我有一个Recipe模型,它包含一个IngredientType对象的M2M字段.这个字段,也就是ingredient_list,通过一个Ingredient对象使用臭名昭着的"通过"模型,该对象将额外的数据添加到我的IngredientType中.这些是我的课程:

class Recipe(models.Model):
    user_profile = models.ForeignKey(UserProfile, null=True, blank = True)
    name = models.CharField(max_length=200)
    photo1 = models.ImageField( upload_to = 'images/recipies', help_text="This photo will show by default")
    ingredient_list = models.ManyToManyField(IngredientType,through='Ingredient')

class Ingredient(models.Model):
    ingredient_type = models.ForeignKey(IngredientType)
    recipe = models.ForeignKey(Recipe)
    amount = models.IntegerField()
    units = models.CharField(max_length=4,choices=UNIT, 
                               default=None, null=True, blank = True)

class IngredientType(models.Model):
    name = models.CharField(max_length=200)
    plural_name = models.CharField(max_length=200)
    photo = models.ImageField( upload_to = 'images/ingredients')
    is_main = models.BooleanField()

我尝试使用rest_framework序列化它们:

class IngredientTypeSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = IngredientType
        fields=('name', 'plural_name', 'photo', 'is_main')

class IngredientSerializer(serializers.HyperlinkedModelSerializer):
    ingredient_type = …

我想学习如何整体获取多对多中间表的序列化程序数据model，而不仅仅是通过 id。

