Django Rest Framework verschachtelte selbstreferenzielle Objekte

Ich habe ein Modell, das so aussieht:

class Category(models.Model):
    parentCategory = models.ForeignKey('self', blank=True, null=True, related_name='subcategories')
    name = models.CharField(max_length=200)
    description = models.CharField(max_length=500)

Ich habe es geschafft, mit dem Serializer eine flache JSON-Darstellung aller Kategorien zu erhalten:

class CategorySerializer(serializers.HyperlinkedModelSerializer):
    parentCategory = serializers.PrimaryKeyRelatedField()
    subcategories = serializers.ManyRelatedField()

    class Meta:
        model = Category
        fields = ('parentCategory', 'name', 'description', 'subcategories')

Was ich jetzt tun möchte, ist, dass die Liste der Unterkategorien eine Inline-JSON-Darstellung der Unterkategorien anstelle ihrer IDs enthält. Wie würde ich das mit dem Django-Rest-Framework machen? Ich habe versucht, es in der Dokumentation zu finden, aber es scheint unvollständig.

Verwenden Sie anstelle von ManyRelatedField einen verschachtelten Serializer als Feld:

class SubCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ('name', 'description')

class CategorySerializer(serializers.ModelSerializer):
    parentCategory = serializers.PrimaryKeyRelatedField()
    subcategories = serializers.SubCategorySerializer()

    class Meta:
        model = Category
        fields = ('parentCategory', 'name', 'description', 'subcategories')

Wenn Sie sich mit willkürlich verschachtelten Feldern befassen möchten, sollten Sie sich den Abschnitt zum Anpassen der Standardfelder in den Dokumenten ansehen . Sie können einen Serializer derzeit nicht direkt als Feld für sich selbst deklarieren, aber Sie können diese Methoden verwenden, um zu überschreiben, welche Felder standardmäßig verwendet werden.

class CategorySerializer(serializers.ModelSerializer):
    parentCategory = serializers.PrimaryKeyRelatedField()

    class Meta:
        model = Category
        fields = ('parentCategory', 'name', 'description', 'subcategories')

        def get_related_field(self, model_field):
            # Handles initializing the `subcategories` field
            return CategorySerializer()

Wie Sie bereits bemerkt haben, ist das eigentlich nicht ganz richtig. Dies ist ein kleiner Hack, aber Sie können versuchen, das Feld hinzuzufügen, nachdem der Serializer bereits deklariert wurde.

class CategorySerializer(serializers.ModelSerializer):
    parentCategory = serializers.PrimaryKeyRelatedField()

    class Meta:
        model = Category
        fields = ('parentCategory', 'name', 'description', 'subcategories')

CategorySerializer.base_fields['subcategories'] = CategorySerializer()

Ein Mechanismus zum Deklarieren rekursiver Beziehungen muss hinzugefügt werden.

Bearbeiten : Beachten Sie, dass jetzt ein Paket von Drittanbietern verfügbar ist, das sich speziell mit dieser Art von Anwendungsfall befasst. Siehe djangorestframework-recursive .

Die Lösung von @ wjin hat für mich hervorragend funktioniert, bis ich auf das Django REST Framework 3.0.0 aktualisiert habe, das to_native nicht mehr unterstützt . Hier ist meine DRF 3.0-Lösung, die eine geringfügige Modifikation darstellt.

Angenommen, Sie haben ein Modell mit einem selbstreferenziellen Feld, z. B. Kommentare mit Thread in einer Eigenschaft namens "Antworten". Sie haben eine Baumdarstellung dieses Kommentarthreads und möchten den Baum serialisieren

Definieren Sie zunächst Ihre wiederverwendbare RecursiveField-Klasse

class RecursiveField(serializers.Serializer):
    def to_representation(self, value):
        serializer = self.parent.parent.__class__(value, context=self.context)
        return serializer.data

Verwenden Sie dann für Ihren Serializer das RecursiveField, um den Wert von "Antworten" zu serialisieren.

class CommentSerializer(serializers.Serializer):
    replies = RecursiveField(many=True)

    class Meta:
        model = Comment
        fields = ('replies, ....)

Einfach peasy, und Sie benötigen nur 4 Codezeilen für eine wiederverwendbare Lösung.

HINWEIS: Wenn Ihre Datenstruktur komplizierter ist als ein Baum, z. B. ein gerichteter azyklischer Graph (FANCY!), Können Sie das Paket von @ wjin ausprobieren - sehen Sie sich seine Lösung an. Ich hatte jedoch keine Probleme mit dieser Lösung für MPTTModel-basierte Bäume.

Eine weitere Option, die mit Django REST Framework 3.3.2 funktioniert:

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ('id', 'name', 'parentid', 'subcategories')

    def get_fields(self):
        fields = super(CategorySerializer, self).get_fields()
        fields['subcategories'] = CategorySerializer(many=True)
        return fields

Spät zum Spiel hier, aber hier ist meine Lösung. Nehmen wir an, ich serialisiere ein Blah mit mehreren Kindern vom Typ Blah.

    class RecursiveField(serializers.Serializer):
        def to_native(self, value):
            return self.parent.to_native(value)

Mit diesem Feld kann ich meine rekursiv definierten Objekte mit vielen untergeordneten Objekten serialisieren

    class BlahSerializer(serializers.Serializer):
        name = serializers.Field()
        child_blahs = RecursiveField(many=True)

Ich habe ein rekursives Feld für DRF3.0 geschrieben und es für pip https://pypi.python.org/pypi/djangorestframework-recursive/ gepackt.

Dieses Ergebnis konnte ich mit a erzielen serializers.SerializerMethodField. Ich bin mir nicht sicher, ob dies der beste Weg ist, habe aber für mich gearbeitet:

class CategorySerializer(serializers.ModelSerializer):

    subcategories = serializers.SerializerMethodField(
        read_only=True, method_name="get_child_categories")

    class Meta:
        model = Category
        fields = [
            'name',
            'category_id',
            'subcategories',
        ]

    def get_child_categories(self, obj):
        """ self referral field """
        serializer = CategorySerializer(
            instance=obj.subcategories_set.all(),
            many=True
        )
        return serializer.data

Eine andere Möglichkeit wäre, in der Ansicht zu rekursieren, die Ihr Modell serialisiert. Hier ist ein Beispiel:

class DepartmentSerializer(ModelSerializer):
    class Meta:
        model = models.Department


class DepartmentViewSet(ModelViewSet):
    model = models.Department
    serializer_class = DepartmentSerializer

    def serialize_tree(self, queryset):
        for obj in queryset:
            data = self.get_serializer(obj).data
            data['children'] = self.serialize_tree(obj.children.all())
            yield data

    def list(self, request):
        queryset = self.get_queryset().filter(level=0)
        data = self.serialize_tree(queryset)
        return Response(data)

    def retrieve(self, request, pk=None):
        self.object = self.get_object()
        data = self.serialize_tree([self.object])
        return Response(data)

Ich hatte kürzlich das gleiche Problem und fand eine Lösung, die bis jetzt zu funktionieren scheint, selbst für willkürliche Tiefen. Die Lösung ist eine kleine Modifikation der von Tom Christie:

class CategorySerializer(serializers.ModelSerializer):
    parentCategory = serializers.PrimaryKeyRelatedField()

    def convert_object(self, obj):
        #Add any self-referencing fields here (if not already done)
        if not self.fields.has_key('subcategories'):
            self.fields['subcategories'] = CategorySerializer()      
        return super(CategorySerializer,self).convert_object(obj) 

    class Meta:
        model = Category
        #do NOT include self-referencing fields here
        #fields = ('parentCategory', 'name', 'description', 'subcategories')
        fields = ('parentCategory', 'name', 'description')
#This is not needed
#CategorySerializer.base_fields['subcategories'] = CategorySerializer()

Ich bin mir nicht sicher, ob es in jeder Situation zuverlässig funktionieren kann ...

Dies ist eine Anpassung der Caipirginka-Lösung, die auf drf 3.0.5 und django 2.7.4 funktioniert:

class CategorySerializer(serializers.ModelSerializer):

    def to_representation(self, obj):
        #Add any self-referencing fields here (if not already done)
        if 'branches' not in self.fields:
            self.fields['subcategories'] = CategorySerializer(obj, many=True)      
        return super(CategorySerializer, self).to_representation(obj) 

    class Meta:
        model = Category
        fields = ('id', 'description', 'parentCategory')

Beachten Sie, dass der CategorySerializer in der 6. Zeile mit dem Objekt und dem Attribut many = True aufgerufen wird.

Ich dachte, ich würde mitmachen!

Über wjin und Mark Chackerian habe ich eine allgemeinere Lösung erstellt, die für direkte baumartige Modelle und Baumstrukturen mit einem Durchgangsmodell funktioniert. Ich bin mir nicht sicher, ob dies zu seiner eigenen Antwort gehört, aber ich dachte, ich könnte es genauso gut irgendwo hinstellen. Ich habe eine Option max_depth eingefügt, die eine unendliche Rekursion verhindert. Auf der tiefsten Ebene werden Kinder als URLs dargestellt (dies ist die letzte else-Klausel, wenn Sie lieber keine URL möchten).

from rest_framework.reverse import reverse
from rest_framework import serializers

class RecursiveField(serializers.Serializer):
    """
    Can be used as a field within another serializer,
    to produce nested-recursive relationships. Works with
    through models, and limited and/or arbitrarily deep trees.
    """
    def __init__(self, **kwargs):
        self._recurse_through = kwargs.pop('through_serializer', None)
        self._recurse_max = kwargs.pop('max_depth', None)
        self._recurse_view = kwargs.pop('reverse_name', None)
        self._recurse_attr = kwargs.pop('reverse_attr', None)
        self._recurse_many = kwargs.pop('many', False)

        super(RecursiveField, self).__init__(**kwargs)

    def to_representation(self, value):
        parent = self.parent
        if isinstance(parent, serializers.ListSerializer):
            parent = parent.parent

        lvl = getattr(parent, '_recurse_lvl', 1)
        max_lvl = self._recurse_max or getattr(parent, '_recurse_max', None)

        # Defined within RecursiveField(through_serializer=A)
        serializer_class = self._recurse_through
        is_through = has_through = True

        # Informed by previous serializer (for through m2m)
        if not serializer_class:
            is_through = False
            serializer_class = getattr(parent, '_recurse_next', None)

        # Introspected for cases without through models.
        if not serializer_class:
            has_through = False
            serializer_class = parent.__class__

        if is_through or not max_lvl or lvl <= max_lvl: 
            serializer = serializer_class(
                value, many=self._recurse_many, context=self.context)

            # Propagate hereditary attributes.
            serializer._recurse_lvl = lvl + is_through or not has_through
            serializer._recurse_max = max_lvl

            if is_through:
                # Delay using parent serializer till next lvl.
                serializer._recurse_next = parent.__class__

            return serializer.data
        else:
            view = self._recurse_view or self.context['request'].resolver_match.url_name
            attr = self._recurse_attr or 'id'
            return reverse(view, args=[getattr(value, attr)],
                           request=self.context['request'])

Mit Django REST Framework 3.3.1 benötigte ich den folgenden Code, um Unterkategorien zu Kategorien hinzuzufügen:

models.py

class Category(models.Model):

    id = models.AutoField(
        primary_key=True
    )

    name = models.CharField(
        max_length=45, 
        blank=False, 
        null=False
    )

    parentid = models.ForeignKey(
        'self',
        related_name='subcategories',
        blank=True,
        null=True
    )

    class Meta:
        db_table = 'Categories'

serializers.py

class SubcategorySerializer(serializers.ModelSerializer):

    class Meta:
        model = Category
        fields = ('id', 'name', 'parentid')


class CategorySerializer(serializers.ModelSerializer):
    subcategories = SubcategorySerializer(many=True, read_only=True)

    class Meta:
        model = Category
        fields = ('id', 'name', 'parentid', 'subcategories')

Diese Lösung ähnelt fast den anderen hier veröffentlichten Lösungen, weist jedoch einen geringfügigen Unterschied in Bezug auf das Problem der Wiederholung von Kindern auf der Stammebene auf (wenn Sie der Meinung sind, dass dies ein Problem ist). Zum Beispiel

class RecursiveSerializer(serializers.Serializer):
    def to_representation(self, value):
        serializer = self.parent.parent.__class__(value, context=self.context)
        return serializer.data

class CategoryListSerializer(ModelSerializer):
    sub_category = RecursiveSerializer(many=True, read_only=True)

    class Meta:
        model = Category
        fields = (
            'name',
            'slug',
            'parent', 
            'sub_category'
    )

und wenn Sie diese Ansicht haben

class CategoryListAPIView(ListAPIView):
    queryset = Category.objects.all()
    serializer_class = CategoryListSerializer

Dies führt zu folgendem Ergebnis:

[
{
    "name": "parent category",
    "slug": "parent-category",
    "parent": null,
    "sub_category": [
        {
            "name": "child category",
            "slug": "child-category",
            "parent": 20,  
            "sub_category": []
        }
    ]
},
{
    "name": "child category",
    "slug": "child-category",
    "parent": 20,
    "sub_category": []
}
]

Hier parent categoryhat child categorydie a- und die json-Darstellung genau das, was wir wollen, dass sie dargestellt wird.

aber Sie können sehen, dass es eine Wiederholung der child categoryauf der Wurzelebene gibt.

Da einige Leute in den Kommentaren der oben veröffentlichten Antworten fragen, wie wir diese untergeordnete Wiederholung auf der Stammebene stoppen können , filtern Sie einfach Ihr Abfrageset mit parent=Nonewie folgt

class CategoryListAPIView(ListAPIView):
    queryset = Category.objects.filter(parent=None)
    serializer_class = CategoryListSerializer

es wird das Problem lösen.

HINWEIS: Diese Antwort steht möglicherweise nicht in direktem Zusammenhang mit der Frage, aber das Problem hängt irgendwie zusammen. Auch dieser Verwendungsansatz RecursiveSerializerist teuer. Besser, wenn Sie andere Optionen verwenden, die leistungsanfällig sind.