Django REPOS cadre de l'objet des autorisations de niveau

Je suis en utilisant Django REPOS Cadre d'accéder à une ressource 'utilisateur'.

Que l'utilisateur l'information qui est personnel, je ne veux pas d'une requête GET à la liste de tous les utilisateurs du système, SAUF si elles sont un admin.

Si l'utilisateur spécifie une pièce d'identité, et ils sont connecté, je voudrais être en mesure de visualiser leurs données et de les modifier (METTRE des POST SUPPRIMER) si nécessaire.

Donc en résumé, dis-permettre à méthode GET pour quelqu'un qui n'est pas un admin et GET POST SUPPRIMER METTRE sur les utilisateurs connectés lors de l'affichage de leurs informations.

j'ai donc créé la coutume d'autorisation classe:

class UserPermissions(permissions.BasePermission):
    """
    Owners of the object or admins can do anything.
    Everyone else can do nothing.
"""

    def has_permission(self, request, view):
        # if admin: True otherwise False
    def has_object_permission(self, request, view, obj):
        # if request.user is the same user that is contained within the obj then allow

Cela n'a pas fonctionné. Après un peu de débogage, j'ai trouvé qu'il vérifie has_permission d'abord, PUIS vérifie has_object_permission. Donc, si nous n'avons pas obtenir passé ce premier obstacle OBTENIR /utilisateur/, alors il n'est pas même envisager la prochaine GET /utilisateur/id.

donc En résumé, personne ne sait comment s'y prendre pour que cela fonctionne?

Merci 🙂

EDIT:

J'ai été en utilisant ModelViewSets, qui ont ce problème comme je l'ai décrit.

Mais si vous divisez la fonctionnalité de Liste avec le Détail ensuite, vous pouvez leur donner une autre autorisation classes:

