Dans Django, comment vérifier si un utilisateur fait partie d'un certain groupe?

J'ai créé un groupe personnalisé sur le site d'administration de Django.

Dans mon code, je veux vérifier si un utilisateur fait partie de ce groupe. Comment je fais ça?

Vous pouvez accéder aux groupes simplement via l' groupsattribut sur User.

from django.contrib.auth.models import User, Group

group = Group(name = "Editor")
group.save()                    # save this new group for this example
user = User.objects.get(pk = 1) # assuming, there is one initial user 
user.groups.add(group)          # user is now in the "Editor" group

puis user.groups.all()revient [<Group: Editor>].

Alternativement, et plus directement, vous pouvez vérifier si un utilisateur est dans un groupe en:

if django_user.groups.filter(name = groupname).exists():

    ...

Notez qu'il groupnamepeut également s'agir de l'objet Django Group réel.

Votre objet User est lié à l' objet Group via une relation ManyToMany .

Vous pouvez ainsi appliquer la méthode de filtrage à user.groups .

Donc, pour vérifier si un utilisateur donné est dans un certain groupe ("Membre" pour l'exemple), il suffit de faire ceci:

def is_member(user):
    return user.groups.filter(name='Member').exists()

Si vous voulez vérifier si un utilisateur donné appartient à plus d'un groupe donné, utilisez l' opérateur __in comme ceci:

def is_in_multiple_groups(user):
    return user.groups.filter(name__in=['group1', 'group2']).exists()

Notez que ces fonctions peuvent être utilisées avec le décorateur @user_passes_test pour gérer l'accès à vos vues:

from django.contrib.auth.decorators import login_required, user_passes_test
@login_required
@user_passes_test(is_member) # or @user_passes_test(is_in_multiple_groups)
def myview(request):
    # Do your processing

J'espère que cette aide

Si vous avez besoin de la liste des utilisateurs appartenant à un groupe, vous pouvez le faire à la place:

from django.contrib.auth.models import Group
users_in_group = Group.objects.get(name="group name").user_set.all()

puis vérifiez

 if user in users_in_group:
     # do something

pour vérifier si l'utilisateur fait partie du groupe.

Si vous n'avez pas besoin de l'instance utilisateur sur le site (comme je l'ai fait), vous pouvez le faire avec

User.objects.filter(pk=userId, groups__name='Editor').exists()

Cela produira une seule requête à la base de données et retournera un booléen.

Si un utilisateur appartient ou non à un certain groupe, peut être vérifié dans les modèles django en utilisant:

{% if group in request.user.groups.all %} "some action" {% endif %}

Vous avez juste besoin d'une ligne:

from django.contrib.auth.decorators import user_passes_test  

@user_passes_test(lambda u: u.groups.filter(name='companyGroup').exists())
def you_view():
    return HttpResponse("Since you're logged in, you can see this text!")

Juste au cas où vous voudriez vérifier que le groupe de l'utilisateur appartient à une liste de groupes prédéfinie:

def is_allowed(user):
    allowed_group = set(['admin', 'lead', 'manager'])
    usr = User.objects.get(username=user)
    groups = [ x.name for x in usr.groups.all()]
    if allowed_group.intersection(set(groups)):
       return True
    return False

J'ai une situation similaire, je voulais tester si l'utilisateur est dans un certain groupe. J'ai donc créé un nouveau fichier utils.py dans lequel j'ai mis tous mes petits utilitaires qui m'aident à travers toute l'application. Là, j'ai cette définition:

utils.py

def is_company_admin(user):
    return user.groups.filter(name='company_admin').exists()

Donc, fondamentalement, je teste si l'utilisateur est dans le groupe company_admin et pour plus de clarté, j'ai appelé cette fonction is_company_admin .

Lorsque je veux vérifier si l'utilisateur est dans company_admin, je fais simplement ceci:

views.py

from .utils import *

if is_company_admin(request.user):
        data = Company.objects.all().filter(id=request.user.company.id)

Maintenant, si vous souhaitez tester la même chose dans votre modèle, vous pouvez ajouter is_user_admin dans votre contexte, quelque chose comme ceci:

views.py

return render(request, 'admin/users.html', {'data': data, 'is_company_admin': is_company_admin(request.user)})

Vous pouvez maintenant évaluer votre réponse dans un modèle:

users.html

{% if is_company_admin %}
     ... do something ...
{% endif %}

Solution simple et propre, basée sur des réponses qui peuvent être trouvées plus tôt dans ce fil, mais faites différemment. J'espère que cela aidera quelqu'un.

Testé dans Django 3.0.4.

En une seule ligne:

'Groupname' in user.groups.values_list('name', flat=True)

Cela évalue soit Trueou False.

Je l'ai fait de la manière suivante. Cela semble inefficace mais je n'avais pas d'autre moyen dans mon esprit:

@login_required
def list_track(request):

usergroup = request.user.groups.values_list('name', flat=True).first()
if usergroup in 'appAdmin':
    tracks = QuestionTrack.objects.order_by('pk')
    return render(request, 'cmit/appadmin/list_track.html', {'tracks': tracks})

else:
    return HttpResponseRedirect('/cmit/loggedin')

User.objects.filter(username='tom', groups__name='admin').exists()

Cette requête vous informera de l'utilisateur: "tom", qu'il appartienne ou non au groupe "admin"

Je l'ai fait comme ça. Pour le groupe nommé Editor.

# views.py
def index(request):
    current_user_groups = request.user.groups.values_list("name", flat=True)
    context = {
        "is_editor": "Editor" in current_user_groups,
    }
    return render(request, "index.html", context)

modèle

# index.html
{% if is_editor %}
  <h1>Editor tools</h1>
{% endif %}