Django-guardian: केवल एक विशिष्ट समूह के लिए सदस्य जोड़ें/निकालें

कोई बात नहीं, आपको ऐसी अनुमतियां बनानी होंगी और django-guardian समर्थन के साथ मैन्युअल रूप से एक्सेस कंट्रोल लागू करना होगा।

एक्सेस कंट्रोल पसंद है?

मैं इस कार्यक्षमता को कैसे कार्यान्वित कर सकता हूं?

Django- अभिभावक किसी भी वस्तु के लिए एक अभिगम नियंत्रण पुस्तकालय है। ऐसी वस्तु समूह भी हो सकती है। उदाहरण परियोजना में अभिगम नियंत्रण देखें। देखें https://github.com/django-guardian/django-guardian/blob/devel/example_project/articles/views.py#L35 ।

उत्तम!

यह मेरा स्निपेट कोड है:

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)

मुझे समूह के सभी उपयोगकर्ताओं के लिए जोड़ने/निकालने की अनुमति की आवश्यकता है।

मुझे नहीं पता कि आपको कहां समस्या है। आपको कुछ चाहिए:

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

और बनाए जाने पर समूह को अनुमति प्रदान करें।

मैंने "सदस्य जोड़ सकते हैं" अनुमति जोड़ने की कोशिश की, लेकिन इसलिए यह सभी समूहों के लिए संभव है, न कि कर्मचारियों के लिए।

मुझे यकीन नहीं है कि आपका क्या मतलब है। Django-अभिभावक विशेषाधिकार हमेशा उपयोगकर्ताओं या उपयोगकर्ताओं के समूहों को दिए जाते हैं। भूमिका या विशेष शर्तों के आधार पर विशेषाधिकार देना संभव नहीं है। यदि आप स्टाफ सदस्यों को "X" समूह को प्रबंधित करने की अनुमति देना चाहते हैं, तो "स्टाफ़" समूह बनाएं, उसमें स्टाफ सदस्य जोड़ें, "X" समूह जोड़ें, और "स्टाफ़" समूह को "X" प्रबंधित करने की अनुमति दें समूह।

मुझे ऐसे उपयोगकर्ता की आवश्यकता होगी जो समूह से संबंधित हो
"X" केवल समूह "X" के लिए जोड़ या हटा सकता है, दुर्भाग्य से अब ऐसा नहीं है यदि आपके पास अनुमति है तो "आप उपयोगकर्ताओं को जोड़ सकते हैं" इसे सभी समूहों के लिए कर सकते हैं न कि प्रशिक्षु के लिए।

मेरी खराब इंग्लिश के लिए माफ़ कीजिये

दुर्भाग्य से, मैं आपकी अपेक्षाओं को नहीं समझ सकता। उदाहरण परियोजना की सावधानीपूर्वक जांच करें। ऐसे मामले में यह पर्याप्त होना चाहिए।

"X" can add or remove only for group "X" मतलब:

1. ग्रुप एक्स बनाएं,
2. समूह X के सदस्यों को जोड़ें
3. समूह X को प्रबंधित करने के लिए समूह X की अनुमति असाइन करें।

मुझे वास्तव में यह सुनिश्चित करने की आवश्यकता है कि एक उपयोगकर्ता जो समूह "x" से संबंधित है, वह अपने समूह से केवल अन्य उपयोगकर्ताओं को जोड़ने या हटाने में सक्षम होगा

@ एलन-नावा, django-अभिभावक विशेषाधिकार हमेशा उपयोगकर्ताओं या उपयोगकर्ताओं के समूहों को दिए जाते हैं। भूमिका या विशेष शर्तों के आधार पर विशेषाधिकार देना संभव नहीं है। यदि आप चाहते हैं कि उपयोगकर्ता अपने समूहों का प्रबंधन करें, तो समूह को उस समूह को एक वस्तु के रूप में प्रबंधित करने की अनुमति दें।

क्या आप समझते हैं कि "X" समूह को प्रबंधित करने के लिए "X" समूह की अनुमति कैसे असाइन करें और जांचें?

यह नेटफ्लिक्स जैसा होना चाहिए (लेकिन सभी सदस्यों के पास लॉगिन करने की संभावना है): प्रत्येक उपयोगकर्ता के पास एक व्यक्तिगत समूह होना चाहिए जहां वह अपनी पसंद के अनुसार उपयोगकर्ताओं को जोड़ या हटा सकता है। मुद्दा यह है कि यदि आप यह अनुमति देते हैं तो उपयोगकर्ताओं को जोड़ें, और यह अन्य सभी समूहों को प्रभावित करता है, न कि उन उपयोगकर्ताओं को जो उस समूह से संबंधित हैं