#this is my model class
class ProductMaterial(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    material = models.ForeignKey(Material, on_delete=models.CASCADE)
    material_rate = models.FloatField(blank=True, null=True)
    material_price = models.FloatField(blank=True, null=True)



#serializer
class ProductMaterialSerializer(serializers.ModelSerializer):
       class Meta:
           model = ProductMaterial
           fields = '__all__'

这将返回：

    {
        "id": 1,
        "material_rate": 0.3,
        "material_price": 6.7,
        "product": 186,
        "material": 7
    },
   {
        "id": 2,
        "material_rate": 0.7,
        "material_price": 1.7,
        "product": 186,
        "material": 8
    },

问题：

1. 第一个问题是由于多对多表而重复数据
2. 我也想查看我的product和material模型字段。

我的目标：

{
    "id": 1,
    "product": {
                 "name" : "abcd",
                 "date" …

我有以下型号：

class Packing(models.Model):
    name = models.CharField(max_length=100)
    size = models.CharField(max_length=50,blank=True)

class Product(models.Model):
    name = models.CharField(max_length=100)
    packing = models.ManyToManyField(Packing,related_name='products',through='Presentation')

class Presentation(models.Model):
    product = models.ForeignKey(Product)
    packing = models.ForeignKey(Packing)
    weight = models.DecimalField(decimal_places=3,max_digits=10)
    price = models.DecimalField(decimal_places=2,max_digits=10)

和我可能的序列化器：

class PresentationSerializer(serializers.ModelSerializer):
    class Meta:
        model = Presentation

class ProductSerializer(serializers.ModelSerializer):
    packing = PresentationSerializer(many=True,read_only=True,)
    class Meta:
        model = Product
        fields = ('name','packing')

预期结果：

{
    'name': 'produt',
    'packing': [
        {'name':'abcd','size':'big','weight':200,'price':222.22},
        {'name':'qwert','size':'small','weight':123,'price':534.21},
        {'name':'foo','size':'xxx','weight':999,'price':999.99}
    ]
}

我目前在使用 Django rest 框架执行两层嵌套时遇到问题。我已经阅读了带有嵌套关系的 DRF 文档http://www.django-rest-framework.org/api-guide/relations/并成功完成了第一层，即在 JSON 中显示具有多种颜色的样式。虽然不确定如何链接另一层。任何帮助，将不胜感激。提前致谢！

当前输出如下所示：

[{
    "name": "AAA123",
    "colors": [
        {
            "name": "White"
        }
    ]
},
{
    "name": "BBB222",
    "colors": [
        {
            "name": "White"
        },
        {
            "name": "Pink"
        },
        {
            "name": "Blue"
        }
    ]
}]

想要的输出应该是这样的：

[{
    "name": "AAA123",
    "colors": [
        {
            "name": "White",
            "sizes": [{name: "S"}, {name: "M"}]
        }
    ]
},
{
    "name": "BBB222",
    "colors": [
        {
            "name": "White",
            "sizes": [{name: "XS"}, {name: "S"}]
        },
        {
            "name": "Pink"
            "sizes": [{name: "XL"}, {name: "XXL"}] …

该模型定义了Article和Author类。它们以多对多的关系链接在一起。此关系是通过自定义中介表定义的：

# models.py
class Article(models.Model):
    title = models.CharField(max_length=500)
    authors = models.ManyToManyField(Author, through='AuthorOrder')

class Author(models.Model):
    name = models.CharField(max_length=255)

class AuthorOrder(models.Model):
    author = models.ForeignKey(Author)
    article = models.ForeignKey(Article)
    writing_order = models.IntegerField()

序列化应返回如下JSON：

#articles_json
{"fields":
     {
         "title": "A title",
         "authors": [
             {
                 "name":"Author 1",
                 "writing_order": 1
             },
             {
                 "name":"Author 2",
                 "writing_order": 2
             }
         }
     }
}

我确定了两种解决方案。

• 此建议建议单独序列化AuthorOrder字段。
• 第二个是使用Django Rest Framework。

我尝试了两者，但没有成功。您知道另一种方法吗？

我在 DRF 中使用带有直通模型的 m2m 场。一切正常，除了当我尝试嵌套成员序列化程序时。

模型.py

class SweepStakes(models.Model):                                                          
    name = models.CharField(max_length=255)                                      

class Event(models.Model):                                                                       
    sweepstakes = models.ManyToManyField(SweepStakes, through='EventSweepStakesMembership')

class EventSweepStakesMembership(models.Model):                                  
    event = models.ForeignKey(Event, on_delete=models.CASCADE)                   
    sweepstakes = models.ForeignKey(SweepStakes, on_delete=models.CASCADE)       
    enabled = models.BooleanField(default=False)

序列化程序.py

class EventSweepStakesSerializer(serializers.ModelSerializer):                      
    name = serializers.ReadOnlyField(source='sweepstakes.name')                     

    class Meta:                                                                     
        model = EventSweepStakesMembership                                          
        fields = ('name', 'enabled',)

class EventSerializer(BaseTenantSerializer):                                                                     
    sweepstakes = EventSweepStakesSerializer(many=True, read_only=True)             

    class Meta:                                                                     
        model = Event                                                               
        fields = ('sweepstakes',)

在这一点上，如果我将EventSweepStakesMembership模型和EventSweepStakesSerializer视图连接到一个视图，我会得到我期望的结果，输出如下：

{"name": "thingy", "enabled" true}

但是，当我将Event模型和EventSerializer序列化程序挂接到视图中时，该sweepstakes字段返回一个空字典而不是嵌套表示，如下所示：

{"sweepstakes": [{}]}

请注意，它不是一个空数组，换句话说，它确实看到了相关的直通模型，但只是在显示时没有正确序列化它。

没有错误，它只是空的。我曾尝试增加depth …

我无法弄清楚为什么我会收到此错误“序列化程序字段可能命名不正确，并且与GenericRelatedObjectManager实例上的任何属性或键都不匹配。原始异常文本是：'GenericRelatedObjectManager' 对象没有属性 'country'。”。我已经为此工作了几天，有人可以帮助我吗？我的代码有什么问题？提前致谢。

我想创建一个具有 CRUD 功能的嵌套序列化程序。计划在我的 DRF 中使用它。

我有 3 个相互关联的模型，即公司、地址和国家。

• 公司模型有一个名为“地址”的字段，它是一个 GenericForeignKey。
• 地址模型有一个名为“国家”的字段，它是外键。
• Country 模型是 CountryField()。我正在使用 django_countries 插件。

模型结构

Company
 |__Address (GenericForeignKey)
    |___Country (ForeignKey)

公司模式

from django_countries.fields import CountryField

class SalesClientCompany(models.Model):
            address = GenericRelation(
                Address,
                null=True,
                blank=True,
            )

地址模型

class Address(models.Model):

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE,)

    object_id = models.UUIDField(
        primary_key=False,
        unique=False,
        default=uuid.uuid4,
        blank=True,
        null=True,
    )

    content_object = GenericForeignKey()

    country = models.ForeignKey(
        Country,
        verbose_name=_("Country"),
        to_field='country',
        blank=False,
        on_delete=models.CASCADE,
    )

国家模式

from django_countries.fields import CountryField

class Country(SmardtAbstractHistory): …

我在序列化中间“枢轴”模型并附加到 Django Rest Framework 中多对多关系中的每个项目时遇到困难。

例子：

模型.py：

class Member(models.Model):
    name = models.CharField(max_length = 20)
    groups = models.ManyToManyField('Group', through='Membership')

class Group(models.Model):
    name = models.CharField(max_length = 20)

class Membership(models.Model):
    member = models.ForeignKey('Member')
    group = models.ForeignKey('Group')
    join_date = models.DateTimeField()

序列化器.py：

class MemberSerializer(ModelSerializer):
    class Meta:
        model = Member

class GroupSerializer(ModelSerializer):
    class Meta:
        model = Group

class MembershipSerializer(ModelSerializer):
    class Meta:
        model = Membership

我尝试遵循答案： Inclusion intermediary (through model) in returns in Django Rest Framework

但这不完全是我需要的

我需要生成以下输出

{
  "id": 1,
  "name": "Paul McCartney",
  "groups": [
    { …