Django-guardian: Mitglied nur für eine bestimmte Gruppe hinzufügen/entfernen

Kein Problem, Sie müssen solche Berechtigungen erstellen und die Zugriffskontrolle mit django-guardian-Unterstützung manuell implementieren.

Zugangskontrolle wie?

Wie kann ich diese Funktionalität implementieren?

Django-guardian ist eine Zugriffskontrollbibliothek für jedes Objekt. Solche Objekte können auch Gruppen sein. Siehe Zugangskontrolle im Beispielprojekt. Siehe https://github.com/django-guardian/django-guardian/blob/devel/example_project/articles/views.py#L35 .

Perfekt!

Das ist mein Snippet-Code:

def create_user_profile(sender, instance, created, **kwargs):
    print("create_user_profile")
    try:
        print("created: "+ str(created))
        if created:
            Profile.objects.create(user=instance)
            print("Member.objects.get_or_create(django_user=instance)")
            #Create a user into groups_manager_member
            member = Member.objects.create(django_user=instance, first_name=instance.first_name, last_name=instance.last_name, username=instance.username, email=instance.email)
            print("member instance created")
            print(member)
            print("Group.objects.create(name=ID_GROUP+instance.username)")

            #Create a group into groups_manager_group
            group = Group.objects.create(name=ID_GROUP+instance.username)
            print("group instance created")
            print(group)
            #Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")

    except Exception as e:
        print("Exception: "+str(e))
        pass


def save_user_profile(sender, instance, **kwargs):
    print("save_user_profile")
    try:
        instance.profile.save()

    except Exception as e:
        print("Exception: "+str(e))
        pass

post_save.connect(create_user_profile, sender=User)
post_save.connect(save_user_profile, sender=User)

Ich benötige die Berechtigung zum Hinzufügen/Entfernen für alle Benutzer der Gruppe.

Ich weiß nicht wo du ein Problem hast. Sie brauchen so etwas wie:

class ProtectedGroupUpdateView(PermissionRequiredMixin, GroupUpdateView):
    permission_required = ['change_group', ]
    ...

und weisen Sie der Gruppe beim Erstellen die Berechtigung zu.

Ich habe versucht, die Berechtigung "Mitglied hinzufügen" hinzuzufügen, aber so ist es für alle Gruppen und nicht für Mitarbeiter möglich.

Ich bin mir nicht sicher, was du meinst. Die django-guardian-Privilegien werden immer Benutzern oder Benutzergruppen gewährt. Es ist nicht möglich, Berechtigungen basierend auf Rollen oder besonderen Bedingungen zu vergeben. Wenn Sie Mitarbeitern die Berechtigung zum Verwalten der Gruppe "X" erteilen möchten, erstellen Sie eine Gruppe "Mitarbeiter", fügen Sie Mitarbeiter hinzu, fügen Sie die Gruppe "X" hinzu und erteilen Sie der Gruppe "Mitarbeiter" die Berechtigung zum Verwalten von "X". Gruppe.

Ich bräuchte einen Benutzer, der zu einer Gruppe gehört
"X" kann nur für die Gruppe "X" hinzufügen oder entfernen, leider ist es jetzt nicht so, wenn Sie die Berechtigung "Sie können Benutzer hinzufügen" haben, können Sie dies für alle Gruppen tun und nicht für die des Lehrlings.

Entschuldigung für mein schlechtes Englisch

Leider kann ich deine Erwartungen nicht nachvollziehen. Untersuchen Sie das Beispielprojekt sorgfältig. Dies sollte in einem solchen Fall ausreichen.

"X" can add or remove only for group "X" bedeuten:

1. Gruppe X erstellen,
2. Mitglieder der Gruppe X hinzufügen
3. Weisen Sie Gruppe X die Berechtigung zu, Gruppe X zu verwalten.

Ich muss tatsächlich sicherstellen, dass ein Benutzer, der zu einer Gruppe "x" gehört, nur andere Benutzer zu seiner eigenen Gruppe hinzufügen oder daraus entfernen kann

@Allan-Nava , Die Django-Guardian-Berechtigungen werden immer Benutzern oder Benutzergruppen gewährt. Es ist nicht möglich, Berechtigungen basierend auf Rollen oder besonderen Bedingungen zu vergeben. Wenn Sie möchten, dass Benutzer ihre Gruppen verwalten, erteilen Sie der Gruppe die Berechtigung, diese Gruppe als Objekt zu verwalten.

