drf 序列模块

Posted 2021-03-19 shaozheng

目录

• drf 序列模块
  • 属性配置：
  • 自定义response封装：
  • 多表深度查询方式：
  • 单删 | 群删
  • 单增 | 群增
  • put 改：
  • patch 改：

drf 序列模块

属性配置：

class Meta:
    model = models.xx   
    filter = '__all__'  

1.filter = '__all__'  :   ：获取改类内所有的反序列 | 序列化字段

2.filter = ['name',.....] : 获取反序列 | 序列化字段

3.exclude = ['name']      ：获取除内面之内的字段，与上属性不同时使用

4.depth = d(int)    ：自动深度，值代表深度次数，但是被深度的外键采用__all__，显示子序列所有字段

 

自定义response封装：

# Response.py:

from rest_framework.response import Response

class APIResponse(Response):

    def __init__(self,status=0,msg='ok',results=None,http_status=400,headers=None,
                 exception=False,content_type=None,**kwargs):
        '''
        自定义的字段放入data 内
        '''
        data = {
            'status': status,
            'msg' : msg,
        }

        # 判断结果是否有数据， results只要不为空都是数据：False、0、'' 都是数据 => 条件不能写if results

        if results is not None:
            data['results'] =  results

        data.update(**kwargs)   # 字典添加值，打散传入

      super().__init__(data=data,status=status,headers=headers,exception=exception,content_type=content_type,)

多表深度查询方式：

#方式一：子序列化
    1）只能在序列化中使用
    2）字段名必须是外键(正向反向)字段
     因为相对于自定义序列化外键字段，自定义序列化字段是不能参与反序列化的，而子序列化必须为外键名，所以就无法入库
    3）在外键关联数据是多条时，需要明确many=True
   4）是单向操作，因为作为子系列的类必须写在上方，所以不能产生逆方向的子序列化

class  BookModelSerializer(serializers.ModelSerializer):
    pass

class PublishModelSerializer(serializers.ModelSerializer):
    books = BookModelSerializer(many=True)  # 与子序列建立联系（深度）
    class Meta:
        model = models.Publish
        fields = ['name','address','books']


#方法二： 配置depth
        自动深度查询的是关联表的所有字段，数据量太多
   class Meta:
        model = models.Publish
        fields = ['name', 'address', 'books']
        # fields = '__all__'
        # exclude = ['name']   
         depth = 2  # 自动深度，值代表深度次数，但是被深度的外键采用__all__，显示子序列化所有字段



#方法三 :  插拔式@property
            名字不能与外键名同名

 # models.py
    
    @property
    def author_list(self):
        author_list_temp = []  # 存放所有作者格式化成数据的列表
        authors = self.authors.all()  # 所有作者
        for author in authors:  # 遍历处理所有作者
            author_dic = {
                'name': author.name,
            }
            try:  # 有详情才处理详情信息
                author_dic['mobile'] = author.detail.mobile
            except:
                author_dic['mobile'] = '无'

            author_list_temp.append(author_dic)  # 将处理过的数据添加到数据列表中

        return author_list_temp  # 返回处理后的结果

单删 | 群删

# 单删群删
    def delete(self, request, *args, **kwargs):
        """
        单删：接口：/books/(pk)/   数据：空
        群删：接口：/books/   数据：[pk1, ..., pkn]
        逻辑：修改is_delete字段，修改成功代表删除成功，修改失败代表删除失败
        """
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]  # 将单删格式化成群删一条
        else:
            pks = request.data  # 群删
        try:  # 数据如果有误，数据库执行会出错
            rows = models.Book.objects.filter(is_delete=False, pk__in=pks).update(is_delete=True)
        except:
            return APIResponse(1, '数据有误')

        if rows:
            return APIResponse(0, '删除成功')
        return APIResponse(1, '删除失败')

单增 | 群增

