Wie überprüfe ich in Django, ob sich ein Benutzer in einer bestimmten Gruppe befindet?

Ich habe eine benutzerdefinierte Gruppe auf der Administrationsseite von Django erstellt.

In meinem Code möchte ich überprüfen, ob sich ein Benutzer in dieser Gruppe befindet. Wie mache ich das?

Sie können einfach über das groupsAttribut auf auf die Gruppen zugreifen 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

user.groups.all()kehrt dann zurück [<Group: Editor>].

Alternativ und direkter können Sie überprüfen, ob sich ein Benutzer in einer Gruppe befindet, indem Sie:

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

    ...

Beachten Sie, dass groupnamedies auch das eigentliche Django Group-Objekt sein kann.

Ihr Benutzerobjekt wird mit dem verknüpften Gruppe Objekt durch eine ManyToMany Beziehung.

Sie können damit die Filtermethode auf user.groups anwenden .

Um zu überprüfen, ob sich ein bestimmter Benutzer in einer bestimmten Gruppe befindet (im Beispiel "Mitglied"), gehen Sie wie folgt vor:

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

Wenn Sie überprüfen möchten, ob ein bestimmter Benutzer zu mehr als einer bestimmten Gruppe gehört, verwenden Sie den Operator __in wie folgt :

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

Beachten Sie, dass diese Funktionen mit dem Dekorator @user_passes_test verwendet werden können , um den Zugriff auf Ihre Ansichten zu verwalten:

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

Ich hoffe das hilft

Wenn Sie die Liste der Benutzer in einer Gruppe benötigen, können Sie dies folgendermaßen tun:

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

und dann überprüfen

 if user in users_in_group:
     # do something

um zu überprüfen, ob der Benutzer in der Gruppe ist.

Wenn Sie die Benutzerinstanz nicht vor Ort benötigen (wie ich), können Sie dies tun

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

Dies erzeugt nur eine Anforderung an die Datenbank und gibt einen Booleschen Wert zurück.

Ob ein Benutzer einer bestimmten Gruppe angehört oder nicht, kann in Django-Vorlagen überprüft werden mit:

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

Sie brauchen nur eine Zeile:

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!")

Nur für den Fall, dass Sie überprüfen möchten, ob die Benutzergruppe zu einer vordefinierten Gruppenliste gehört:

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

Ich habe eine ähnliche Situation, ich wollte testen, ob der Benutzer in einer bestimmten Gruppe ist. Also habe ich eine neue Datei utils.py erstellt, in der ich alle meine kleinen Dienstprogramme ablege, die mir bei der gesamten Anwendung helfen. Dort habe ich diese Definition:

utils.py

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

Im Grunde teste ich, ob sich der Benutzer in der Gruppe company_admin befindet, und aus Gründen der Übersichtlichkeit habe ich diese Funktion is_company_admin genannt .

Wenn ich überprüfen möchte, ob sich der Benutzer in der Datei company_admin befindet, gehe ich einfach folgendermaßen vor:

views.py

from .utils import *

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

Wenn Sie dasselbe in Ihrer Vorlage testen möchten, können Sie is_user_admin in Ihrem Kontext hinzufügen.

views.py

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

Jetzt können Sie Ihre Antwort in einer Vorlage auswerten:

users.html

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

Einfache und saubere Lösung, basierend auf Antworten, die früher in diesem Thread zu finden sind, aber anders gemacht werden. Hoffe es wird jemandem helfen.

Getestet in Django 3.0.4.

In einer Zeile:

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

Dies ergibt entweder Trueoder False.

Ich habe es folgendermaßen gemacht. Scheint ineffizient, aber ich hatte keinen anderen Weg im Kopf:

@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()

Diese Abfrage informiert den Benutzer: "tom", ob er zur Gruppe "admin" gehört oder nicht

Ich habe es so gemacht. Für die Gruppe mit dem Namen 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)

Vorlage

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