In Django, come posso verificare se un utente appartiene a un determinato gruppo?

Ho creato un gruppo personalizzato nel sito di amministrazione di Django.

Nel mio codice, voglio verificare se un utente è in questo gruppo. Come lo faccio?

Puoi accedere ai gruppi semplicemente tramite l' groupsattributo on 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

quindi user.groups.all()ritorna [<Group: Editor>].

In alternativa, e più direttamente, puoi verificare se un utente è in un gruppo:

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

    ...

Nota che groupnamepuò essere anche l'oggetto reale del gruppo Django.

L' oggetto Utente è collegato all'oggetto Gruppo tramite una relazione ManyToMany .

È quindi possibile applicare il metodo di filtro a user.groups .

Quindi, per verificare se un determinato Utente appartiene a un determinato gruppo ("Membro" per l'esempio), basta fare questo:

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

Se si desidera verificare se un determinato utente appartiene a più di un determinato gruppo, utilizzare l' operatore __in in questo modo:

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

Nota che queste funzioni possono essere utilizzate con il decoratore @user_passes_test per gestire l'accesso alle tue viste:

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

Spero che questo aiuto

Se hai bisogno dell'elenco di utenti che fanno parte di un gruppo, puoi invece farlo:

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

e poi controlla

 if user in users_in_group:
     # do something

per verificare se l'utente è nel gruppo.

Se non hai bisogno dell'istanza utente sul sito (come ho fatto io), puoi farlo con

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

Ciò produrrà una sola richiesta al database e restituirà un valore booleano.

Se un utente appartiene o meno a un determinato gruppo, può essere verificato nei modelli di django usando:

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

Hai solo bisogno di una riga:

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

Nel caso in cui si desideri verificare che il gruppo dell'utente appartenga a un elenco di gruppi predefinito:

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

Ho una situazione simile, volevo verificare se l'utente appartiene a un determinato gruppo. Quindi, ho creato un nuovo file utils.py dove ho inserito tutte le mie piccole utility che mi aiutano attraverso l'intera applicazione. Ecco, ho questa definizione:

utils.py

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

quindi sostanzialmente sto testando se l'utente è nel gruppo company_admin e per chiarezza ho chiamato questa funzione is_company_admin .

Quando voglio verificare se l'utente è in company_admin, faccio solo questo:

views.py

from .utils import *

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

Ora, se desideri provare lo stesso nel tuo modello, puoi aggiungere is_user_admin nel tuo contesto, qualcosa del genere:

views.py

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

Ora puoi valutare la tua risposta in un modello:

users.html

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

Soluzione semplice e pulita, basata su risposte che possono essere trovate in precedenza in questo thread, ma fatte in modo diverso. Spero che possa aiutare qualcuno.

Testato in Django 3.0.4.

In una riga:

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

Questo valuta uno Trueo False.

L'ho fatto nel modo seguente. Sembra inefficiente ma non avevo altro modo di pensare:

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

Quella query informerà l'utente: "tom" se appartiene o meno al gruppo "admin"

L'ho fatto così. Per il gruppo denominato 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)

modello

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