def post(self, request, *args, **kwargs):
     """
        单增：接口：/books/   数据：{...} 
        群增：接口：/books/   数据：[{...}, ..., {...}]
        逻辑：将数据给系列化类处理，数据的类型关系到 many 属性是否为True
        """
    if isinstance(request.data, dict):
        many= False
     elif isinstance(request.data,list):
        many= True
     else:
        return Response(data={'detail': '数据有误'}，status=400)
    book_ser = serializers.BookModelSerializer(data=request.data, many=many)
    book_ser.is_valid(raise_exception=True)
    book_obj_or_list = book_ser.save()
    return APIResponse(results=serializers.BookModelSerializer(book_obj_or_list, many=many).data)

put 改：

 """
  单改：接口：/books/(pk)/   数据：{...}
   群增：接口：/books/   数据：[{pk, ...}, ..., {pk, ...}]
   逻辑：将数据给系列化类处理，数据的类型关系到 many 属性是否为True
    """
    pk = kwargs.get('pk')
    if pk:  # 单改
        try:
            # 与增的区别在于，需要明确被修改的对象，交给序列化类
            book_instance = models.Book.objects.get(is_delete=False, pk=pk)
            except:
                return Response({'detail': 'pk error'}, status=400)

            book_ser = serializers.BookModelSerializer(instance=book_instance, data=request.data)
            book_ser.is_valid(raise_exception=True)
            book_obj = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_obj).data)
        else:  # 群改
            # 分析（重点）：
            # 1）数据是列表套字典，每个字典必须带pk，就是指定要修改的对象，如果有一条没带pk，整个数据有误
            # 2）如果pk对应的对象已被删除，或是对应的对象不存在，可以认为整个数据有误(建议)，可以认为将这些错误数据抛出即可
            request_data = request.data
            try:
                pks = []
                for dic in request_data:
                    pk = dic.pop('pk')  # 解决分析1，没有pk pop方法就会抛异常
                    pks.append(pk)

                    book_query = models.Book.objects.filter(is_delete=False, pk__in=pks).all()
                    if len(pks) != len(book_query):
                        raise Exception('pk对应的数据不存在')
                        except Exception as e:
                            return Response({'detail': '%s' % e}, status=400)

                        book_ser = serializers.BookModelSerializer(instance=book_query, data=request_data, many=True)
                        book_ser.is_valid(raise_exception=True)
                        book_list = book_ser.save()
                        return APIResponse(results=serializers.BookModelSerializer(book_list, many=True).data)

patch 改：

   def patch(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:  # 单改
            try:
                book_instance = models.Book.objects.get(is_delete=False, pk=pk)
            except:
                return Response({'detail': 'pk error'}, status=400)
            # 设置partial=True的序列化类，参与反序列化的字段，都会置为选填字段
            # 1）提供了值得字段发生修改。
            # 2）没有提供的字段采用被修改对象原来的值

            # 设置context的值，目的：在序列化完成自定义校验(局部与全局钩子)时，可能需要视图类中的变量，如请求对象request
            # 可以通过context将其传入，在序列化校验方法中，self.context就能拿到传入的视图类中的变量
            book_ser = serializers.BookModelSerializer(instance=book_instance, data=request.data, partial=True, context={'request': request})
            book_ser.is_valid(raise_exception=True)
            book_obj = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_obj).data)
        else:  # 群改
            request_data = request.data
            try:
                pks = []
                for dic in request_data:
                    pk = dic.pop('pk')
                    pks.append(pk)

                book_query = models.Book.objects.filter(is_delete=False, pk__in=pks).all()
                if len(pks) != len(book_query):
                    raise Exception('pk对应的数据不存在')
            except Exception as e:
                return Response({'detail': '%s' % e}, status=400)

            book_ser = serializers.BookModelSerializer(instance=book_query, data=request_data, many=True, partial=True)
            book_ser.is_valid(raise_exception=True)
            book_list = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_list, many=True).data)