DRF中多对多ManytoMany字段的更新和添加

# models.py
import django.utils.timezone as timezone
from django.contrib.auth.models import User
from django.db import models
from serverorders.models import BusinessArea
from menu.models import Menu
import uuid


# Create your models here.
class OrderCenter(models.Model):
    orderId = models.UUIDField(verbose_name='订单编号', default=uuid.uuid4, editable=False)
    orderBusinessArea = models.ForeignKey(to=BusinessArea, verbose_name='订单营业区域', null=True, blank=True,
                                          on_delete=models.CASCADE)
    orderMenu = models.ManyToManyField(to=Menu, verbose_name='多选菜品', null=True, blank=True,
                                       related_name='orderMenu', through='OrderCenterThough')
    orderPerson = models.ForeignKey(to=User, on_delete=models.CASCADE, null=True, blank=True, verbose_name='下单人')
    isCancel = models.BooleanField(verbose_name='是否取消', default=False)
    orderCreatTime = models.DateTimeField("创建日期", default=timezone.now)
    orderModTime = models.DateTimeField('最后修改日期', auto_now=True)

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

    class Meta:
        verbose_name = '订单'
        verbose_name_plural = verbose_name


class OrderCenterThough(models.Model):
    order_id = models.ForeignKey(to='OrderCenter', on_delete=models.CASCADE,verbose_name='订单ID')
    menu_id = models.ForeignKey(to=Menu, on_delete=models.CASCADE, verbose_name='菜品ID')
    menu_number = models.IntegerField(verbose_name="菜品数量")
    isCancel = models.BooleanField(verbose_name='是否取消', default=False)
    orderCreatTime = models.DateTimeField("创建日期", default=timezone.now)
    orderModTime = models.DateTimeField('最后修改日期', auto_now=True)

    class Meta:
        unique_together = ('order_id', 'menu_id')
        verbose_name = '订单中间表'
        verbose_name_plural = verbose_name

# serializer.py
from rest_framework import serializers
# 用于读取OrderCenter
class ReadOrderCenterSerializer(serializers.ModelSerializer):

    # 进一步自定义中间表字段的序列化表示，可以在 to_representation 方法中进行处理
    def to_representation(self, instance):
        representation = super(ReadOrderCenterSerializer, self).to_representation(instance)
        # 定义要显示的orderMenu
        representation['orderMenu'] = []
        # 此时的实例对象是OrderCent，传入实例对象获取orderMenu字段输入many = True 表示多个再使用.data序列化出来
        for i in MenuSerializer(instance.orderMenu, many=True).data:
            # 实例Order的ordercenterthough_set查找外键表传入查找的字段并用data序列话出来
            reason = OrderCenterThoughSerializer(instance.ordercenterthough_set.get(order_id=instance.id, menu_id=i['id'])).data
            # 加入到menu_number字段上
            i['menu_number_detail'] = reason
            # 列表添加，最好返回所有内容
            representation['orderMenu'].append(i)
        # 处理下把订单区域和下单人显示出来
        representation['orderBusinessAreaName']=instance.orderBusinessArea.area
        representation['orderPersonName'] = instance.orderPerson.username
        return representation

    class Meta:
        model = OrderCenter
        fields = "__all__"
        # 查询深度
        depth: 2

# 用于写的OrderCenter
class OrderCenterSerializer(serializers.ModelSerializer):

    class Meta:
        model = OrderCenter
        fields = "__all__"
        depth: 2
        
        
# OrderCenterMenu中间表
class OrderCenterThoughSerializer(serializers.ModelSerializer):

    class Meta:
        model = OrderCenterThough
        fields = "__all__"

from rest_framework import viewsets, status
from .serializers import ReadOrderCenterSerializer, OrderCenterSerializer, OrderCenterThoughSerializer
class OrderCenterViewSet(viewsets.ModelViewSet):
    """
    API endpoint that allows groups to be viewed or edited.
    """
    queryset = OrderCenter.objects.all()
    serializer_class = OrderCenterSerializer
    # permission_classes = [permissions.IsAuthenticated] # 权限方面

    # 这里是根据不同的请求调用不同的序列化器
    def get_serializer_class(self):
        print(self.action)
        if self.action == "list" or self.action == "retrieve":
            return ReadOrderCenterSerializer
        else:
            # 当不是list 和 retrieve的时候用下面的序列化器
            return self.serializer_class

    #更新
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False) # 请求方式为patch的时候partial:True
        instance = self.get_object()
        # 发送的数据传orderBusinessArea_id 这里处理将orderBusinessArea设置为orderBusinessArea_id一样的值
        request.data['orderBusinessArea'] = request.data.get('orderBusinessArea_id')
        # 获取传入过来的多对多信息格式为[{},{}]
        # 我的方法比较笨，理论上是可以传入多个的就是在实例化的时候添加many = True 来标识，但是实在是没心思搞了
        orderMenu = request.data.get('orderMenu')
        for i in orderMenu:
        # 我的思路是既然不能在更新主表的时候更新多对多字段那就单独把多对多字段提出来更新
        # 在传入对多对多字段的时候同步传入需要更新的中间表id
            obj = OrderCenterThough(pk=i.get('id'))
            # 将获取到的id实例 传入序列化器中再把需要更新的字段传入data
            obj_serializer = OrderCenterThoughSerializer(instance=obj, data=i)
            # 校验
            obj_serializer.is_valid()
            保存
            obj_serializer.save()
        request.data['orderPerson'] = request.data.get('orderPerson_id')
        serializer = self.get_serializer(instance, data=request.data, partial=partial)

        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        # for i in serializer.data:
        #     print(i)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)
    # 创建新的订单
    def create(self, request, *args, **kwargs):
        #先取出传入的多对多字段
        orderMenu= request.data.pop('orderMenu',[])
        # 在创建的时候先创建一个centerodrer然后获取centerorder的pk 再创建对应的OrderCenterThough收到更新中间表数据
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        # 上面创建了主订单，这里获取主订单的id
        #print(serializer.instance.pk)
        # 遍历多对多字段
        for i in orderMenu:
            # 找到需要更新的那个中间表对应id
            i['order_id'] = serializer.instance.pk
            # 组建新的中间表数据传入序列化器中
            ojb = OrderCenterThoughSerializer(data=i)
            # 校验
            ojb.is_valid()
            # 保存
            ojb.save()
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)