Django rest framework-pro-Aktion-Berechtigung

Ich bin ein Neuling in der Entwicklung mit Django + Django-Rest-framework, und ich bin an einem Projekt arbeiten, bietet die REST-Api zugreifen. Ich Frage mich, was ist die beste Vorgehensweise zum zuweisen einer anderen Berechtigung zu jeder Aktion eines bestimmten ApiView oder Viewset.

Nehmen wir an, ich definierte Berechtigungen Klassen wie 'IsAdmin', 'IsRole1', 'IsRole2', ..., und ich will zu gewähren unterschiedliche Berechtigungen für die einzelnen Handlungen (z.B. ein Nutzer mit Role1 erstellen oder abzurufen, kann ein Benutzer mit Role2 aktualisieren können, und nur ein Admin kann löschen).

Wie kann ich die Struktur einer class-based view, um zum zuweisen einer permission-Klasse zu den 'create', 'Liste', 'abgerufen', 'update', 'delete' - Aktionen?
Ich versuche, so zu tun, um eine Klasse, die wiederverwendet werden können, für verschiedene Tabellen, die die gleiche Berechtigung Muster.

Vielleicht bin ich einfach ertrinken in einem Zoll von Wasser, vielen Dank für Ihre Antworten.

InformationsquelleAutor der Frage lWhitmore | 2013-10-11

  1. 13

    Können Sie erstellen, benutzerdefinierte Berechtigung Klasse Ausweitung der DRF ist BasePermission.

    Implementieren Sie has_permission wo Sie Zugriff auf die request und view Objekte. Sie können überprüfen request.user für die entsprechende Rolle und zurück True/False als angemessen.

    Haben Sie einen Blick auf die mitgelieferte IsAuthenticatedOrReadOnly Klasse (und andere) für ein gutes Beispiel, wie einfach es ist.

    Ich hoffe, das hilft.

    InformationsquelleAutor der Antwort Carlton Gibson

  2. 34

    In DRF Dokumentation,

    Hinweis: Der Instanz-Ebene has_object_permission Methode wird nur aufgerufen, wenn der view-Ebene has_permission Prüfungen bereits bestanden haben

    Nehmen wir an, folgende Berechtigung zu user Objekt

    • Liste : - Personal nur
    • Erstellen : wer
    • Abrufen : eigene oder Mitarbeiter
    • Update, Teil-update : eigene oder Mitarbeiter
    • Zerstören : Mitarbeiter nur

    permissons.py

    from rest_framework import permissions

class UserPermission(permissions.BasePermission):

    def has_permission(self, request, view):
        if view.action == 'list':
            return request.user.is_authenticated() and request.user.is_admin
        elif view.action == 'create':
            return True
        elif view.action in ['retrieve', 'update', 'partial_update', 'destroy']:
            return True
        else:
            return False

    def has_object_permission(self, request, view, obj):
        # Deny actions on objects if the user is not authenticated
        if not request.user.is_authenticated():
            return False

        if view.action == 'retrieve':
            return obj == request.user or request.user.is_admin
        elif view.action in ['update', 'partial_update']:
            return obj == request.user or request.user.is_admin
        elif view.action == 'destroy':
            return request.user.is_admin
        else:
            return False

    views.py

    from .models import User
from .permissions import UserPermission
from .serializers import UserSerializer
from rest_framework import viewsets


