11 Book系列多表群操作 - 图1

Book系列连表接口

views.py

  1. from django.shortcuts import render
  3. # Create your views here.
  4. from rest_framework.views import APIView
  5. from rest_framework.viewsets import ModelViewSet
  6. from app01.models import Book
  7. # from app01.ser import BookSerializers
  8. from rest_framework.decorators import action
  9. from rest_framework.response import Response
  10. from rest_framework.authentication import SessionAuthentication, BasicAuthentication
  11. # class TestView(APIView):
  12. #     def get(self,request):
  13. #         1/0
  14. #         return Response({'msg':'个人中心'})
  15. #
  16. # class BookViewSet(ModelViewSet):
  17. #     authentication_classes = [BasicAuthentication,]
  18. #     queryset = Book.objects.all()
  19. #     serializer_class = BookSerializers
  20.     # @action(methods=['get'], detail=False)
  21.     # def login(self, request):
  22.     #     Book.objects.update_or_create()
  23.     #     return Response({'msg':'登陆成功'})
  24.     # @action(methods=['put'], detail=True)
  25.     # def get_new_5(self, request,pk):
  26.     #     return Response({'msg':'获取5条数据成功'})
  28. from rest_framework.permissions import AllowAny,IsAuthenticated,IsAdminUser,IsAuthenticatedOrReadOnly
  32. from app01.response import APIResponse
  33. from app01 import models
  34. from app01 import ser as serializers
  35. class PublishAPIView(APIView):
  36.     def get(self, request, *args, **kwargs):
  37.         pk = kwargs.get('pk')
  38.         if pk:
  39.             publish_obj = models.Publish.objects.filter(pk=pk).first()
  40.             if not publish_obj:
  41.                 return APIResponse(1, 'pk error', http_status=400)
  42.             publish_data = serializers.PublishModelSerializer(publish_obj).data
  43.             return APIResponse(results=publish_data)
  45.         publish_query = models.Publish.objects.all()
  46.         return APIResponse(0, 'ok', data=serializers.PublishModelSerializer(publish_query, many=True).data)
  49. class BookAPIView(APIView):
  50.     # 单查、群查
  51.     def get(self, request, *args, **kwargs):
  52.         pk = kwargs.get('pk')
  53.         if pk:
  54.             book_obj = models.Book.objects.filter(pk=pk, is_delete=False).first()
  55.             if not book_obj:
  56.                 return APIResponse(1, 'pk error', http_status=400)
  57.             book_data = serializers.BookModelSerializer(book_obj).data
  58.             print(book_data)
  59.             return APIResponse(data=book_data)
  61.         book_query = models.Book.objects.filter(is_delete=False).all()
  63.         return APIResponse(0, 'ok', data=serializers.BookModelSerializer(book_query, many=True).data)
  65.     # 单删、群删
  66.     def delete(self, request, *args, **kwargs):
  67.         """
  68.         单删：前台数据为pk，接口为 /books/(pk)/
  69.         群删：前台数据为pks，接口为 /books/
  70.         """
  71.         pk = kwargs.get('pk')
  72.         # 将单删群删逻辑整合
  73.         if pk:  # /books/(pk)/的接口就不考虑群删，就固定为单删
  74.             pks = [pk]
  75.         else:
  76.             pks = request.data.get('pks')
  77.         # 前台数据有误(主要是群删没有提供pks)
  78.         if not pks:
  79.             return APIResponse(1, 'delete error', http_status=400)
  80.         # 只要有操作受影响行，就是删除成功，反之失败
  81.         rows = models.Book.objects.filter(is_delete=False, pk__in=pks).update(is_delete=True)
  82.         if rows:
  83.             return APIResponse(0, 'delete ok')
  84.         return APIResponse(1, 'delete failed')
  86.     # 单增、群增
  87.     def post(self, request, *args, **kwargs):
  88.         """
  89.         单增：前台提交字典，接口 /books/
  90.         群增：前台提交列表套字典，接口 /books/
  91.         """
  92.         request_data = request.data
  93.         if isinstance(request_data, dict):  # 单增
  94.             book_ser = serializers.BookModelSerializer(data=request_data)
  95.             if book_ser.is_valid():
  96.                 book_obj = book_ser.save()
  97.                 return APIResponse(data=serializers.BookModelSerializer(book_obj).data)
  98.             return APIResponse(1, msg=book_ser.errors)
  99.         elif isinstance(request_data, list) and len(request_data) != 0 :  # 群增
  100.             book_ser = serializers.BookModelSerializer(data=request_data, many=True)
  101.             book_ser.is_valid(raise_exception=True)
  102.             book_obj_list = book_ser.save()
  103.             return APIResponse(data=serializers.BookModelSerializer(book_obj_list, many=True).data)
  104.         else:
  105.             return APIResponse(1, 'data error', http_status=400)
  107.     # 单整体改、群整体改
  108.     def put(self, request, *args, **kwargs):
  109.         """
  110.         单整体改：前台提交字典，接口 /books/(pk)/
  111.         群整体改：前台提交列表套字典，接口 /books/，注每一个字典都可以通过pk
  112.         """
  113.         pk = kwargs.get('pk')
  114.         request_data = request.data
  115.         if pk: # 单改
  116.             try:
  117.                 book_obj = models.Book.objects.get(pk=pk)
  118.             except:
  119.                 return APIResponse(1, 'pk error')
  121.             # 修改和新增，都需要通过数据，数据依旧给data，修改与新增不同点，instance要被赋值为被修改对象
  122.             book_ser = serializers.BookModelSerializer(instance=book_obj, data=request_data)
  123.             book_ser.is_valid(raise_exception=True)
  124.             book_obj = book_ser.save()
  125.             return APIResponse(data=serializers.BookModelSerializer(book_obj).data)
  126.         else:  # 群改
  127.             if not isinstance(request_data, list) or len(request_data) == 0:
  128.                 return APIResponse(1, 'data error', http_status=400)
  130.             # [{pk:1,...}, {pk:3,...}, {pk:100,...}] => [obj1, obj3, obj100] + [{...}, {...}, {...}]
  131.             # 要考虑pk对应的对象是否被删，以及pk没有对应的对象
  132.             # 假设pk3被删，pk100没有 => [obj1] + [{...}]
  134.             # 注：一定不要在循环体中对循环对象进行增删(影响对象长度)的操作
  135.             obj_list = []
  136.             data_list = []
  137.             for dic in request_data:
  138.                 # request_data可能是list，单内部不一定是dict
  139.                 try:
  140.                     pk = dic.pop('pk')
  141.                     try:
  142.                         obj = models.Book.objects.get(pk=pk, is_delete=False)
  143.                         obj_list.append(obj)
  144.                         data_list.append(dic)
  145.                     except:
  146.                         pass
  147.                 except:
  148.                     return APIResponse(1, 'data error', http_status=400)
  150.             book_ser = serializers.BookModelSerializer(instance=obj_list, data=data_list, many=True)
  151.             book_ser.is_valid(raise_exception=True)
  152.             book_obj_list = book_ser.save()
  153.             return APIResponse(data=serializers.BookModelSerializer(book_obj_list, many=True).data)
  155.     # 单局部改、群局部改
  156.     def patch(self, request, *args, **kwargs):
  157.         """
  158.         单整体改：前台提交字典，接口 /books/(pk)/
  159.         群整体改：前台提交列表套字典，接口 /books/，注每一个字典都可以通过pk
  160.         """
  161.         pk = kwargs.get('pk')
  162.         request_data = request.data
  163.         if pk:
  164.             try:
  165.                 book_obj = models.Book.objects.get(pk=pk)
  166.             except:
  167.                 return APIResponse(1, 'pk error')
  168.             # 局部修改就是在整体修改基础上设置partial=True，将所有参与反序列化字段设置为required=False
  169.             book_ser = serializers.BookModelSerializer(instance=book_obj, data=request_data, partial=True)
  170.             book_ser.is_valid(raise_exception=True)
  171.             book_obj = book_ser.save()
  172.             return APIResponse(data=serializers.BookModelSerializer(book_obj).data)
  174.         else:  # 群改
  175.             if not isinstance(request_data, list) or len(request_data) == 0:
  176.                 return APIResponse(1, 'data error', http_status=400)
  178.             # [{pk:1,...}, {pk:3,...}, {pk:100,...}] => [obj1, obj3, obj100] + [{...}, {...}, {...}]
  179.             # 要考虑pk对应的对象是否被删，以及pk没有对应的对象
  180.             # 假设pk3被删，pk100没有 => [obj1] + [{...}]
  182.             # 注：一定不要在循环体中对循环对象进行增删(影响对象长度)的操作
  183.             obj_list = []
  184.             data_list = []
  185.             for dic in request_data:
  186.                 # request_data可能是list，单内部不一定是dict
  187.                 try:
  188.                     pk = dic.pop('pk')
  189.                     try:
  190.                         obj = models.Book.objects.get(pk=pk, is_delete=False)
  191.                         obj_list.append(obj)
  192.                         data_list.append(dic)
  193.                     except:
  194.                         pass
  195.                 except:
  196.                     return APIResponse(1, 'data error', http_status=400)
  198.             book_ser = serializers.BookModelSerializer(instance=obj_list, data=data_list, many=True, partial=True)
  199.             book_ser.is_valid(raise_exception=True)
  200.             book_obj_list = book_ser.save()
  201.             return APIResponse(data=serializers.BookModelSerializer(book_obj_list, many=True).data)
  203. class AuthorAPIView(APIView):
  204.     def get(self,request,*args,**kwargs):
  205.         authors=models.Author.objects.all()
  206.         author_ser=serializers.AuthorModelSerializer(authors,many=True)
  207.         return APIResponse(data=author_ser.data)
  208.     def put(self,reuqest,*args,**kwargs):
  209.         pass
  210.     def post(self,request,*args,**kwargs):
  211.         author_ser=serializers.AuthorModelSerializer(data=request.data)
  212.         author_ser.is_valid(raise_exception=True)
  213.         author_ser.save()
  214.         return APIResponse()
  215.     def delete(self,request,*args,**kwargs):
  216.         pass

ser.py

  1. from rest_framework import serializers
  2. from app01 import models
  3. class BookListSerializer(serializers.ListSerializer):
  4.     # 1、create方法父级ListSerializer已经提供了
  5.     # def create(self, validated_data):
  6.     #     # 通过self.child来访问绑定的ModelSerializer
  7.     #     print(self.child)
  8.     #     raise Exception('我不提供')
  10.     # 2、父级ListSerializer没有通过update方法的实现体，需要自己重写
  11.     def update(self, instance, validated_data):
  12.         # print(instance)
  13.         # print(validated_data)
  14.         return [
  15.             self.child.update(instance[i], attrs) for i, attrs in enumerate(validated_data)
  16.         ]
  20. class BookModelSerializer(serializers.ModelSerializer):
  21.     # 通过BookModelSerializer.Meta.list_serializer_class来访问绑定的ListSerializer
  22.     class Meta:
  23.         # 关联ListSerializer完成群增群改
  24.         list_serializer_class = BookListSerializer
  26.         model = models.Book
  27.         # fields = ('name', 'price', 'publish', 'authors')
  28.         # fields = ('name', 'price', 'publish_name', 'author_list')
  30.         # 了解
  31.         # fields = '__all__'
  32.         # exclude = ('id', )
  33.         # depth = 1
  35.         # 序列化与反序列化整合
  36.         fields = ('name', 'price', 'publish_name', 'author_list', 'publish', 'authors')
  37.         extra_kwargs = {
  38.             'publish': {
  39.                 'write_only': True
  40.             },
  41.             'authors': {
  42.                 'write_only': True
  43.             }
  44.         }
  49. # 前提：如果只有查需求的接口，自定义深度还可以用子序列化方式完成
  50. class PublishModelSerializer(serializers.ModelSerializer):
  51.     # 子序列化都是提供给外键(正向方向)完成深度查询的，外键数据是唯一：many=False；不唯一：many=True
  52.     # 注：只能参与序列化，且反序列化不能写(反序列化外键字段会抛异常)
  53.     books = BookModelSerializer(many=True)
  54.     class Meta:
  55.         model = models.Publish
  56.         fields = ('name', 'address', 'books')
  58. class AuthorModelSerializer(serializers.ModelSerializer):
  59.     class Meta:
  60.         model=models.Author
  61.         fields=('name','sex','mobile','mobile_in')
  62.         extra_kwargs={
  63.             'mobile':{
  64.                 'read_only': True
  65.             },
  66.         }
  68.     mobile_in=serializers.CharField(write_only=True)
  69.     # def validate_mobile_in(self, data):
  70.     #     print(data)
  71.     #     return data
  74.     def create(self, validated_data):
  75.         print(validated_data)
  76.         mobile=validated_data.pop('mobile_in')
  77.         author=models.Author.objects.create(**validated_data)
  78.         authordetail=models.AuthorDetail.objects.create(mobile=mobile,author=author)
  79.         return author

