0

我们的项目是一个虚构的网上商店，您可以将小狗放入购物车并订购它们。我们拥有的三个主要模型是用户、订单和小狗。因为每个订单都有一个小狗列表，每只小狗都有自己的数量，我们需要一个中间模型来处理这两者，因为简单的 ManyToManyField 显然无法处理额外的列。这使事情变得更加复杂（至少对于刚接触 Django 的人来说）。此外，我们的授权是通过 JWT 令牌进行的，这就是为什么 self.request.user 显然必须手动设置而不是自动设置的原因。唯一可以通过 POST 创建的是新订单。这些应该自动获得一个日期，并且发布它的用户也应该自动设置。

在反应中发布：

async function createOrder(auth, puppies) {
  auth = auth.token
  puppies = puppies.map(element =>
    element = {'id' : element.puppy.id, 'amount': element.amount}
  )
  const res = await fetch(REACT_APP_BACKEND_URL + `/shop/orders/`, {
      method: 'POST',
      headers: {
        "Content-Type": "application/json",
        "Authorization": "JWT " +  auth
      },
      body: JSON.stringify({ puppies })
    })
  return res.json()

console.log 结果：[{"id":2,"amount":1},{"id":3,"amount":1}]

模型.py：

from django.db import models
from django.conf import settings
from django.contrib.auth.models import User
from django.db.models.signals import post_save
from django.dispatch import receiver


class Puppy(models.Model):
    name = models.CharField(max_length=30)
    price = models.DecimalField(max_digits=6, decimal_places=2)
    image_url = models.CharField(max_length=200)
    age = models.IntegerField(null=True)
    weight = models.IntegerField(null=True)
    description_de = models.CharField(max_length=500, null=True)
    description_en = models.CharField(max_length=500, null=True)

    def __str__(self):
        return self.name


class Order(models.Model):
    total_price = models.DecimalField(max_digits=9, decimal_places=2, null=True)
    puppies = models.ManyToManyField(Puppy, through='PuppyOrder')
    date = models.DateTimeField(auto_now_add=True, blank=True)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='orders')

    def __str__(self):
        return str(self.id)


class PuppyOrder(models.Model):
    order = models.ForeignKey(Order, on_delete=models.CASCADE)
    puppy = models.ForeignKey(Puppy, on_delete=models.CASCADE)
    amount = models.IntegerField()

    def __str__(self):
        return str(self.id)