class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = (UserPermission,)

    BEARBEITEN

    Für Django 2.0 ersetzen is_authenticated() mit is_authenticated. Die Methode wurde in ein Attribut.

    InformationsquelleAutor der Antwort Chemical Programmer

  3. 3

    Django hat eine persmissions Klasse namens DjangoObjectPermissions was nutzt Django-Guardian als ein Authentifizierungs-backend.

    Wenn man Django-guardian aktiv in Ihren Einstellungen fügen Sie einfach permission_classes = [DjandoObjectPermissions] auf Ihre Ansicht und es tut Berechtigung Authentifizierung automatisch, so kann man 'CRUD', basierend auf der Genehmigung auf einen bestimmten django.contrib.auth Gruppe oder Benutzer.

    Sehen gist mit einem Beispiel.

    Sie können Django-Guardian, wie Ihr die Authentifizierung gesichert http://django-guardian.readthedocs.org/en/latest/installation.html

    InformationsquelleAutor der Antwort

  4. 2

    RestFramework s-Klasse-basierte Ansichten-Methoden für die einzelnen HTTP-verb (sprich : HTTP-GET => Ansicht.get() usw). Sie müssen nur verwenden, django.contrib.auth die Berechtigungen für Benutzer, Gruppen und Dekorateure, wie dokumentiert.

    InformationsquelleAutor der Antwort bruno desthuilliers

  5. 1

    Ich persönlich hasse diese Art von frankenmonster benutzerdefinierten Berechtigungen, meiner Meinung nach, es ist nicht sehr idiomatisch, wenn es um Django-framework;
    So kam ich mit der folgenden Lösung - es ist sehr ähnlich wie @list_route und @detail_route Dekorateure arbeiten.
    Wir verlassen uns auf die Tatsache, dass die Methoden/Funktionen sind first-class Objekte

    Zuallererst bin ich die Erstellung solcher decorator:

    decorators.py

    def route_action_arguments(**kwargs):
    """
    Add arguments to the action method
    """
    def decorator(func):
        func.route_action_kwargs = kwargs
        return func
    return decorator

    Wie Sie sehen können, fügt es ein Wörterbuch, um die Funktion, die es schmückt mit übergebenen Parameter als Liste arg

    Nun erstellte ich eine solche mixin:
    mixins.py

    class RouteActionArgumentsMixin (object):
    """
    Use action specific parameters to 
    provide:
    - serializer
    - permissions
    """

    def _get_kwargs(self):
        action = getattr(self, 'action')
        if not action:
            raise AttributeError
        print('getting route kwargs for action:' + action)
        action_method = getattr(self, action)
        kwargs = getattr(action_method, 'route_action_kwargs')
        print(dir(kwargs))
        return kwargs

    def get_serializer_class(self):
        try:
            kwargs = self._get_kwargs()
            return kwargs['serializer']
        except (KeyError, AttributeError):
            return super(RouteActionArgumentsMixin, self).get_serializer_class()

    def get_permissions(self):
        try:
            kwargs = self._get_kwargs()
            return kwargs['permission_classes']
        except (KeyError, AttributeError):
            return super(RouteActionArgumentsMixin, self).get_permissions()

    Mixin zwei Dinge tut;
    wenn get_permissions aufgerufen wird, prüft es die 'action' ausgeführt wird, und looksup die permission_classes Sammlung von route_action_kwargs im Zusammenhang mit der viewset.action_method.route_action_kwargs

    wenn get_serializer_class heißt, es macht das gleiche, und nimmt die serializer aus route_action_kwargs

    Nun die Art, wie wir es verwenden können:

    @method_decorator(route_action_arguments(serializer=LoginSerializer), name='create')
class UserViewSet (RouteActionArgumentsMixin, RequestContextMixin, viewsets.ModelViewSet):
    """
    User and profile managment viewset
    """

    queryset = User.objects.all()
    serializer_class = UserSerializer

    @list_route(methods=['post'])
    @route_action_arguments(permission_classes=(AllowAny,), serializer=LoginSerializer)
    def login(self, request):
        serializer = self.get_serializer_class()(data=request.data)

    Für benutzerdefinierte Routen definieren wir explizit können wir nur die @route_action_arguments explizit auf die Methode.

    In Bezug auf generische viewsets und Methoden, die wir noch hinzufügen können Sie mit der
    @method_decorator

    @method_decorator(route_action_arguments(serializer=LoginSerializer), name='create')
class UserViewSet (RouteActionArgumentsMixin, RequestContextMixin, viewsets.ModelViewSet):

    InformationsquelleAutor der Antwort Marcin Kudzia

Schreibe einen Kommentar