Django Rest Framework, das viele zu viele Felder serialisiert

Wie serialisiere ich ein Viele-zu-Viele-Feld in eine Liste von etwas und gebe sie über das Rest-Framework zurück? In meinem Beispiel unten versuche ich, den Beitrag zusammen mit einer Liste der damit verbundenen Tags zurückzugeben.

models.py

class post(models.Model):
    tag = models.ManyToManyField(Tag)
    text = models.CharField(max_length=100)

serializers.py

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ("text", "tag"??)

views.py

class PostViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

Sie benötigen eine TagSerializer, deren class Metahat model = Tag. Nach TagSerializererstellt wird, ändern die PostSerializermit many=Truefür eine ManyToManyFieldBeziehung:

class PostSerializer(serializers.ModelSerializer):
    tag = TagSerializer(read_only=True, many=True)

    class Meta:
        model = Post
        fields = ('tag', 'text',)

Die Antwort ist für DRF 3

Nehmen wir an, ein Buch kann mehr als einen Autor haben und ein Autor kann mehr als ein Buch haben: On Model:

class Author(models.Model):
    name = models.CharField(max_length=100, default="")
    last_name = models.IntegerField(default=0)

class Book(models.Model):
    authors = models.ManyToManyField(Author, related_name="book_list", blank=True)
    name = models.CharField(max_length=100, default="")
    published = models.BooleanField(default=True)

Auf Serialisierern:

class BookSerializer(serializers.ModelSerializer):
    authors = serializers.PrimaryKeyRelatedField(queryset=Author.objects.all(), many=True)

    class Meta:
        model = Book
        fields = ('id', 'name', 'published', 'authors')


class AuthorSerializer(serializers.ModelSerializer):
    book_list = BookSerializer(many=True, read_only=True)

    class Meta:
        model = Author
        fields = ('id', 'name', 'last_name', 'book_list')

Das Hinzufügen zu @ Brians Antwort "tags": [{"name": "tag1"}] kann auf folgende Weise zu "tags": ["tag1", "tag2", ...] vereinfacht werden:

class PostSerializer(serializers.ModelSerializer):
    tag = TagSerializer(read_only=True, many=True)

    class Meta:
        ...

class TagSerializer(serializers.RelatedField):

     def to_representation(self, value):
         return value.name

     class Meta:
        model = Tag

Weitere Informationen hier: https://www.django-rest-framework.org/api-guide/relations/#custom-relational-fields

Django 2.0

Für viele bis viele Bereiche, wenn Sie einen bestimmten möchten:

class QuestionSerializer(serializers.ModelSerializer):

    topics_list = serializers.SerializerMethodField()

    def get_topics_list(self, instance):
        names = []
        a = instance.topics.get_queryset()
        for i in a:
            names.append(i.desc)
        return names
    class Meta:
        model = Question
        fields = ('topics_list',)

Das funktioniert bei mir.

tag = TagSerializer(source="tag", read_only=True, many=True)

In der Methode serializer on init können Sie das Abfrageset an das Feld übergeben und rest_framework die IDs auf diesem Abfrageset validieren

1) Erweitern Sie zuerst Ihren Serializer von Serializers.ModelSerializer

class YourSerializer(serializers.ModelSerializer):

2) Fügen Sie das Feld in die Metaklasse ein

class YourSerializer(serializers.ModelSerializer):
  class Meta:
        fields = (..., 'your_field',)

3) in der init-Methode:

def __init__(self, *args, **kwargs):
    super(YourSerializer, self).__init__(*args, **kwargs)
    self.fields['your_field].queryset = <the queryset of your field>

Sie können den Abfragesatz für dieses Feld unter einem beliebigen Argument mithilfe von Filter einschränken oder ausschließen, wie Sie es normalerweise tun. Wenn Sie alle einschließen möchten, verwenden Sie einfach .objects.all ()

Die Standardeinstellung ModelSerializerverwendet Primärschlüssel für Beziehungen. Mit dem Meta depthAttribut können Sie jedoch problemlos verschachtelte Darstellungen erstellen:

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ("text", "tag")
        depth = 1 

Wie in der Dokumentation erwähnt :

Die depthOption sollte auf einen ganzzahligen Wert festgelegt werden, der die Tiefe der Beziehungen angibt, die durchlaufen werden sollen, bevor zu einer flachen Darstellung zurückgekehrt wird.