Django Rest Framework POST and GET Nested Serializers

Question

I've been developing my own API for a Kanban-Style Project Board. I have attached a UML diagram to show how the "boards" application is organised.

My Application's Model UML Diagram

My problem is that when I want to create a new Card I want to be able to create the card with a list of Labels by Primary Keys passed in the POST parameters, like so:

{
    "title": "Test Card",
    "description": "This is a Test Card!",
    "created_by": 1,
    "labels": [1,2]
}

Another requirement I have is that I would like to retrieve the serialized labels as part of the card object, like so:

{
    "id": 1,
    "board": 1,
    "title": "Some Card",
    "description": "The description of Some Card.",
    "created_by": 1,
    "assignees": [
        {
            "id": 1,
            "username": "test1",
            "email": "[email protected]"
        }
    ],
    "labels": [
        {
            "id": 1,
            "board": 1,
            "title": "Pink Label",
            "color": "#f442cb"
        }
    ],
    "comment_set": []
}

I am going to assume that to achieve this difference in POST and GET functionality I am going to have to have 2 different serializers?

However, the main question of this post has to do with the creation logic from the POST data as mentioned above. I keep getting errors like this:

{
    "labels": [
        {
            "non_field_errors": [
                "Invalid data. Expected a dictionary, but got int."
            ]
        },
        {
            "non_field_errors": [
                "Invalid data. Expected a dictionary, but got int."
            ]
        }
    ]
}

I have tried many different combinations of DRF Serializers in my CardSerializer but always end up with error messages that have the same format as above: "Expected but got ". Any help or pointers, even someone telling me that this is bad REST design for example, would be greatly appreciated! :)

EDIT: I should add that in the case I change the CardSerializer labels field from a LabelSerializer to a PrimaryKeyRelatedField (as the comment in the code shows) I receive the following error:

Direct assignment to the forward side of a many-to-many set is prohibited. Use labels.set() instead.

Here are the relevant parts of my source code:

models.py

class Card(models.Model):
"""Represents a card."""

    # Parent
    board = models.ForeignKey(Board, on_delete=models.CASCADE)
    column = models.ForeignKey(Column, on_delete=models.CASCADE, null=True)

    # Fields
    title = models.CharField(max_length=255, null=False)
    description = models.TextField()

    assignees = models.ManyToManyField(User, blank=True, related_name='card_assignees')
    labels = models.ManyToManyField(Label, blank=True, related_name='card_labels')

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(blank=True, null=True)  # Blank for django-admin

    created_by = models.ForeignKey(User, on_delete=models.CASCADE, related_name='card_created_by')

views.py

class CardList(generics.ListCreateAPIView):
    queryset = Card.objects.all()
    serializer_class = CardSerializer

    def get_queryset(self):
        columns = Column.objects.filter(board_id=self.kwargs['board_pk'])
        queryset = Card.objects.filter(column__in=columns)
        return queryset

    def post(self, request, *args, **kwargs):
        board = Board.objects.get(pk=kwargs['board_pk'])

        post_data = {
            'title': request.data.get('title'),
            'description': request.data.get('description'),
            'created_by': request.data.get('created_by'),
            'assignees': request.data.get('assignees'),
            'labels': request.data.get('labels'),
        }
        serializer = CardSerializer(data=post_data, context={'board': board})

        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status.HTTP_201_CREATED)
        return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)

serializers.py

class UserSerializer(serializers.ModelSerializer):
    """Serializer to map the User instance to JSON."""

    class Meta:
        model = User
        fields = ('id', 'username', 'email')


class CommentSerializer(serializers.ModelSerializer):
    """Serializer to map the Comment instance to JSON."""

    class Meta:
        model = Comment
        fields = '__all__'


class LabelSerializer(serializers.ModelSerializer):
    """Serializer to map the Label instance to JSON."""

    class Meta:
        model = Label
        fields = ('id', 'board', 'title', 'color')


class CardSerializer(serializers.ModelSerializer):
    """Serializer to map the Card instance to JSON."""
    assignees = UserSerializer(many=True, read_only=True)
    labels = LabelSerializer(many=True)
    comment_set = CommentSerializer(many=True, read_only=True)

    # assignees = PrimaryKeyRelatedField(many=True, read_only=True)
    # labels = PrimaryKeyRelatedField(many=True, queryset=Label.objects.all())

    def create(self, validated_data):
        board = self.context['board']
        card = Card.objects.create(
            board=board,
            **validated_data
        )
        return card

    class Meta:
        model = Card
        fields = ('id', 'board', 'title', 'description', 'created_by', 'assignees', 'labels', 'comment_set')
        read_only_fields = ('id', 'board')

I believe your answer lies in here: django-rest-framework.org/api-guide/serializers/… "Because the behavior of nested creates and updates can be ambiguous, and may require complex dependencies between related models, REST framework 3 requires you to always write these methods explicitly. The default ModelSerializer .create() and .update() methods do not include support for writable nested representations." — souldeux
– souldeux, Commented Jun 17, 2018 at 14:45
I don't want to create the nested objects. They already exist and I want to create the Card object with the referenced Label objects. This should be done on create and on update, however I'm worrying only about the create for now. Maybe instead of creating the nested object as per that example I could retrieve and then pass them? I don't see how this could work with my many2many relationship at the moment though. — ev350
– ev350, Commented Jun 17, 2018 at 14:55

ev350 · Accepted Answer · 2018-06-17 15:16:28Z

3

I managed to find a solution, however this may not conform to best practice. If anyone could clarify this that would be great. However, for now:

I changed the create function in the CardSerializer to the following:

def create(self, validated_data):
    board = self.context['board']
    labels_data = validated_data.pop('labels')
    card = Card.objects.create(
        board=board,
        **validated_data
    )
    card.labels.set(labels_data)
    return card

The card.labels.set(labels_data) line means I bypass the following error message:

Direct assignment to the forward side of a many-to-many set is prohibited.

Which is why I am uncertain if it is the "correct" thing to do but it seems to work for now.

answered Jun 17, 2018 at 15:16

ev350

4393 silver badges18 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Tek Kshetri · Accepted Answer · 2021-02-19 07:47:00Z

If anyone stuck on the same problem, then here is the solution. I think you need to create the two serializer classes, one for the get request and another for the post request. And call the required serializer from viewset as below,

class MyModelViewSet(viewsets.MyModelViewSet):

    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer # default serializer, you can change this to MyModelListSerializer as well

    action_serializers = {
        'list': MyModelListSerializer, # get request serializer
        'create': MyModelCreateSerializer # post request serializer
    }

    def get_serializer_class(self):

        if hasattr(self, 'action_serializers'):
            return self.action_serializers.get(self.action, self.serializer_class)

        return super(MyModelViewSet, self).get_serializer_class()

here is the example of the MyModelListSerializer and MyModelCreateSerializer,

# Used for the get request
class MyModelListSerializer(serializers.ModelSerializer):
    assignees = AssigneesSerializer(read_only=True, many=True)
    labels = LabelsSerializer(read_only=True, many=True)

    class Meta:
        model = MyModel
        fields = '__all__'

# Used for the post request
class MyModelCreateSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = "__all__"

Collectives™ on Stack Overflow

Django Rest Framework POST and GET Nested Serializers

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related