Django rest çerçevesi, kendinden referanslı nesneler iç içe

Şuna benzeyen modelim var:

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)

Serileştirici ile tüm kategorilerin düz json temsilini almayı başardım:

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

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

Şimdi yapmak istediğim şey, alt kategoriler listesinin alt kategorilerin kimlikleri yerine satır içi json temsiline sahip olmasıdır. Bunu django-rest-framework ile nasıl yapabilirim? Belgelerde bulmaya çalıştım ama eksik görünüyor.

ManyRelatedField kullanmak yerine, alanınız olarak iç içe geçmiş bir serileştirici kullanın:

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

Keyfi olarak iç içe geçmiş alanlarla uğraşmak istiyorsanız , belgelerin varsayılan alanları özelleştirme bölümüne bir göz atmalısınız . Şu anda bir serileştiriciyi doğrudan kendi başına bir alan olarak ilan edemezsiniz, ancak bu yöntemleri varsayılan olarak hangi alanların kullanıldığını geçersiz kılmak için kullanabilirsiniz.

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

Aslında, yukarıda belirttiğiniz gibi tam olarak doğru değil. Bu biraz zor ama serileştirici zaten bildirildikten sonra alanı eklemeyi deneyebilirsiniz.

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

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

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

Özyinelemeli ilişkiler bildirme mekanizması, eklenmesi gereken bir şeydir.

Düzenleme : Artık, özellikle bu tür kullanım durumuyla ilgilenen üçüncü taraf bir paket bulunduğunu unutmayın. Djangorestframework-recursive konusuna bakın .

@ wjin'in çözümü, Django REST framework 3.0.0'a yükseltme yapana kadar benim için harika çalışıyordu, bu da to_native'i kullanımdan kaldırıyor . İşte küçük bir değişiklik olan DRF 3.0 çözümüm.

Kendi kendine referans alanlı bir modeliniz olduğunu varsayalım, örneğin "yanıtlar" adlı bir özellikteki zincir halinde yorumlar. Bu yorum dizisinin ağaç temsiline sahipsiniz ve ağacı serileştirmek istiyorsunuz

İlk olarak, yeniden kullanılabilir RecursiveField sınıfınızı tanımlayın

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

Ardından, serileştiriciniz için "yanıtlar" ın değerini serileştirmek için RecursiveField kullanın.

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

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

Kolay peasy ve yeniden kullanılabilir bir çözüm için yalnızca 4 satır koda ihtiyacınız var.

NOT: Veri yapınız bir ağaçtan daha karmaşıksa, örneğin yönlendirilmiş döngüsel olmayan bir grafik (FANCY!) Ancak MPTTM model tabanlı ağaçlar için bu çözümle ilgili herhangi bir sorun yaşamadım.

Django REST Framework 3.3.2 ile çalışan başka bir seçenek:

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

Burada oyuna geç kaldım ama işte çözümüm. Diyelim ki bir Blah'ı, aynı zamanda Blah tipi birden fazla çocukla seri hale getiriyorum.

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

Bu alanı kullanarak, birçok alt nesneye sahip özyinelemeli olarak tanımlanmış nesnelerimi serileştirebilirim

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

DRF3.0 için yinelemeli bir alan yazdım ve pip için paketledim https://pypi.python.org/pypi/djangorestframework-recursive/

Bu sonucu a kullanarak başardım serializers.SerializerMethodField. Bunun en iyi yol olduğundan emin değilim, ama benim için çalıştı:

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

Diğer bir seçenek, modelinizi serileştiren görünümde yinelemektir. İşte bir örnek:

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)

Geçenlerde aynı sorunu yaşadım ve keyfi derinlik için bile şimdiye kadar işe yarayan bir çözüm buldum. Çözüm, Tom Christie'den küçük bir değişiklik:

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

Yine de her durumda güvenilir bir şekilde çalışabileceğinden emin değilim ...

Bu, drf 3.0.5 ve django 2.7.4 üzerinde çalışan caipirginka çözümünden bir uyarlamadır:

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

6. satırdaki CategorySerializer'ın nesne ve many = True niteliğiyle çağrıldığını unutmayın.

Eğlenceye katılacağımı düşündüm!

Via wjin ve Mark Chackerian ben direkt için çalışan daha genel bir çözüm yarattı ağacın benzeri modelleri ve ağaç yapıları modeli ile var olan. Bunun kendi cevabına ait olup olmadığından emin değilim ama bir yere koyabilirim diye düşündüm. Sonsuz özyinelemeyi önleyecek bir max_depth seçeneği ekledim, en derin düzeyde çocuklar URLS olarak temsil edilir (eğer url olmasaydı bu son else cümlesi).

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 çerçevesi 3.3.1 ile, kategorilere alt kategoriler eklemek için aşağıdaki koda ihtiyacım vardı:

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

Bu çözüm, burada yayınlanan diğer çözümlerle neredeyse benzerdir ancak kök düzeyinde çocuk tekrarı sorunu açısından küçük bir farka sahiptir (bunun bir sorun olduğunu düşünüyorsanız). Örnek olarak

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

ve eğer bu görüşe sahipsen

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

Bu, aşağıdaki sonucu verecektir,

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

Burada parent categoryhas a child categoryve json temsili tam olarak temsil edilmesini istediğimiz şeydir.

ancak child categorykök seviyesinde bir tekrarının olduğunu görebilirsiniz .

Bazı insanlar yukarıda yayınlanan yorum bölümlerinde bu çocuk tekrarını kök seviyesinde nasıl durdurabileceğimizi sorduğundan , sorgu kümenizi parent=Noneaşağıdaki gibi filtreleyin.

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

sorunu çözecektir.

NOT: Bu yanıt doğrudan soruyla ilgili olmayabilir, ancak sorun bir şekilde ilişkilidir. Ayrıca bu kullanma yaklaşımı RecursiveSerializerpahalıdır. Performansa eğilimli diğer seçenekleri kullanırsanız daha iyi olur.