CODEWITHSUNDEEP
django-rest-framework
ddd
ddd

Reputation: 219

Django REST framework restrict posting and browsable Api-fields

I use the Django Rest framework together with an JavaScript app. I have some difficulties to get the posting of new data items right with the generic ModelViewSet

Most importantly I want to restrict what a poster can submit (they should only be allowed to post items that have the user_id of this user (the authenticated user of the session).

I don't know when/where I should check for this? Is this a validation problem? How I understand the permission classes is that they restrict the method (Post/Get) or check for user groups.

Also my user field in the item model is a foreign key to the user model so the browsable api suggest in the Html-form a dropdown with the information about other users. (their email adresses and some other fields).

My data items look like this

[{
    "id": 792,
    "name": "test",
    "category": 1,
    "value": 5,       
    "user": "33"
}]

Here is my Serializer and the Viewset:

class ItemSerializer(serializers.ModelSerializer):

    class Meta:
        model = Item
        fields = ('id',
                  'name',
                  'category',
                  'value',
                  'user',
        )

class ItemViewSet(viewsets.ModelViewSet):
    serializer_class = ItemSerializer

    def get_queryset(self):
        return Item.objects.filter(user=self.request.user)

Upvotes: 4

Views: 1722

Answers (2)

KingRanTheMan
KingRanTheMan

Reputation: 740

I can't believe this issue with the DRF Create/Update (Post/Put) form isn't more widely discussed. It's a huge data privacy issue - e.g. One can restrict the List API view to only show items owned by a User via overriding the get_queryset method inside as below:

# views.py

class ItemViewSet(viewsets.ModelViewSet):
    def get_queryset(self):
        return Item.objects.filter(user=self.request.user)

But as OP notes, when accessing the API Create/Post or Update/Put form for the ItemViewSet, there is seemingly no easy way to restrict the user options to the user itself.

I had a similar issue myself building a survey platform, where I want to restrict choice of survey/question/options etc. to those owned by the user, and prevent users from inadvertently seeing each other's data.

Jocelyn's answer works for the OP's particular situation where we already know that the Item.user must equal request.user, so we override this on the perform_create method.

But Jocelyn's solution is insufficient for situations where you do not know in advance what the relationship between model instances will be (e.g. in my case where a new question objected could be added to any one of a user's surveys).

The solution I came up with was the nuclear option: do away with the Viewset altogether for Create and Update functionality, and use a set of custom views.APIView classes instead, as below (adapted for the case of the OP, only showing Create).

class ItemCreateView(views.APIView):
    def post(self, request, format=None):
        post_user_id = int(request.data['user'].split('/')[-2])
        request_user_id = request.user.id
        serializer = ItemSerializer(data=request.data, context={'request': request})
        if post_user_id == request_user_id:
            if serializer.is_valid():
                serializer.save()
                return Response(serializer.data, status=status.HTTP_201_CREATED)
            else: 
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response('Not Allowed: Owner is not User', status=status.HTTP_401_UNAUTHORIZED)

Please note, I'm using a HyperlinkedModelSerializer rather than a plain ModelSerializer, hence the need for .split('/')[-2] to grab the post_user_id

Upvotes: 2

Jocelyn delalande
Jocelyn delalande

Reputation: 5394

Handling the user field

First set the user field to be readonly:

# serializers.py     

class ItemSerializer(serializers.ModelSerializer):
    user = serializers.ReadOnlyField()
    class Meta:
        model = Item
        fields = ('id',
                  'name',
                  'category',
                  'value',
                  'user',
        )

Then auto-set the user id on creation:

# views.py

class ItemViewSet(viewsets.ModelViewSet):
    serializer_class = ItemSerializer

    def get_queryset(self):
        return Item.objects.filter(user=self.request.user)

    def perform_create(self, serializer):
        serializer.save(user=self.request.user.customer)

Handling permissions

Just use standard permissions mechanism to define a custom one :

# permissions.py

from rest_framework import permissions

class IsOwner(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        return (request.user.is_authenticated() and
                (obj.user == request.user.customer))

...and use it in your viewset :

# views.py

from permissions import IsOwner

class ItemViewSet(viewsets.ModelViewSet):
    permission_classes = [IsOwner]
    ...

Upvotes: 0

Related Questions