Verstehen Sie, wie Sie die Gruppenberechtigung "X" zuweisen und überprüfen, um die Gruppe "X" zu verwalten?

Es sollte wie Netflix sein (aber alle Mitglieder haben die Möglichkeit sich einzuloggen): Jeder Benutzer sollte eine persönliche Gruppe haben, in der er die Benutzer nach seinen Wünschen hinzufügen oder entfernen kann. Das Problem ist, dass, wenn Sie diese Berechtigung erteilen, Benutzer hinzufügen, und dies beeinflusst alle anderen Gruppen, nicht Benutzer, die zu dieser gehören

Das Problem ist, dass, wenn Sie diese Berechtigung erteilen, Benutzer hinzufügen, und dies beeinflusst alle anderen Gruppen, nicht Benutzer, die zu dieser gehören

Es ist definitiv nicht wahr. Dieser Satz gilt für Django-Kern. Wenn Sie die richtige Django-Wächter-Berechtigung verwenden, die der Verwaltungsgruppe X für die Gruppe X gewährt wurde, gilt nur für Gruppe X. Wie in einem Beispielprojekt bedeutet die Vergabe des Rechts zum Verwalten eines bestimmten Artikels nicht, dass andere Artikel bearbeitet werden können von diesem Benutzer.

Ich möchte eine einzelne Berechtigung erstellen, die es allen Benutzern ermöglicht, andere Personen zu ihrer Mitgliedergruppe hinzuzufügen. Jedes Mal, wenn ich einen neuen Benutzer mit seiner Mitgliedschaftsgruppe 'X' erstelle, möchte ich eine neue Berechtigung namens 'Kann Gruppe für X hinzufügen' erstellen, und diese Berechtigung muss die Gruppe 'X' als Objekt haben.

So was:

def create_user_profile(sender, instance, created, **kwargs):
    print("create_user_profile")
    try:
        print("created: "+ str(created))
        if created:
            Profile.objects.create(user=instance)
            print("Member.objects.get_or_create(django_user=instance)")
            #Create a user into groups_manager_member
            member = Member.objects.create(django_user=instance, first_name=instance.first_name, last_name=instance.last_name, username=instance.username, email=instance.email)
            print("member instance created")
            print(member)
            print("Group.objects.create(name=ID_GROUP+instance.username)")

            #Create a group into groups_manager_group
            group = Group.objects.create(name=ID_GROUP+instance.username)
            print("group instance created")
            print(group)
            #Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")
            UserObjectPermission.objects.assign_perm('can_add_member_for_xgroup', member, obj=group)

    except Exception as e:
        print("Exception: "+str(e))
        pass


def save_user_profile(sender, instance, **kwargs):
    print("save_user_profile")
    try:
        instance.profile.save()

    except Exception as e:
        print("Exception: "+str(e))
        pass

post_save.connect(create_user_profile, sender=User)
post_save.connect(save_user_profile, sender=User)

Abnormal ist die Erstellung von tausend Berechtigungen. assign_perm('manage_group',group,group) oder assign_perm('manage_group',user,group) es sollte reichen. Der Rest besteht darin, zu überprüfen, ob der Benutzer berechtigt ist, eine bestimmte Gruppe zu verwalten.

Ok, perfekt, aber wie kann ich in der Templar-Ansicht überprüfen?

{{ perms.groups_manager.canaddmemberx2}}

@Allan-Nava , überprüfen Sie das Beispielprojekt erneut sorgfältig, insbesondere Vorlagen und RTFD .

@ad-m Ok danke, also mein Snippet-Code:

from guardian.shortcuts import assign_perm

def create_user_profile(sender, instance, created, **kwargs):
    print("create_user_profile")
    try:
        print("created: "+ str(created))
        if created:
            Profile.objects.create(user=instance)
            print("Member.objects.get_or_create(django_user=instance)")
            #Create a user into groups_manager_member
            member = Member.objects.create(django_user=instance, first_name=instance.first_name, last_name=instance.last_name, username=instance.username, email=instance.email)
            print("member instance created")
            print(member)
            print("Group.objects.create(name=ID_GROUP+instance.username)")

            #Create a group into groups_manager_group
            group = Group.objects.create(name=ID_GROUP+instance.username)
            print("group instance created")
            print(group)
            #Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")
            #UserObjectPermission.objects.assign_perm('can_add_member_for_xgroup', member, obj=group)
            assign_perm('groups_manager.can_add_member_custom', member, group)

    except Exception as e:
        print("Exception: "+str(e))
        pass