class Address(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    country = models.CharField(max_length=30, blank=True)
    street = models.CharField(max_length=30, blank=True)
    zip = models.CharField(max_length=10, blank=True)
    city = models.CharField(max_length=30, blank=True)


@receiver(post_save, sender=User)
def create_user_address(sender, instance, created, **kwargs):
    if created:
        Address.objects.create(user=instance)


@receiver(post_save, sender=User)
def save_user_address(sender, instance, **kwargs):
    instance.address.save()

视图.py：

from shop.models import Puppy, Order
from django.contrib.auth.models import User
from rest_framework import permissions, status, viewsets, generics
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework.reverse import reverse
from rest_framework.exceptions import ValidationError
from rest_framework_jwt.serializers import VerifyJSONWebTokenSerializer
from .serializers import UserSerializer, UserSerializerWithToken, OrderSerializer, PuppySerializer
from .permissions import IsOwner


@api_view(['GET'])
def api_root(request, format=None):
    return Response({
        'users': reverse('user-list', request=request, format=format),
        'orders': reverse('order-list', request=request, format=format),
        'puppies': reverse('puppy-list', request=request, format=format),
    })


class OrderList(generics.ListCreateAPIView):
    queryset = Order.objects.all()
    permission_classes = (permissions.IsAuthenticated,)
    serializer_class = OrderSerializer

    def get_queryset(self):
        return Order.objects.all().filter(user=self.request.user)

    def perform_create(self, serializer):
        print('Creating new order...')
        serializer.save(user=self.request.user)
        return Response(serializer.data)


class OrderDetail(generics.RetrieveAPIView):
    permission_classes = (permissions.IsAuthenticated,)
    queryset = Order.objects.all()
    serializer_class = OrderSerializer

    def get_queryset(self):
        return Order.objects.all().filter(user=self.request.user)


class UserList(generics.ListAPIView):
    queryset = User.objects.all().select_related('address')
    serializer_class = UserSerializer


class UserDetail(generics.RetrieveAPIView):
    queryset = User.objects.all().select_related('address')
    serializer_class = UserSerializer


class PuppyList(generics.ListAPIView):
    permission_classes = (permissions.AllowAny,)
    queryset = Puppy.objects.all()
    serializer_class = PuppySerializer


class PuppyDetail(generics.RetrieveAPIView):
    permission_classes = (permissions.AllowAny,)
    queryset = Puppy.objects.all()
    serializer_class = PuppySerializer

序列化程序.py：

from rest_framework import serializers
from rest_framework_jwt.settings import api_settings
from django.contrib.auth.models import User
from django.db import models
from .models import Order, Puppy, PuppyOrder


class UserSerializer(serializers.ModelSerializer):
    orders = serializers.PrimaryKeyRelatedField(many=True, read_only=True)

    class Meta:
        model = User
        fields = ('id', 'username', 'orders')


class UserSerializerWithToken(serializers.ModelSerializer):
    # Code to generate token on login ...

class PuppySerializer(serializers.ModelSerializer):
    description = serializers.SerializerMethodField()

    def get_description(self, puppy):
        return {'DE': puppy.description_de, 'EN': puppy.description_en}

    class Meta:
        model = Puppy
        fields = ('id', 'name', 'price', 'image_url', 'age', 'weight', 'description')


class PuppyOrderSerializer(serializers.ModelSerializer):
    puppy = serializers.ReadOnlyField(source='puppy.id')
    order = serializers.ReadOnlyField(source='order.id')

    class Meta:
        model = PuppyOrder
        fields = ('order', 'puppy', 'amount')


class OrderSerializer(serializers.ModelSerializer):
    user = serializers.ReadOnlyField(source='user.username')
    puppies = PuppyOrderSerializer(source='puppyorder_set', many=True)

        def create(self, validated_data):
        print(validated_data)
        puppies = validated_data.pop("puppyorder_set")
        order = Order.objects.create(**validated_data)
        total_price = 0
        for puppy in puppies:
            puppy_id = puppy.get("id")
            amount = puppy.get("amount")
            puppy_instance = Puppy.objects.get(pk=puppy_id)
            total_price += puppy_instance.price
            PuppyOrder(order=order, puppy=puppy_instance, amount=amount).save()
        order.save()
        return Order

    class Meta:
        model = Order
        fields = ('id', 'total_price', 'puppies', 'date', 'user')

此代码导致错误：“禁止直接分配到多对多集合的前端。请改用 puppies.set()。 ”请告诉我我做错了什么

4

1 回答 1

0

有很多事情你做得不太对。一是身份认证。请检查DRF-JWT或类似的库并使用它们的身份验证类，或者至少看看如何创建你的，这样你的身份验证就不会散布在你的代码中。

至于perform_create在您看来，您实际上不必检查serializer.is_valid()那里。它在被调用create之前已经被签入perform_create。据我所知，该方法并不意味着返回 API 响应。它只是为了在调用之前执行您想要的任何其他额外操作serializer.save()。对于大多数基本用法，它永远不会被覆盖。您还可以将您的用户和日期传递给 save 方法或在序列化程序中执行此操作。

现在，在序列化程序的 create 方法中，您不需要访问initial_data. 您需要的一切都应该在validated_data. 首先，你应该在调用之前弹出puppiesfrom ，否则它将无法处理它。然后，您现在可以使用前面的弹出小狗创建对象。validated_dataobjects.createPuppyOrder

这是在视图的 perform_create 中向序列化程序的验证数据添加额外数据的方式：

serializer.save(date=datetime.today(), user=self.request.user, total_price=total_price)

您可以在序列化程序的 create 方法中执行相同的操作，只需将项目直接添加到验证数据中即可。毕竟这只是一本普通的字典：

validated_data['user'] = self.context['request'].user
validated_data['date'] = datetime.today()
validated_data['total_price'] = total_price

编辑：对 PuppyOrder 使用非模型序列化程序

由于在发送请求时尚未创建订单和 PuppyOrder，因此 OrderSerializer 中的以下行将导致错误，因为序列化程序需要实际的 PuppyOrders

puppies = PuppyOrderSerializer(source='puppyorder_set', many=True)

相反，您可以像这样使用非模型序列化程序（假设小狗已经存在）：

class PuppyOrderCreateSerializer(serializers.Serializer):
    puppy = serializers.PrimaryKeyRelatedField(queryset=Puppy.objects.all())
    amount = serializers.IntegerField()

然后你可以在 yuur OrderSerializer 中使用这个序列化器：

puppies_data = PuppyOrderCreateSerializer(many=True)
于 2019-01-19T17:09:08.793 回答