models.py

  1. from django.db import models
  5. # 一、基表
  6. # Model类的内部配置Meta类要设置abstract=True，这样的Model类就是用来作为基表
  8. # 多表：Book，Publish，Author，AuthorDetail
  9. class BaseModel(models.Model):
  10.     is_delete = models.BooleanField(default=False)
  11.     create_time = models.DateTimeField(auto_now_add=True)
  12.     class Meta:
  13.         # 基表必须设置abstract，基表就是给普通Model类继承使用的，设置了abstract就不会完成数据库迁移完成建表
  14.         abstract = True
  16. class Book(BaseModel):
  17.     name = models.CharField(max_length=16)
  18.     price = models.DecimalField(max_digits=5, decimal_places=2)
  19.     publish = models.ForeignKey(to='Publish', related_name='books', db_constraint=False, on_delete=models.DO_NOTHING)
  20.     # 重点：多对多外键实际在关系表中，ORM默认关系表中两个外键都是级联
  21.     # ManyToManyField字段不提供设置on_delete，如果想设置关系表级联，只能手动定义关系表
  22.     authors = models.ManyToManyField(to='Author', related_name='books', db_constraint=False)
  24.     # 自定义连表深度，不需要反序列化，因为自定义插拔属性不参与反序列化
  25.     @property
  26.     def publish_name(self):
  27.         return self.publish.name
  28.     @property
  29.     def author_list(self):
  30.         temp_author_list = []
  31.         for author in self.authors.all():
  32.             temp_author_list.append({
  33.                 'name': author.name,
  34.                 'sex': author.get_sex_display(),
  35.                 'mobile': author.detail.mobile
  36.             })
  37.         return temp_author_list
  40. class Publish(BaseModel):
  41.     name = models.CharField(max_length=16)
  42.     address = models.CharField(max_length=64)
  44. class Author(BaseModel):
  45.     name = models.CharField(max_length=16)
  46.     sex = models.IntegerField(choices=[(0, '男'),(1, '女')], default=0)
  48. class AuthorDetail(BaseModel):
  49.     mobile = models.CharField(max_length=11)
  50.     # 有作者可以没有详情，删除作者，详情一定会被级联删除
  51.     # 外键字段为正向查询字段，related_name是反向查询字段
  52.     author = models.OneToOneField(to='Author', related_name='detail', db_constraint=False, on_delete=models.CASCADE)
  54. # 二、表断关联
  55. # 1、表之间没有外键关联，但是有外键逻辑关联(有充当外键的字段)
  56. # 2、断关联后不会影响数据库查询效率，但是会极大提高数据库增删改效率（不影响增删改查操作）
  57. # 3、断关联一定要通过逻辑保证表之间数据的安全
  58. # 4、断关联
  59. # 5、级联关系
  60. #       作者没了，详情也没：on_delete=models.CASCADE
  61. #       出版社没了，书还是那个出版社出版：on_delete=models.DO_NOTHING
  62. #       部门没了，员工没有部门(空不能)：null=True, on_delete=models.SET_NULL
  63. #       部门没了，员工进入默认部门(默认值)：default=0, on_delete=models.SET_DEFAULT
  66. # 三、ORM外键设计
  67. # 1、一对多：外键放在多的一方
  68. # 2、多对多：外键放在常用的一方
  69. # 3、一对一：外键放在不常用的一方
  70. # 4、外键字段为正向查询字段，related_name是反向查询字段
  73. # from django.contrib.auth.models import AbstractUser, User
  74. # class MyUser(AbstractUser):
  75. #     pass

setting.py

  1. LANGUAGE_CODE = 'zh-hans'
  3. TIME_ZONE = 'Asia/shanghai'
  5. USE_I18N = True
  7. USE_L10N = True
  9. USE_TZ = False

urls.py

  1. path(r'publishes/', views.PublishAPIView.as_view()),
  2. re_path(r'^publishes/(?P<pk>\d+)/$', views.PublishAPIView.as_view()),
  4. path(r'books/', views.BookAPIView.as_view()),
  5. re_path(r'^books/(?P<pk>\d+)/$', views.BookAPIView.as_view()),