发表一对多关系 [英] Posting a one-to-many relationship

问题描述

我正在尝试通过Django REST框架将API暴露给我的Django模型。

我有一个对象观察。一个观察可以包含多个已经观察到的东西。所以我代表它是这样的：

  class Observation（models.Model）：
 
 photo_file = models .ImageField（upload_to = img_dir，blank = True，null = True）
 titestamp = models.DateTimeField（blank = True，null = True）
 latitude = models.FloatField（）
 longitude = model.FloatField（）
 
 
 class ObservedThing（models.Model）：
 thing = models.ForeignKey（Thing）＃被观察的东西
观察=模型。 ForeignKey（Observation，related_name ='observe_thing'）
 value = models.FloatField（）
  

据了解，这是一对多的关系。

我现在有一个API视图：

  class ObsvList（generics.ListCreateAPIView）：

表示观察列表的API端点

 model =观察
 serializer_class = ObsvSerializer 
  

和相应的序列号r：

  class ObsvSerializer（serializers.ModelSerializer）：
 
 observer_thing = serializers.PrimaryKeyRelatedField（many =真的）
 
 class Meta：
 model =观察
  

什么我必须做的是能够发现一个观察与几个事情检测到？我无法想像出来非常感谢。

解决方案

（或多或少地从另一个类似但不太清楚的问题）

要在单个POST中创建多个相关对象，需要不可用的可写嵌套序列化程序。

完全支持是正在进行中，但同时一个（黑客）解决方案是在每种情况下，在视图中覆盖 create 方法：

  class FooListCreateView （ListCreateAPIView）：
 model = Foo 
 serializer_class = FooSerializer 
 
 def create（self，request，* args，** kwargs）：
 data = request.DATA 
 
f = Foo.objects.create（）
 
＃...创建嵌套对象请求数据... 
 
＃... 
返回响应（serializer.data，
 status = status.HTTP_201_CREATED，
 headers = headers）
  

可能不是很理想，但它适用于我，直到正确的方式。

另一个选项是使用单独的POST单独创建相关的 Observation 对象，并使用 PrimaryKeyRelatedField或HyperlinkedRelatedField ，使最终 ObservedThing POST。

I'm trying to expose an API to my Django model through Django REST framework.

I have an object Observation. An observation can contain multiple things that have been observed. So I represented it like this:

class Observation(models.Model):

    photo_file = models.ImageField( upload_to=img_dir,   blank=True, null=True )
    titestamp = models.DateTimeField(blank=True, null=True)
    latitude = models.FloatField()
    longitude = models.FloatField()


class ObservedThing(models.Model):
    thing = models.ForeignKey(Thing) # the thing being observed
    observation = models.ForeignKey(Observation, related_name='observed_thing')
    value = models.FloatField()

As I understand this is a one-to-many relationship.

I now have an API View:

class ObsvList(generics.ListCreateAPIView):
    """
    API endpoint that represents a list of observations.
    """
    model = Observation
    serializer_class = ObsvSerializer

and the corresponding serialiser:

class ObsvSerializer(serializers.ModelSerializer):

    observed_thing = serializers.PrimaryKeyRelatedField(many=True)

    class Meta:
        model = Observation

What do I have to do to be able to POST an observation with several things detected? I cannot figure it out. Many thanks.

解决方案

(answer more or less copied from another similar but less clear question)

To create multiple related objects in a single POST requires writable nested serializers which are not yet available.

Full support is a work in progress, but in the mean time one (hacky) solution is to override the create method in the view in each case:

class FooListCreateView(ListCreateAPIView):
    model = Foo
    serializer_class = FooSerializer

    def create(self, request, *args, **kwargs):
        data=request.DATA

        f = Foo.objects.create()

        # ... create nested objects from request data ...  

        # ...
        return Response(serializer.data, 
                        status=status.HTTP_201_CREATED,
                        headers=headers)

Probably not ideal, but it works for me until the proper way comes along.

The other option is to create the related Observation objects individually with separate POSTs, and the use PrimaryKeyRelatedField or HyperlinkedRelatedField to make the associations in the final ObservedThing POST.

这篇关于发表一对多关系的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！