Django rest framework создает вложенные объекты "Модели" POST

Ответ 1

Вложенные представления в настоящее время не поддерживают чтение-запись и должны быть доступны только для чтения.

Вероятно, вам следует изучить использование плоского представления, используя pk или гиперссылки.

Если вам нужно вложенное представление, вы можете захотеть иметь две отдельные конечные точки - плоскую записываемую конечную точку и вложенную конечную точку только для чтения.

Ответ 2

Если кому-то нужно быстрое и грязное решение для этого, я придумал это, я буду временно использовать в проекте:

class NestedManyToManyField(serializers.WritableField):
    def to_native(self, value):
        serializer = self.Meta.serializer(value.all(), many=True, context=self.context)
        return serializer.data
    def from_native(self, data):
        serializer = self.Meta.serializer(data=data, many=True, context=self.context)
        serializer.is_valid()
        serializer.save()
        return serializer.object
    class Meta:
        serializer = None

Затем создайте свой собственный подкласс NestedManyToManyField:

class TopicNestedSerializer(NestedManyToManyField):
    class Meta:
        serializer = MyOriginalSerializer

Пример MyOriginalSerializer:

class MyOriginalSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.MyModel
        fields = ('id', 'title',)

Это работает для меня до сих пор. Но имейте в виду, что появляются чистые исправления:

• https://github.com/tomchristie/django-rest-framework/issues/960
• https://github.com/tomchristie/django-rest-framework/pull/817

Ответ 3

после долгого усилия я сделал первую версию, которая funcinasse... Я считаю, что с некоторыми улучшениями можно было бы включить в ModelSerializer

class ChannelItemSerializer(serializers.ModelSerializer):

    class Meta:
        model = ChannelItem
        fields = ('id', 'content_id', 'content_version')

    def field_from_native(self, data, files, field_name, into):
        try:
            if self._use_files:
                _files = files[field_name]
            else:
                _data = data[field_name]
        except KeyError:
            if getattr(self, 'default', None):
                _data = self.default
            else:
                if getattr(self, 'required', None):
                    raise ValidationError(self.error_messages['required'])
                return

        if type(_data) is list:
            into[field_name] = [] 
            for item in _data:
                into[field_name].append(self._custom_from_native(item))
        else:
            into[field_name] = self._custom_from_native(_data)


    def _custom_from_native(self, data):
        self._errors = {}
        if data is not None:
            attrs = self.restore_fields(data, None)
            attrs = self.perform_validation(attrs)
        else:
            self._errors['non_field_errors'] = ['No input provided']

        if not self._errors:
            return self.restore_object(attrs, instance=getattr(self, 'object', None))




class PlaylistSerializer(serializers.ModelSerializer):

    class Meta:
        model = Playlist
        fields = ('id', 'provider', 'channel_id', 'channel_version', 'start', 'url', 'channel_items')
        depth = 1

    channel_items = ChannelItemSerializer()

    def restore_object(self, attrs, instance=None):
        self.foreign_data = {}

        for (obj, model) in self.opts.model._meta.get_all_related_objects_with_model():
            field_name = obj.field.related_query_name()
            if field_name in attrs:
                self.foreign_data[field_name] = attrs.pop(field_name)


        return super(PlaylistSerializer, self).restore_object(attrs, instance)

    def save(self, save_m2m=True):
        super(PlaylistSerializer, self).save(save_m2m)

        if getattr(self, 'foreign_data', None):
            for accessor_name, object_list in self.foreign_data.items():
                setattr(self.object, accessor_name, object_list)
            self.foreign_data = {}

        return self.object

Ответ 4

Для меня у меня есть гибридное решение, с которым я в порядке. А именно, создайте представление, которое имеет:

• Поле ManyToMany в форме не-вложенного сериализатора
• псевдоним вложенного поля ManyToMany в переменную с _objs как суффикс и указать его как только для чтения
• когда вы PUT возвращаетесь на сервер, сверяйте два поля с псевдонимом и сохраняйте результат в поле не-вложенного сериализатора

например.

class MSerializer(serializers.HyperlinkedModelSerializer):
    foo_objs = TempSensorSerializer(source='foos', many=True, allow_add_remove=True,required=False,read_only=True)
    class Meta:
        model = M
        fields = ('url', 'foos', 'foo_objs')

Мне не нравится это решение, но он бьет, пытаясь раздельно запросить и сопоставить вложенные поля после извлечения исходного контейнера.