10_17 序列化组件之model的运用

一。拆分的序列化。

　　model序列化的基本用法就是使用元类中的fields，其中model绑定的就是model中的表

　　如果需要多表查询，要在model中定义property：

class BookModelSerializer(ModelSerializer):
    publish = PublishModelSerializer()

    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish')

　　model该表中的property方法：

    @property
    def publish_name(self):
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name', 'age','detail__mobile').all()

　　这些都是model中的字段。

　　第二种就是使用外接的序列化类生成序列化对象，然后作为字段添加到field中。这种设定不是可插拔式的。

class PublishModelSerializer(ModelSerializer):
    class Meta:
        model = models.Publish
        fields = ('name', 'address')

class BookModelSerializer(ModelSerializer):

    publish = PublishModelSerializer()

    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish')

　　第三种不常用，就是使用field。exclude除了这立马的字段之外其他都显示，另加depth作为深度。

class BookModelSerializer(ModelSerializer):
    publish = PublishModelSerializer()
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish')
        # 了解知识点
        # 所有字段
        # fields = '__all__'
        # 与fields不共存，exclude排除哪些字段
        # exclude = ('id', 'is_delete', 'create_time')
        # 自动连表深度
        # depth = 1

　　这些序列化类在被定义之后，在view视图层种调用，调用的参数有instance，date和many

　　instance是需要序列化的对象，date是从前端接受的数据，many就是是否为多单位。

class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

　　反序列化使用：

　　重新继承一个modelserializer类，反序列化需要使用元类字段extra_kwargs。

　　这个是其他关键字段，其中的元素就是fields种的字段，字段种使用字段进行判断:

　　required：是否必填。

　　min_length等长度提示，

　　error_messages则是以上限时生效的时候返回给前端的错误信息。

　　进行反序列化后可以通过钩子函数（局部和全局）进判断。

class BookModelDeserializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用来完成反序列化字段的 系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            }
        }
    
    # 局部钩子
    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value
    # 全局钩子
    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

    # ModelSerializer类已经帮我们实现了 create 与 update 方法

　　这个模块已经帮我们实现了create和update，只需要在前端调用save方法即可。

二。整合的序列化。

　　在序列化类中，有以下信息：

　　model = models.book  模块的定义

　　fields = 操作的字段定义。

　　extra_kwargs  对字段的操作

　　在对字段的操作中，有三选一的操作：

　　　　required:True  是否必填。

　　　　read_only  只能序列化。

　　　　write_only 只能反序列化。

"""
1) fields中设置所有序列化与反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则
"""
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

三。单查询和群查询。

　　主要通过路由传输参数pk，判断是否有pk如果有pk则为单查，如果没有pk则为群查。

'''
单查路由：http://127.0.0.1:8000/api/v2/books/1/
单查数据返回：{
    "status": 0,
    "msg": "ok",
    "results": {
        "name": "南开大学",
        "price": "12.00",
        "img": "/media/img/default.jpg",
        "publish_name": "东京出版社",
    }
}
群查路由：http://127.0.0.1:8000/api/v2/books
群查数据返回：{
    "status": 0,
    "msg": "ok",
    "results": [
        {
            "name": "南开大学",
            "price": "12.00",
            "img": "/media/img/default.jpg",
            "publish_name": "东京出版社",
            "author_list": [
                {
                    "id": 1,
                    "is_delete": false,
                    "create_time": "2019-10-17T11:09:29.316398",
                    "name": "zzj",
                    "age": 12
                },
                {
                    "id": 2,
                    "is_delete": false,
                    "create_time": "2019-10-17T11:10:21.914888",
                    "name": "zzp",
                    "age": 43
                }
            ]
        },
        {
            "name": "南开大学",
            "price": "12.00",
            "img": "/media/img/default.jpg",
            "publish_name": "东京出版社",
            "author_list": [
                {
                    "id": 1,
                    "is_delete": false,
                    "create_time": "2019-10-17T11:09:29.316398",
                    "name": "zzj",
                    "age": 12
                },
                {
                    "id": 2,
                    "is_delete": false,
                    "create_time": "2019-10-17T11:10:21.914888",
                    "name": "zzp",
                    "age": 43
                }
            ]
        }
]
}
'''
def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer
　　　　　　　　　　(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

四，单增和多增。

　　增加的逻辑就是判断传入的数据是否是字典或列表，是字典则是单个，列表则是多个

'''
增添路由：http://127.0.0.1:8000/api/v2/books/
单增输入：
{
    "name":"南开大学12",
    "price":12,
    "publish":1,
    "authors":[1,2]
}
多增输入：
[
{
    "name":"南开大学1",
    "price":12,
    "publish":1,
    "authors":[1,2]
},
{
    "name":"南开大学2",
    "price":12,
    "publish":1,
    "authors":[1,2]
}
]
数据返回：
{
    "status": 0,
    "msg": "ok",
    "results": {
        "name": "南开大学12",
        "price": "12.00",
        "img": "/media/img/default.jpg",
        "publish_name": "东京出版社",
    }
}
'''

    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer
　　　　　　　　(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer
　　　　　　　　　　　　　　　　(book_result, many=many).data
        })

五。单删和多删。

　　单次删除时添加参数pk，而如果没有pk，则会获取传入参数 的数据中的pks。

　　最后都生成列表以并操作。

'''
单删路由：http://127.0.0.1:8000/api/v2/books/7/
多删路由:http://127.0.0.1:8000/api/v2/books/
多删输入：{"pks": [1, 2, 3]}
返回数据{
    "status": 0,
    "msg": "删除成功"
}
'''
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update
　　　　　　　　　　(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

六。整体单改

　　修改主要取决于序列化对象中的参数partial和所有字段中的required对象

"""
1) 单整体改，说明前台要提供修改的数据，那么数据就需要校验，
　　校验的数据应该在实例化“序列化类对象”时，赋值给data
2）修改，就必须明确被修改的模型类对象，并在实例化“序列化类对象”时，赋值给instance
3）整体修改，所有校验规则有required=True的字段，都必须提供，因为在实例化“序列化类对象”时，
　　参数partial默认为False
注：如果partial值设置为True，就是可以局部改
1）单整体修改，一般用put请求：
V2BookModelSerializer(
    instance=要被更新的对象, 
    data=用来更新的数据,
    partial=默认False，必须的字段全部参与校验
)
2）单局部修改，一般用patch请求：
V2BookModelSerializer(
    instance=要被更新的对象, 
    data=用来更新的数据,
    partial=设置True，必须的字段都变为选填字段
)
    注：partial设置True的本质就是使字段 required=True 校验规则失效
"""

　　对于单体全修改，使用put来提交数据。

　　如果系列化对象中同时存在对象和数据时，就会修改该数据：

'''
修改路由：http://127.0.0.1:8000/api/v2/books/7/
修改输入：
{
    "name":"南开大学123",
    "price":12,
    "publish":1,
    "authors":[1,2]
}(所有必填字段都要)
'''
class V2Book(APIView):
    # 单整体改: 对 v2/books/(pk)/ 传的数据是与model对应的字典
　　　　{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，
　　　　　　　　校验成功后，序列化类来帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, 
　　　　　　　　　　data=request_data, partial=False)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要更新的目标，用来更新的新数据
        book_obj = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })

七。单改和群局部修改。

　　只需要修改被改的对象。

　　首先通过是否有pk和传入的修改数据对象类型进行判断，同一替换成列表。

　　群体修改的数据需要一一对应。然后弹出pk。

　　其中需要定义listserializer中的update方法，重写，可以调用子的update方法进行重写。

# 重点：ListSerializer与ModelSerializer建立关联的是：
# ModelSerializer的Meta类的 - list_serializer_class
class V2BookListSerializer(ListSerializer):
    def update(self, instance, validated_data):
        # print(instance)  # 要更新的对象们
        # print(validated_data)  # 更新的对象对应的数据们
        # print(self.child)  # 服务的模型序列化类 - V2BookModelSerializer
        for index, obj in enumerate(instance):
            self.child.update(obj, validated_data[index])
        return instance
    
# 原模型序列化类变化
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        # ...
        # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法
        list_serializer_class = V2BookListSerializer
    # ...

　　视图：

'''
单局部修改路由：http://127.0.0.1:8000/api/v2/books/7/
单局部修改输入：{"name":"南开大学1234"}
群局部修改路由：http://127.0.0.1:8000/api/v2/books/
群局部修改输入：[
{"pk":1, "name":"123"}, 
{"pk":3, "price":7}, 
{"pk":7, "publish":2}
]

'''
class V2Book(APIView):
    # 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填
    # 群局部改：对 v2/books/ 
    # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]
    def patch(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')

        # 将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] | 
　　　　　　request_data=[每个要修改的对象对应的修改数据]
        if pk and isinstance(request_data, dict):  # 单改
            pks = [pk, ]
            request_data = [request_data, ]
        elif not pk and isinstance(request_data, list): # 群改
            pks = []
            for dic in request_data:  
　　　　　　# 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，
　　　　　　拿一个个字典
                pk = dic.pop('pk', None)
                if pk:
                    pks.append(pk)
                else:
                    return Response({
                        'status': 1,
                        'msg': '数据有误',
                    })
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })

        # pks与request_data数据筛选，
        # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，
　　　　　　　request_data对应索引位上的数据也移除
        # 2）将合理的pks转换为 objs
        objs = []
        new_request_data = []
        # [{},{},{}]
        for index, pk in enumerate(pks):
            try:
                # pk对应的数据合理，将合理的对象存储
                obj = models.Book.objects.get(pk=pk)
                objs.append(obj)
                # 对应索引的数据就需要保存下来
                new_request_data.append(request_data[index])
            except:
                # 重点：反面教程 - pk对应的数据有误，
　　　　　　　　　　将对应索引的data中request_data中移除
                # index = pks.index(pk)
                # request_data.pop(index)
                continue

        book_ser = serializers.V2BookModelSerializer
　　　　　　(instance=objs, data=new_request_data, partial=True, many=True)
        book_ser.is_valid(raise_exception=True)
        book_objs = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer
　　　　　　(book_objs, many=True).data
        })    

总结：

　　model层：

from django.db import models

# 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""

# 1) 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的Model不能在数据库中形成对应的表，设置 abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    """name、price、img、authors、publish、is_delete、create_time"""
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,
        related_name='books',
        on_delete=models.DO_NOTHING,
    )
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books'
    )


    @property
    def publish_name(self):
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name', 'age', 'detail__mobile').all()

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Publish(BaseModel):
    """name、address、is_delete、create_time"""
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Author(BaseModel):
    """name、age、is_delete、create_time"""
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class AuthorDetail(BaseModel):
    """mobile, author、is_delete、create_time"""
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,
    )

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name
    def __str__(self):
        return '%s的详情' % self.author.name

　　exception层：

from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.views import Response
from rest_framework import status
def exception_handler(exc, context):
    # drf的exception_handler做基础处理
    response = drf_exception_handler(exc, context)
    # 为空，自定义二次处理
    if response is None:
        print('%s - %s - %s' % (context['view'], context['request'].method, exc))
        return Response({
            'detail': '服务器错误'
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
    return response

　　serializers层：

from rest_framework.serializers import ModelSerializer, SerializerMethodField
from rest_framework.exceptions import ValidationError
from . import models


class PublishModelSerializer(ModelSerializer):
    class Meta:
        model = models.Publish
        fields = ('name', 'address')

class BookModelSerializer(ModelSerializer):
    # 了解: 该方式设置的序列化字段，必须在fields中声明
    # publish_address = SerializerMethodField()
    # def get_publish_address(self, obj):
    #     return obj.publish.address

    # 自定义连表深度 - 子序列化方式
    publish = PublishModelSerializer()

    class Meta:
        # 序列化类关联的model类
        model = models.Book
        # 参与序列化的字段
        fields = ('name', 'price', 'img', 'author_list', 'publish')

        # 了解知识点
        # 所有字段
        # fields = '__all__'
        # 与fields不共存，exclude排除哪些字段
        # exclude = ('id', 'is_delete', 'create_time')
        # 自动连表深度
        # depth = 1

class BookModelDeserializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用来完成反序列化字段的 系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

    # ModelSerializer类已经帮我们实现了 create 与 update 方法


"""
1) fields中设置所有序列化与反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则
"""
from rest_framework.serializers import ListSerializer

# 重点：ListSerializer与ModelSerializer建立关联的是：
# ModelSerializer的Meta类的 - list_serializer_class
class V2BookListSerializer(ListSerializer):
    def update(self, instance, validated_data):
        # print(instance)  # 要更新的对象们
        # print(validated_data)  # 更新的对象对应的数据们
        # print(self.child)  # 服务的模型序列化类 - V2BookModelSerializer
        for index, obj in enumerate(instance):
            self.child.update(obj, validated_data[index])
        return instance



class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

        # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法
        list_serializer_class = V2BookListSerializer

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

　　url：

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),

    url(r'^publishes/$', views.Publish.as_view()),
    url(r'^publishes/(?P<pk>.*)/$', views.Publish.as_view()),

    url(r'^v2/books/$', views.V2Book.as_view()),
    url(r'^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()),
]

　　view层：

from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers

class Publish(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                publish_obj = models.Publish.objects.get(pk=pk, is_delete=False)
                publish_data = serializers.PublishModelSerializer(publish_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '出版社不存在'
                })
        else:
            publish_query = models.Publish.objects.filter(is_delete=False).all()
            publish_data = serializers.PublishModelSerializer(publish_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': publish_data
        })



class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    def post(self, request, *args, **kwargs):
        request_data = request.data
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })



class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

    # 单整体改: 对 v2/books/(pk)/ 传的数据是与model对应的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，校验成功后，序列化类来帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data, partial=False)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要更新的目标，用来更新的新数据
        book_obj = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })


    # 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填
    # 群局部改：
    # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]
    def patch(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')

        # 将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] | request_data=[每个要修改的对象对应的修改数据]
        if pk and isinstance(request_data, dict):  # 单改
            pks = [pk, ]
            request_data = [request_data, ]
        elif not pk and isinstance(request_data, list): # 群改
            pks = []
            for dic in request_data:  # 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一个个字典
                pk = dic.pop('pk', None)
                if pk:
                    pks.append(pk)
                else:
                    return Response({
                        'status': 1,
                        'msg': '数据有误',
                    })
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })

        # pks与request_data数据筛选，
        # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，request_data对应索引位上的数据也移除
        # 2）将合理的pks转换为 objs
        objs = []
        new_request_data = []
        for index, pk in enumerate(pks):
            try:
                # pk对应的数据合理，将合理的对象存储
                obj = models.Book.objects.get(pk=pk)
                objs.append(obj)
                # 对应索引的数据就需要保存下来
                new_request_data.append(request_data[index])
            except:
                # 重点：反面教程 - pk对应的数据有误，将对应索引的data中request_data中移除
                # index = pks.index(pk)
                # request_data.pop(index)
                continue

        book_ser = serializers.V2BookModelSerializer(instance=objs, data=new_request_data, partial=True, many=True)
        book_ser.is_valid(raise_exception=True)
        book_objs = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_objs, many=True).data
        })



    # 总结：
    """
    1）单整体修改：
    V2BookModelSerializer(
        instance=要被更新的对象, 
        data=用来更新的数据,
        partial=默认False，必须的字段全部参与校验
    )
    2）单局部修改：
    V2BookModelSerializer(
        instance=要被更新的对象, 
        data=用来更新的数据,
        partial=设置True，必须的字段都变为选填字段
    )
    注：partial设置True的本质就是使字段 required=True 校验规则失效
    """