def save_user_profile(sender, instance, **kwargs):
    print("save_user_profile")
    try:
        instance.profile.save()

    except Exception as e:
        print("Exception: "+str(e))
        pass

post_save.connect(create_user_profile, sender=User)
post_save.connect(save_user_profile, sender=User)

@ad-m Ich habe diesen Code ausprobiert, aber ich habe eine Ausnahme erhalten.

#Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")

            #Assign permission for the groups
            assign_perm('groups_manager.can_add_member_custom', member, group)
            print("assign_perm('groups_manager.can_add_member_custom', member, group)")

@Allan-Nava , was ist dir in der Fehlermeldung nicht klar?

@ad-m
Ich habe diesen Fehler:

def create_user_profile(sender, instance, created, **kwargs):
    print("create_user_profile")
    try:
        print("created: "+ str(created))
        if created:
            Profile.objects.create(user=instance)
            print("Member.objects.get_or_create(django_user=instance)")
            #Create a user into groups_manager_member
            member = Member.objects.create(django_user=instance, first_name=instance.first_name, last_name=instance.last_name, username=instance.username, email=instance.email)
            print("member instance created")
            print(member)
            print("Group.objects.create(name=ID_GROUP+instance.username)")

            #Create a group into groups_manager_group
            group = Group.objects.create(name=ID_GROUP+instance.username)
            print("group instance created")
            print(group)
            #Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")

            #Assign permission for the groups
            assign_perm('groups_manager.can_add_member_custom', instance, group)
            print("assign_perm('groups_manager.can_add_member_custom', instance, group)")

    except Exception as e:
        print("Exception: "+str(e))
        pass

@Allan-Nava , was ist dir in der Fehlermeldung nicht klar?

@ad-m Ich verstehe nicht wo das Problem ist

@Allan-Nava , diese Art von Erlaubnis gibt es nicht. Lesen Sie die Dokumente, welche Berechtigungen vorhanden sind .

Ok, ich habe gelesen, aber ich muss N Berechtigungen für N Gruppen/Benutzer erstellen, wenn ich einen neuen Benutzer erstelle?

content_type = ContentType.objects.get_for_model(Group)
permission = Permission.objects.create(
    codename='can_add_member_custom',
    name='Can Add Member Custom',
    content_type=content_type,
)

Wie gesagt vor :

Abnormal ist die Erstellung von tausend Berechtigungen.

Eine Berechtigung pro Aktionstyp.

Wie schon gesagt:
Abnormal ist die Erstellung von tausend Berechtigungen.
Eine Berechtigung pro Aktionstyp.

Ok, aber wie kann ich die allgemeine Berechtigung erstellen?

Wie die Kerndokumente von Django sagten. Oben verlinkt.

Ok, ich benutze den Django Groups Manager:

Das ist mein Modell Gruppen:

class Group(GroupMixin):

    group_type = models.ForeignKey(GroupType, null=True, blank=True, on_delete=models.SET_NULL,
                                   related_name='%(app_label)s_%(class)s_set')
    group_entities = models.ManyToManyField(GroupEntity, blank=True,
                                            related_name='%(app_label)s_%(class)s_set')

    django_group = models.ForeignKey(DjangoGroup, null=True, blank=True, on_delete=models.SET_NULL)
    group_members = models.ManyToManyField(Member, through='GroupMember',
                                           related_name='%(app_label)s_%(class)s_set')

    # this is just required for easy explanation
    class Meta(GroupMixin.Meta):
        abstract = False
        permissions = (
            ('can_add_member_custom', 'Can Add Member Custom'),
        )

Und das ist mein Modell Profil:

from __future__ import unicode_literals

import hashlib
import os.path
import urllib

from django.conf import settings
from django.contrib.auth.models import User
from django.db import models
from django.db.models.signals import post_save
from django.utils.encoding import python_2_unicode_compatible