मुद्दा यह है कि यदि आप यह अनुमति देते हैं तो उपयोगकर्ताओं को जोड़ें, और यह अन्य सभी समूहों को प्रभावित करता है, न कि उन उपयोगकर्ताओं को जो उस समूह से संबंधित हैं

यह निश्चित रूप से सच नहीं है। यह वाक्य Django कोर के लिए सही है। यदि आप समूह X के लिए प्रबंधन समूह X को दी गई सही Django-अभिभावक अनुमति का उपयोग कर रहे हैं, तो यह केवल समूह X पर लागू होता है। उदाहरण प्रोजेक्ट की तरह, किसी विशेष लेख को प्रबंधित करने का अधिकार देने का मतलब यह नहीं है कि अन्य लेखों को संपादित किया जा सकता है। उस उपयोगकर्ता द्वारा।

मैं एक एकल अनुमति बनाना चाहता हूं जो सभी उपयोगकर्ताओं को अन्य लोगों को अपने सदस्यता समूह में जोड़ने की अनुमति देता है। हर बार जब मैं अपने सदस्यता समूह 'एक्स' के साथ एक नया उपयोगकर्ता बनाता हूं, तो मैं एक नई अनुमति बनाना चाहता हूं, जिसे 'एक्स के लिए समूह जोड़ सकते हैं' कहा जाता है, और उस अनुमति को समूह 'एक्स' को ऑब्जेक्ट के रूप में रखना होगा।

इस कदर:

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)

असामान्य एक हजार अनुमति का निर्माण है। assign_perm('manage_group',group,group) या assign_perm('manage_group',user,group) यह पर्याप्त होना चाहिए। बाकी यह सत्यापित करना है कि उपयोगकर्ता के पास किसी विशेष समूह को प्रबंधित करने का अधिकार है या नहीं।

ठीक है, लेकिन टेम्पलरी व्यू में मैं कैसे जांच सकता हूं?

{{ perms.groups_manager.canaddmemberx2}}

@ एलन-नावा, फिर से, उदाहरण परियोजना की सावधानीपूर्वक जांच करें, विशेष रूप से टेम्प्लेट और आरटीएफडी ।

@ ad-m ठीक है धन्यवाद, तो मेरा स्निपेट कोड:

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 मैंने इस कोड की कोशिश की, लेकिन मुझे अपवाद मिला।

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

@ एलन-नावा, त्रुटि संदेश में आपको क्या स्पष्ट नहीं है?

@ विज्ञापन-एम
मुझे यह बग मिला:

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

@ एलन-नावा, त्रुटि संदेश में आपको क्या स्पष्ट नहीं है?

@ ad-m मुझे समझ में नहीं आता कि समस्या कहाँ है

@ एलन-नवा, इस तरह की कोई अनुमति नहीं है। डॉक्स पढ़ें क्या अनुमति मौजूद है ।

ठीक है, मैंने पढ़ा है, लेकिन जब मैं एक नया उपयोगकर्ता बनाता हूं तो मुझे एन समूहों/उपयोगकर्ताओं के लिए एन अनुमति बनाने की आवश्यकता होती है?

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,
)

जैसा कि पहले कहा गया

असामान्य एक हजार अनुमति का निर्माण है।

प्रति क्रिया प्रकार एक अनुमति।

जैसा कि पहले कहा गया था:
असामान्य एक हजार अनुमति का निर्माण है।
प्रति क्रिया प्रकार एक अनुमति।

ठीक है, लेकिन मैं सामान्य अनुमति कैसे बना सकता हूं?

जैसा कि Django कोर डॉक्स ने कहा। ऊपर जुड़ा हुआ है।

ठीक है, मैं Django समूह प्रबंधक का उपयोग करता हूं:

यह मेरा मॉडल समूह है :

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'),
        )

और यह मेरा मॉडल प्रोफाइल है :

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-अभिभावक प्रति ऑब्जेक्ट अनुमति प्रबंधन है, इसलिए एकल ऑब्जेक्ट को एकल उपयोगकर्ता/समूह अनुमति प्रदान करें।

ठीक है, लेकिन अभी भी काम नहीं कर रहा है, हालांकि मैंने मॉडल समूह में अनुमति जोड़ी है

क्या काम नहीं करता?

यह रेखा:

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

उदाहरण उपयोगकर्ता वस्तु है लेकिन मैं समूह मॉडल में अनुमति जोड़ता हूं

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

मैंने इस django-groups-manager . का उपयोग किया है

मैं मूर्ख हूँ, मुझे प्रवास करना है और पलायन करना है:

python3 manage.py makemigrations
python3 manage.py migrate

धैर्य के लिए धन्यवाद 👍 @ad-m

लेकिन टेम्प्लेट व्यू में, मैं कैसे जांच सकता हूं?
यह:
jack.has_perm('change_group', admins)

django खोल के साथ यह काम करता है: