Django - 处理多个不同级别的嵌套模型

Question

我对 django 嵌套模型有一些疑问。

据我所知，要处理嵌套数据结构，我必须反序列化每个数据，然后创建将与 ForeignKeyField 连接的对象。

我可以通过覆盖.create() 方法来处理这个问题，通过.pop() 分隔每个嵌套数据并分别创建每个对象模型。这是我如何处理 2 级嵌套数据的示例 （基于文档：DRF Documentation）

def create(self, validated_data):
    child_data = validated_data.pop('child_data')
    parent_obj = ParentModel.objects.create(**validated_data)
    for data in child_data:
        ChildModel.objects.create(parent_id=parent_obj, **data)
    return parent_obj

我在这里遇到了一些麻烦。我有多个多级数据结构，可能像下面的数据：

    "data_a": [
        {
            "data_a_1": [
                {
                    "data_a_1_1": [
                        {
                            "data_a_1_1_1": "example_a_1_1_1",
                            "data_a_1_1_2": "example_a_1_1_2"
                        }
                    ]
                },
                {
                    "data_a_1_2_1": "Example a-1-2-1",
                    "data_a_1_2_2": "Example a-1-2-2"
                }
            ]
            "data_a_2": [
                {
                    "data_a_2_1": "Example a-2-1"
                },
                {
                    "data_a_2_2": "Example a-2-2"
                }
            ]
        }
    ]

我的问题是：

1. 处理这种动态数据结构的最佳方法是什么？如上所述，通过覆盖.create() 来处理多个多级数据结构将需要很长的硬编码脚本。
2. 还有其他处理上述数据结构的最佳实践吗？

Answer 1

我找到了这个结构的解决方案。

我在 DRF 文档中看到，有一个第三方包可以轻松处理父子关系drf-writable-nested

在没有硬编码.create() 和.update() 的情况下处理这种数据结构问题对我有很大帮助。这个包提供了特殊的方法来处理上面提到的父子CRUD问题。

示例如下：

models.py：

class GrandChildModel(models.Model):
    name = models.CharField(max_length=32, blank=True, null=True)
    parent_id = models.ForeignKeyField(ChildModel, on_delete=CASCADE, related_name='grandchild')

class ChildModel(models.Model):
    name = models.CharField(max_length=32, blank=True, null=True)
    parent_id = models.ForeignKeyField(ParentModel, on_delete=CASCADE, related_name='child')

class ParentModel(models.Model):
    parent_name = model.CharField(max_length=32, blank=True, null=True)

serializer.py

from drf_writable_nested.serializers import WritableNestedModelSerializer

class GrandChildSerializer(serializers.ModelSerializer):
    class Meta:
        model=GrandChildModel
        fields = ["name"]

class ChildSerializer(WritableModelSerializer):
    grandchild = GrandChildSerializer(many=True)
    class Meta:
        model=ChildModel
        fields = ["name", "grandchild"]

class ParentSerializer(WritableModelSerializer):
    child = ChildSerializer(many=True)
    class Meta:
        model=ChildModelimport 
        fields = ["name", "child"]

有了这个，你可以处理所有类型的嵌套数据:)