from bootcamp.activities.models import Notification
#Custom class - ParentsProfile
from bootcamp.parents.models import ParentsProfile
#Custom class - MemberMixin TO CREATE INTO groups_manager_member
from bootcamp.groups_manager.models import MemberMixin, Member, Group
#Import django guardian assign_perm
from guardian.shortcuts import assign_perm
#import UserObjectPermission
from guardian.models import UserObjectPermission

import datetime

ID_GROUP = "Group_"

'''
User Model - Authentication
'''
<strong i="12">@python_2_unicode_compatible</strong>
class Profile(models.Model):
    user = models.OneToOneField(User)
    location = models.CharField(max_length=50, null=True, blank=True)
    url = models.CharField(max_length=50, null=True, blank=True)
    job_title = models.CharField(max_length=50, null=True, blank=True)

    #I need to delete the parents application

    #Other tascout attributes
    birthdate = models.DateField(default=datetime.date.today)
    address = models.CharField(max_length=255, null=True, blank=True)
    main_role = models.CharField(max_length=255, null=True, blank=True)
    other_roles = models.CharField(max_length=255, null=True, blank=True)
    mobile = models.CharField(max_length=255, null=True, blank=True)
    background_photo = models.CharField(max_length=255, null=True, blank=True)
    profile_photo = models.CharField(max_length=255, null=True, blank=True)
    biography = models.TextField(null=True, blank=True)
    idols = models.TextField(null=True, blank=True)
    weight = models.IntegerField(default=0)
    height = models.IntegerField(default=0)
    favorite_team = models.CharField(max_length=255, null=True, blank=True)
    level = models.IntegerField(default=0)
    sex = models.CharField(max_length=1, default="M")
    nationality = models.CharField(max_length=255, null=True, blank=True)
    city = models.CharField(max_length=255, null=True, blank=True)
    postal_code = models.CharField(max_length=255, null=True, blank=True)
    province = models.CharField(max_length=255, null=True, blank=True)
    number = models.CharField(max_length=255, null=True, blank=True)
    latitude = models.DecimalField( null=True, blank=True, max_digits=9, decimal_places=6)
    longitude = models.DecimalField( null=True, blank=True, max_digits=9, decimal_places=6)

    class Meta:
        db_table = 'auth_profile'

    def __str__(self):
        return self.user.username

    def get_url(self):
        url = self.url
        if "http://" not in self.url and "https://" not in self.url and len(self.url) > 0:  # noqa: E501
            url = "http://" + str(self.url)

        return url

    def get_picture(self):
        no_picture = settings.MEDIA_URL +'/profile_pictures/user.png'
        try:
            filename = settings.MEDIA_ROOT + '/profile_pictures/' +\
                self.user.username + '.jpg'
            picture_url = settings.MEDIA_URL + 'profile_pictures/' +\
                self.user.username + '.jpg'
            if os.path.isfile(filename):  # pragma: no cover
                return picture_url
            else:  # pragma: no cover
                gravatar_url = 'http://www.gravatar.com/avatar/{0}?{1}'.format(
                    hashlib.md5(self.user.email.lower()).hexdigest(),
                    urllib.urlencode({'d': no_picture, 's': '256'})
                    )
                return gravatar_url

        except Exception:
            return no_picture

    #Retrieve users' cover
    def get_cover(self):
        no_cover = settings.MEDIA_ROOT +'profile_covers/cover.jpg'
        try:
            filename = settings.MEDIA_ROOT + '/profile_covers/' +\
                self.user.username + '.jpg'
            cover_url = settings.MEDIA_URL + 'profile_covers/' +\
                self.user.username + '.jpg'
            if os.path.isfile(filename) and os.path.exists(filename):  # pragma: no cover
                if cover_url != None:
                    return cover_url
                else:
                    return no_cover
            else:
                no_cover
        except Exception:
            return no_cover

    def get_screen_name(self):
        try:
            if self.user.get_full_name():
                return self.user.get_full_name()
            else:
                return self.user.username
        except:
            return self.user.username

    def notify_liked(self, feed):
        if self.user != feed.user:
            Notification(notification_type=Notification.LIKED,
                         from_user=self.user, to_user=feed.user,
                         feed=feed).save()

    def unotify_liked(self, feed):
        if self.user != feed.user:
            Notification.objects.filter(notification_type=Notification.LIKED,
                                        from_user=self.user, to_user=feed.user,
                                        feed=feed).delete()

    def notify_commented(self, feed):
        if self.user != feed.user:
            Notification(notification_type=Notification.COMMENTED,
                         from_user=self.user, to_user=feed.user,
                         feed=feed).save()

    def notify_also_commented(self, feed):
        comments = feed.get_comments()
        users = []
        for comment in comments:
            if comment.user != self.user and comment.user != feed.user:
                users.append(comment.user.pk)

        users = list(set(users))
        for user in users:
            Notification(notification_type=Notification.ALSO_COMMENTED,
                         from_user=self.user,
                         to_user=User(id=user), feed=feed).save()

    def notify_favorited(self, question):
        if self.user != question.user:
            Notification(notification_type=Notification.FAVORITED,
                         from_user=self.user, to_user=question.user,
                         question=question).save()

    def unotify_favorited(self, question):
        if self.user != question.user:
            Notification.objects.filter(
                notification_type=Notification.FAVORITED,
                from_user=self.user,
                to_user=question.user,
                question=question).delete()

    def notify_answered(self, question):
        if self.user != question.user:
            Notification(notification_type=Notification.ANSWERED,
                         from_user=self.user,
                         to_user=question.user,
                         question=question).save()

    def notify_accepted(self, answer):
        if self.user != answer.user:
            Notification(notification_type=Notification.ACCEPTED_ANSWER,
                         from_user=self.user,
                         to_user=answer.user,
                         answer=answer).save()

    def unotify_accepted(self, answer):
        if self.user != answer.user:
            Notification.objects.filter(
                notification_type=Notification.ACCEPTED_ANSWER,
                from_user=self.user,
                to_user=answer.user,
                answer=answer).delete()