class UserList(generics.ListCreateAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes=(UserPermissionsAll,)

class UserDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes=(UserPermissionsObj,)

class UserPermissionsAll(permissions.BasePermission):
"""
Owners of the object or admins can do anything.
Everyone else can do nothing.
"""

    def has_permission(self, request, view):
        if request.user.is_staff:
            return True
        else:
            return False

class UserPermissionsObj(permissions.BasePermission):
"""
Owners of the object or admins can do anything.
Everyone else can do nothing.
"""

    def has_object_permission(self, request, view, obj):
        if request.user.is_staff:
            return True

        return obj == request.user

La solution ci-dessous à partir de produits Chimiques Programmeur travaillera avec viewsets.

InformationsquelleAutor user1830568 | 2013-09-05

Je l'ai fait dans le passé en utilisant une autorisation personnalisée et remplacé has_object_permission comme suit:

from rest_framework import permissions


class MyUserPermissions(permissions.BasePermission):
    """
    Handles permissions for users.  The basic rules are

     - owner may GET, PUT, POST, DELETE
     - nobody else can access
     """

    def has_object_permission(self, request, view, obj):

        # check if user is owner
        return request.user == obj

Vous pouvez faire un peu plus détaillée des choses telles que de refuser une demande spécifique de types (par exemple pour permettre d'OBTENIR les demandes de tous les utilisateurs):

class MyUserPermissions(permissions.BasePermission):

    def has_object_permission(self, request, view, obj):

        # Allow get requests for all
        if request.method == 'GET':
            return True
        return request.user == obj

Alors à votre avis que vous donnez à utiliser les autorisations de classe:

from my_custom_permissions import MyUserPermissions

class UserView(generics.ListCreateAPIView):
    ...
    permission_classes = (MyUserPermissions, )
    ...

InformationsquelleAutor will-hart

J'ai un besoin similaire. Permet d'appeler mon app x. Voici ce que j'ai trouvé.

D'abord, mettez ceci dans x/viewsets.py:

# viewsets.py
from rest_framework import mixins, viewsets

class DetailViewSet(
  mixins.CreateModelMixin,
  mixins.RetrieveModelMixin,
  mixins.UpdateModelMixin,
  mixins.DestroyModelMixin,
  viewsets.GenericViewSet):
    pass

class ReadOnlyDetailViewSet(
  mixins.RetrieveModelMixin,
  viewsets.GenericViewSet):
    pass

class ListViewSet(
  mixins.ListModelMixin,
  viewsets.GenericViewSet):
    pass

Puis dans x/permissions.py:

# permissions.py
from rest_framework import permissions

class UserIsOwnerOrAdmin(permissions.BasePermission):
    def has_permission(self, request, view):
        return request.user and request.user.is_authenticated()

    def check_object_permission(self, user, obj):
        return (user and user.is_authenticated() and
          (user.is_staff or obj == user))

    def has_object_permission(self, request, view, obj):
        return self.check_object_permission(request.user, obj)

Puis dans x/views.py:

# views.py
from x.viewsets import DetailViewSet, ListViewSet
from rest_framework import permissions

class UserDetailViewSet(DetailViewSet):
    queryset = User.objects.all()
    serializer_class = UserDetailSerializer
    permission_classes = (UserIsOwnerOrAdmin,)

class UserViewSet(ListViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes (permissions.IsAdminUser,)

En passant, notez que vous pouvez utiliser un différents sérialiseur pour ces deux viewsets, ce qui signifie que vous pouvez afficher différents attributs dans le list vue que dans le retrieve vue! Par exemple:

# serializers.py
class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ('username', 'url',)

class UserDetailSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ('url', 'username', 'groups', 'profile', 'password',)
        write_only_fields = ('password',)

Puis dans x/urls.py:

# urls.py
from x import views
from rest_framework import routers

router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
router.register(r'users', views.UserDetailViewSet)

...

J'ai été légèrement surpris de voir que router accepté le même modèle à deux reprises, mais il ne semble fonctionner.

Caveat lector: j'ai confirmé tout cela fonctionne via l'API du navigateur, mais je n'ai pas essayé mise à jour via l'API encore.

J'aime cette approche, vous n'avez même pas besoin de créer des classes moyennes comme DetailViewSet ou ListViewSet. Et il fait de définir les permissions beaucoup plus facile.

InformationsquelleAutor Tim Ruddick

9

Pour le faux upons, le la documentation dans les restrictions de niveau de l'objet de l'autorisation dit:
```
For performance reasons the generic views will not automatically apply object level permissions to each instance in a queryset when returning a list of objects.
```
Donc, la vue détails fonctionne, mais pour la liste, vous aurez besoin de filtre à contre-courant de l'utilisateur.

InformationsquelleAutor keni

Juste une chose à @will-hart réponse.

Dans DRF3 documentation,

Remarque: Le niveau de l'instance has_object_permission méthode sera appelée uniquement si le point de vue du niveau has_permission contrôles ont déjà passé

Par conséquent, has_permission doit être spécifié à utiliser has_object_permission.

from rest_framework import permissions

class MyUserPermissions(permissions.BasePermission):

    def has_permission(self, request, view):
        return True

    def has_object_permission(self, request, view, obj):
        return request.user == obj

Toutefois, le code ci-dessus donne la permission à personne lorsque l'utilisateur tente de récupérer la liste de l'utilisateur. Dans ce cas, il serait préférable de donner la permission selon action, pas la HTTP method.

from rest_framework import permissions

def has_permission(self, request, view):
    if request.user.is_superuser:
        return True
    elif view.action == 'retrieve':
        return True
    else:
        return False

def has_object_permission(self, request, view, obj):
    if request.user.is_superuser:
        return True
    elif view.action == 'retrieve':
        return obj == request.user or request.user.is_staff

Pour définir des autorisations complexes, c'est une sorte de cauchemar. Est-il un meilleur moyen ?

InformationsquelleAutor Chemical Programmer

Vous devez vous connecter pour publier un commentaire.