Django rest framework - как вы вставляете вложенные данные?

Ответ 1

Я не уверен, что это самый простой способ, но решение, с которым я столкнулся, состояло в том, чтобы переопределить метод to_native MemberhipSerializer, а затем вручную создать и вызвать метод to_native PersonSerializer и объединить два результирующих словаря вместе

class MembershipSerializer(serializers.HyperlinkedModelSerializer):

    def to_native(self, obj):

        ret = super(MembershipSerializer, self).to_native(obj)
        p_serializer = PersonSerializer(obj.person, context=self.context)
        p_ret = p_serializer.to_native(obj.person)

        for key in p_ret:
            ret[key] = p_ret[key]

        return ret

    class Meta:
        model = Membership
        fields = ('id', 'url', 'group', 'date_joined', 'invite_reason', 'person')

Словарь является подклассом SortedDict. Я не уверен, есть ли явный метод для объединения двух, которые сохраняют порядок, поэтому я только использовал цикл.

Ответ 2

Здесь подход, основанный на ответе Джеймса, но для более новой версии Django Rest Framework и поддержки чтения и записи (обновление только вложенного поля, должно быть достаточно просто добавить создание, см. документацию по DRF для этого.)

class ProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = Profile
        fields = ('phone', 'some', 'other', 'fields')


class UserDetailsSerializer(serializers.ModelSerializer):
    """User model with Profile. Handled as a single object, profile is flattened."""
    profile = ProfileSerializer()

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

    def to_representation(self, obj):
        """Move fields from profile to user representation."""
        representation = super().to_representation(obj)
        profile_representation = representation.pop('profile')
        for key in profile_representation:
            representation[key] = profile_representation[key]

        return representation

    def to_internal_value(self, data):
        """Move fields related to profile to their own profile dictionary."""
        profile_internal = {}
        for key in ProfileSerializer.Meta.fields:
            if key in data:
                profile_internal[key] = data.pop(key)

        internal = super().to_internal_value(data)
        internal['profile'] = profile_internal
        return internal

    def update(self, instance, validated_data):
        """Update user and profile. Assumes there is a profile for every user."""
        profile_data = validated_data.pop('profile')
        super().update(instance, validated_data)

        profile = instance.profile
        for attr, value in profile_data.items():
            setattr(profile, attr, value)
        profile.save()

        return instance

Ответ 3

Ответ Джеймса - то, что я наконец использовал. Поскольку у меня было несколько сериализаторов, использующих этот метод, я преобразовал его в миксин:

class FlattenMixin(object):
    """Flatens the specified related objects in this representation"""
    def to_representation(self, obj):
        assert hasattr(self.Meta, 'flatten'), (
            'Class {serializer_class} missing "Meta.flatten" attribute'.format(
                serializer_class=self.__class__.__name__
            )
        )
        # Get the current object representation
        rep = super(FlattenMixin, self).to_representation(obj)
        # Iterate the specified related objects with their serializer
        for field, serializer_class in self.Meta.flatten:
            serializer = serializer_class(context = self.context)
            objrep = serializer.to_representation(getattr(obj, field))
            #Include their fields, prefixed, in the current   representation
            for key in objrep:
                rep[field + "__" + key] = objrep[key]
        return rep

Таким образом, вы можете сделать что-то вроде:

class MembershipSerializer(FlattenMixin, serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Membership
        fields = ('id', 'url', 'group', 'date_joined', 'invite_reason')
        flatten = [ ('person', PersonSerializer) ]

Ответ 4

Я не пробовал это с помощью HyperlinkedModelSerializer, но с ModelSerializer вы можете создать собственный класс serializer, поддерживающий flatten.

class CustomModelSerializer(serializers.ModelSerializer):
    def __init__(self, *args, **kwargs):
        self.flatten = kwargs.pop('flatten', False)
        super(CustomModelSerializer, self).__init__(*args, **kwargs)

    def get_fields(self):
        fields = super(CustomModelSerializer, self).get_fields()
        for field_name, field in fields.items():
            if getattr(field, 'flatten', False):
                del fields[field_name]
                for nested_field_name, nested_field in field.fields.iteritems():
                    nested_field.source = (field_name + '.' +
                                           (nested_field.source or nested_field_name))
                    fields[nested_field_name] = nested_field
        return fields

Использование:

class MembershipSerializer(CustomModelSerializer):
    person = PersonSerializer(flatten=True)

    class Meta:
        model = Membership
        fields = ('person', ...)


class PersonSerializer(CustomModelSerializer):

    class Meta:
        model = Person
        fields = (...)