def create_user_profile(sender, instance, created, **kwargs):
    print("create_user_profile")
    try:
        print("created: "+ str(created))
        if created:
            Profile.objects.create(user=instance)
            print("Member.objects.get_or_create(django_user=instance)")
            #Create a user into groups_manager_member
            member = Member.objects.create(django_user=instance, first_name=instance.first_name, last_name=instance.last_name, username=instance.username, email=instance.email)
            print("member instance created")
            print(member)
            print("Group.objects.create(name=ID_GROUP+instance.username)")

            #Create a group into groups_manager_group
            group = Group.objects.create(name=ID_GROUP+instance.username)
            print("group instance created")
            print(group)
            #Add member into the group correct
            group.add_member(member=member)
            print("member added into the group correct")

            #Assign permission for the groups
            assign_perm('can_add_member_custom', instance, group)
            #print("assign_perm('can_add_member_custom', instance, group)")

    except Exception as e:
        print("Exception: "+str(e))
        pass


def save_user_profile(sender, instance, **kwargs):
    print("save_user_profile")
    try:
        instance.profile.save()

    except Exception as e:
        print("Exception: "+str(e))
        pass

post_save.connect(create_user_profile, sender=User)
post_save.connect(save_user_profile, sender=User)

Django-Guardian ist eine Einzelobjekt-Berechtigungsverwaltung, also gewähren Sie einem einzelnen Benutzer/einer Gruppe die Berechtigung für ein einzelnes Objekt.

Ok perfekt, aber immer noch nicht funktioniert , obwohl ich die Erlaubnis , in Modell - Gruppe hinzugefügt

Was funktioniert nicht?

Diese Linie:

#Assign permission for the groups
            assign_perm('can_add_member_custom', instance, group)
            print("assign_perm('can_add_member_custom', instance, group)")

-Instanz ist das Benutzerobjekt, aber ich füge dem Gruppenmodell die Berechtigung hinzu

# this is just required for easy explanation
    class Meta(GroupMixin.Meta):
        abstract = False
        permissions = (
            ('can_add_member_custom', 'Can Add Member Custom'),
        )

Ich habe diesen django-groups-manager verwendet

Ich bin dumm, ich muss Migrationen machen und migrieren:

python3 manage.py makemigrations
python3 manage.py migrate

Danke für Geduld 👍 @ad-m

Aber wie kann ich in der Vorlagenansicht überprüfen?
Dies:
jack.has_perm('change_group', admins)

Mit der Django-Shell funktioniert es: