Django rest framework вкладені самореференційні об'єкти

У мене є модель, яка виглядає так:

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)

Мені вдалося отримати плоске представлення JSON усіх категорій за допомогою серіалізатора:

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

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

Тепер я хочу зробити, щоб у списку підкатегорій було вбудоване представлення json підкатегорій замість їх ідентифікаторів. Як я можу це зробити за допомогою django-rest-framework? Я намагався знайти це в документації, але воно видається неповним.

Замість використання ManyRelatedField використовуйте вкладений серіалізатор як своє поле:

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')

Якщо ви хочете мати справу з довільно вкладеними полями, вам слід поглянути на налаштування за замовчуванням полів частини документів. Наразі ви не можете безпосередньо оголосити серіалізатор як поле для себе, але ви можете використовувати ці методи, щоб замінити ті поля, які використовуються за замовчуванням.

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()

Насправді, як ви вже зазначали, вищесказане не зовсім правильно. Це трохи зламати, але ви можете спробувати додати поле після того, як серіалізатор вже оголошено.

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

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

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

Механізм оголошення рекурсивних відносин - це те, що потрібно додати.

Редагувати : Зверніть увагу, що зараз доступний сторонній пакет, який спеціально стосується цього виду використання. Див. Djangorestframework-рекурсивний .

Рішення @ wjin чудово працювало для мене, доки я не перейшов на Django REST framework 3.0.0, який не підтримує to_native . Ось моє рішення DRF 3.0, яке є невеликою модифікацією.

Скажімо, у вас є модель із самореференційним полем, наприклад, коментарі з нитками у властивості, яка називається "відповіді". У вас є дерево представлення цього потоку коментарів, і ви хочете серіалізувати дерево

Спочатку визначте свій багаторазовий клас RecursiveField

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

Потім для вашого серіалізатора використовуйте RecursiveField для серіалізації значення "відповідей"

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

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

Легко, і вам потрібно лише 4 рядки коду для повторного використання рішення.

ПРИМІТКА: Якщо ваша структура даних складніша за дерево, наприклад, скажімо, спрямований ациклічний графік (FANCY!), Тоді ви можете спробувати пакет @ wjin - див. Його рішення. Але я не мав жодних проблем з цим рішенням для дерев на основі MPTTModel.

Інший варіант, який працює з Django REST Framework 3.3.2:

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

Пізно до гри тут, але ось моє рішення. Скажімо, я серіалізую бла, з кількома дітьми також типу бла.

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

Використовуючи це поле, я можу серіалізувати свої рекурсивно визначені об'єкти, які мають багато дочірніх об'єктів

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

Я написав рекурсивне поле для DRF3.0 і упакував його для pip https://pypi.python.org/pypi/djangorestframework-recursive/

Мені вдалося досягти цього результату за допомогою serializers.SerializerMethodField. Я не впевнений, що це найкращий спосіб, але працював для мене:

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

Іншим варіантом було б повторити повторення у поданні, яке серіалізує вашу модель. Ось приклад:

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)

Нещодавно у мене була та ж проблема, і я придумав рішення, яке, здається, працює досі, навіть на довільну глибину. Рішенням є невелика модифікація тієї, яку написав Том Крісті:

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()

Я не впевнений, що це може надійно працювати в будь-якій ситуації, хоча ...

Це адаптація з рішення caipirginka, яке працює на drf 3.0.5 і django 2.7.4:

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')

Зверніть увагу, що CategorySerializer у 6-му рядку викликається з об’єктом та атрибутом many = True.

Я думав, що приєднаюся до розваги!

Через wjin та Mark Chackerian я створив більш загальне рішення, яке працює для прямих деревоподібних моделей та деревних структур, що мають наскрізну модель. Я не впевнений, чи це належить у його власній відповіді, але я думав, що міг би десь це поставити. Я включив опцію max_depth, яка запобіжить нескінченну рекурсію, на найглибшому рівні діти представлені як URL-адреси (це останнє речення else, якщо ви хочете, щоб це не була url-адреса).

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'])

З Django REST framework 3.3.1 мені потрібен був наступний код для додавання підкатегорій до категорій:

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')

Це рішення майже схоже на інші рішення, опубліковані тут, але має невелику різницю щодо проблеми повторення дітей на кореневому рівні (якщо ви вважаєте це проблемою). Для прикладу

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'
    )

і якщо у вас такий погляд

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

Це дасть такий результат,

[
{
    "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": []
}
]

Тут представлення parent categoryhas child categoryі json - саме те, що ми хочемо, щоб воно було представлене.

але ви можете бачити, що є повторення child categoryна кореневому рівні.

Оскільки деякі люди запитують у розділах коментарів до опублікованих вище відповідей, що як ми можемо зупинити повторення цієї дочірньої групи на кореневому рівні , просто відфільтруйте набір запитів за допомогою parent=None, як показано нижче

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

це вирішить проблему.

ПРИМІТКА: Ця відповідь може не мати прямого відношення до запитання, але проблема якось пов’язана. Також такий підхід використання RecursiveSerializerє дорогим. Краще, якщо ви використовуєте інші варіанти, які схильні до ефективності.