改项目名,模块与包及导入规则,断言(assert),drf之请求响应,两个视图基类(APIView,GenericAPIView),五个视图扩展类,9 个视图子类,视图集

Ⅰ 改项目名

【一】改名方式一

• 若是不成功 直接在文件夹上改

• 复制路径，在磁盘中找文件所在路径

• 删除idea文件夹

• 删除之后再打开pycharm会发现没有项目，这是因为删除idea之后pycharm不会记录最后的，所以要在路径中重新打开项目，他会再次生成一个idea文件夹

【二】第二种改名方式

• 第一种改名方式下面那种

【三】改名完后续操作

• 打开再次运行之后会运行不了，这就需要进行setting设置

• 在搜索框输入django进行搜索

• 进行配置

• 然后就可以运行

• 在进行内部文件修改

• 修改完再次运行，会报错

• 将文件中用到的module的four全部改为fourfour

• 全局替换

• 再次运行还是会报错，错误是在启动项目中

• 里面还是four的启动项目

• 所以把原来的配置删除，重新建一个

• 再次运行就可以了

• 若是还报错说是缺少four,就在项目根目录里面看看还有没有没有被替换的

【四】总结

# 【1】 文件夹名
# 【2】项目名没改
	 删 .idea
     直接改名
    
# 【3】改项目中得文件夹名--->导入包路径都有问题
	 全局查找替换
  
# 【4】删除djangoserver，重新创建一个

# 【5】settings-->django-->指定项目根路径和配置文件路径

Ⅱ 模块与包及导入规则

# 1 模块--->就是一个py文件-->在别的py文件中把它导入，这个py文件就叫模块
# 2 脚本--->一个py文件，右键运行，这个py文件就叫脚本
# 3 包-->文件夹下有 __init__.py
	-包中可以有很多py文件-->py文件中又有很多方法，类。。。

# 重点：导入模块或包的规则
	 绝对导入
        # 在python内部查找的顺序都是绝对路径
            import sys
            print(sys.path)
    	 根指的是？ 环境变量，如果一个路径在环境变量中，直接以此路径为根导入即可
        打印环境变量：sys.path
     相对导入
    	相对的是谁？   相对的就是当前这个py文件
        # ./ 表示当前同级目录下
        # ../ 表示当前目录的上一级目录
        # 默认就是当前目录下
 

import sys
print(sys.path)
# 环境变量

['E:\\yjjj\\fourfour\\fourfour',  # 项目目录
 'E:\\yjjj\\fourfour', 
 'E:\\pycharm\\PyCharm 2023.3.5\\plugins\\python\\helpers\\pycharm_display', 'E:\\python\\python310\\python310.zip',  #  os ，time
 'E:\\python\\python310\\DLLs', 
 'E:\\python\\python310\\lib', 
 'E:\\python\\python310', 
 'E:\\python\\python310\\lib\\site-packages', # 装的第三方模块，直接导入即可
 'E:\\pycharm\\PyCharm 2023.3.5\\plugins\\python\\helpers\\pycharm_matplotlib_backend']

 
 
 # 以后如果我们写包，写第三方包
 	可以直接  from 包名  import 即可  	
 		# 因为如果给别人用，别人下载完会在 site-packages  在环境变量
 		# 如果自己用，我们会放在项目根路径， 项目根路径  在环境变量中
 

Ⅲ 断言(assert)

【一】断言的使用

# 判断 name 的值必须是 zyb，才能继续执行，否则抛异常

name = 'zyb'
# if not name == 'zyb':
#     raise Exception('名字不为zyb，不能继续执行')
# print('代码继续执行')



# 断言代码使用
assert name=='zyb',"名字不为zyb，不能继续执行"
print('代码继续执行')

【二】使用断言的位置

• 断定 某些值一定存储
• 断定 某个值必须为 字符串类型 等等等

Ⅳ drf之请求响应

【一】请求-支持的编码格式

【1】drf请求，可以支持 三种编码格式

# 三种编码格式分别是
application/json,multipart/form-data,application/x-www-form-urlencoded


#  drf请求，可以支持 三种编码格式
	request.data  -->取出请求体的内容
    
    
#  后期，有个上传文件接口-->只能接受 form-data类型，其他类型不允许，如何做？
	控制某个接口，只能处理 某一种 编码格式，其他的都不行

【2】使用方式1 （局部使用）

• 在视图类上，配置-->只运行json格式，如果不配，支持三种

from .models import Book
from .serializer import BookSerialzier
from  rest_framework.parsers import JSONParser, MultiPartParser, FormParser

class BookView(APIView):
   

	parser_classes = [JSONParser]
    # 在视图类上,配置--->只运行json格式，如果不加限制，则三种格式都支持
    def post(self, request):
        serializer = BookSerialzier(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})

【3】配置文件中--所有视图类都会使用这个解析（全局使用）

# 所有drf的配置，都写在这里面
REST_FRAMEWORK = {
    # 解析类
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        # 'rest_framework.parsers.FormParser',
        # 'rest_framework.parsers.MultiPartParser',
    ],
}

【4】 全局使用了，局部再定制

# 所有drf的配置，都写在这里面
REST_FRAMEWORK = {
    # 解析类
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        # 'rest_framework.parsers.FormParser',
        # 'rest_framework.parsers.MultiPartParser',
    ],
}


from .models import Book
from .serializer import BookSerialzier
from  rest_framework.parsers import JSONParser, MultiPartParser, FormParser


    parser_classes = [MultiPartParser]  # 局部重新定制了
    # 在视图类上,配置--->只运行json格式，如果不加限制，则三种格式都支持
    def post(self, request):
        serializer = BookSerialzier(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})

【5】总结

# 重点：解析类使用顺序
	优先视图类中配置的parser_classes
    其次使用项目配置文件中得：REST_FRAMEWORK--->DEFAULT_PARSER_CLASSES  # 固定搭配跟英文  不能更改
    最后会使用drf内置的-->三个都有

【二】响应-支持的编码格式

#  postman 返回json--->浏览器返回已经封装后的好看界面

# 控制，只返回json格式，浏览器也是返回json格式


# 5 局部禁用
class BookView(APIView):
    renderer_classes = [JSONRenderer]

【1】可以支持两种格式

from rest_framework.renderers import BrowsableAPIRenderer,JSONRenderer

# BrowsableAPIRenderer 浏览器格式   JSONRenderer json格式

【2】局部使用

from rest_framework.renderers import BrowsableAPIRenderer,JSONRenderer
class BookView(APIView):
    renderer_classes = [JSONRenderer]

【3】全局使用

#  全局使用
REST_FRAMEWORK = {
      'DEFAULT_RENDERER_CLASSES': [
        # 'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ],
}

【4】 全局使用了，局部再定制

#  全局使用
REST_FRAMEWORK = {
      'DEFAULT_RENDERER_CLASSES': [
        # 'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ],
}

from rest_framework.renderers import BrowsableAPIRenderer,JSONRenderer
class BookView(APIView):
    renderer_classes = [JSONRenderer]

【三】代码实现

• settings.py

# 所有drf的配置，都写在这里面
REST_FRAMEWORK = {
    # 解析类
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        # 'rest_framework.parsers.FormParser',
        # 'rest_framework.parsers.MultiPartParser',
    ],
    'DEFAULT_RENDERER_CLASSES': [
            # 'rest_framework.renderers.JSONRenderer',
            'rest_framework.renderers.BrowsableAPIRenderer',
        ],
}

• serializer.py

class BookSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Book

        fields = '__all__' # 表示把book所有字段，在这写一遍
        # 只显示name跟price
        extra_kwargs = {'publish': {'write_only': True},
                        'authors': {'write_only': True,'required': False,'allow_null':True}}

• views.py

from .models import Book
from .serializer import BookSerialzier
from  rest_framework.parsers import JSONParser, MultiPartParser, FormParser
from rest_framework.renderers import BrowsableAPIRenderer, JSONRenderer

class BookView(APIView):
    renderer_classes = [JSONRenderer]
    def get(self, request):
        books = Book.objects.all()
        serializer = BookSerialzier(books, many=True)
        return Response({'code': 100, 'msg': '查询成功', 'results': serializer.data})

    parser_classes = [JSONParser]
    # 在视图类上,配置--->只运行json格式，如果不加限制，则三种格式都支持
    def post(self, request):
        serializer = BookSerialzier(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})

Ⅴ 两个视图基类(APIView,GenericAPIView)

【一】基于APIView+序列化类+Response写5个接口

• models.py

from django.db import models

# Create your models here.
from django.db import models


class Student(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    @property  # 包装成数据属性
    def new_name(self):   # 括号内是不能传参数的   以后 对象.name 就变成了name_NB
        return self.name + '_NB'





class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    city = models.CharField(max_length=32)


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()
    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    # 多对多关系，需要有中间件表
    # 但是django的orm帮咱们优化了-->不用手动创建中间件，使用ManyToMany可以自动创建出来
    # authors 不是表里的字段，它是一个中间表
    authors=models.ManyToManyField(to='Author')


    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.addr, 'city': self.publish.city}

    def author_detail(self):
        # 拿出所有作者
        authors = self.authors.all()
        author_list = []
        for author in authors:
            author_list.append({'name': author.name, 'age': author.age})  # 跨表查询  直接需要连的表.属性就行

        return author_list


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    addr = models.CharField(max_length=32)

• urls.py

from django.urls import path
from .views import StudentView,BookView,BookDetailView
urlpatterns = [
    
    path('books/', BookView.as_view()),
    path('books/<int:pk>/', BookDetailView.as_view()),
]

• views.py

#  基于api五个接口
class BookView(APIView):
    def get(self, request):
        books = Book.objects.all()
        serializer = BookSerialzier(books, many=True)
        return Response({'code': 100, 'msg': '查询成功', 'results': serializer.data})


    def post(self, request):
        serializer = BookSerialzier(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})


class BookDetailView(APIView):
    def put(self, request,pk):
        books = Book.objects.filter(pk=pk).first()
        serializer = BookSerialzier(instance=books, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '修改成功', 'results': serializer.data})

    def get(self, request,pk):
        book = Book.objects.filter(pk=pk).first()
        serializer = BookSerialzier(instance=book)
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})

    def delete(self,request,pk):
        book = Book.objects.filter(pk=pk)
        book.delete()
        return Response({'code': 100, 'msg': '删除成功'})

• serializer.py

from .models import Book
class BookSerialzier(serializers.ModelSerializer):
    class Meta:
        model = Book

        fields =['name','price','publish','authors','publish_detail','author_detail']
        # 只显示name跟price
        extra_kwargs = {'publish': {'write_only': True},
                        'authors': {'write_only': True},
                        'publish_detail': {'read_only': True},
                        'author_detail': {'read_only': True},
                        }

【二】基于GenericAPIView+序列化类+Response写5个接口

#  继承GenericAPIView后会有两个类属性和 3个方法
	类属性：
         queryset = Book.objects.all()     # 所有数据
         serializer_class = BookSerializer # 序列化类
    方法：对象调用 --->于是可以  self.方法
    	self.get_serializer(data=request.data) # 跟之前用序列化类一样
         self.get_queryset()                    # 所有数据
         self.get_object()                      # 根据传入的pk值，拿到单条
        
#  假设以后再写  【其他类的】的5个接口-->代码只要改两个类属性即可

• serializer.py和urls.py和上面一样
• views.py

from rest_framework.generics import GenericAPIView
class BookView(GenericAPIView):

    # 要序列化的数据
    queryset = Book.objects.all()
    # 序列化类
    serializer_class = BookSerialzier



    def get(self, request):
        # self.get_queryset()  拿到我们在类属性上配置的queryset 的值
        books = self.get_queryset()
        serializer = self.get_serializer(books, many=True)
        return Response({'code': 100, 'msg': '查询成功', 'results': serializer.data})


    def post(self, request):
        # self.get_serializer 拿到我们在类属性上配置的serializer_class 的值
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})


class BookDetailView(GenericAPIView):
    # 要序列化的数据
    queryset = Book.objects.all()
    # 序列化类
    serializer_class = BookSerialzier
    def put(self, request,pk):
        #  根据传入pk值，拿到一条记录
        # self.get_object()--->根据queryset 配置的所有数据和 pk ，获取一条记录
        book = self.get_object()
        serializer = self.get_serializer(instance=book, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({'code': 100, 'msg': '修改成功', 'results': serializer.data})

    def get(self, request,pk):
        book = self.get_object()
        serializer = self.get_serializer(instance=book)
        return Response({'code': 100, 'msg': '新增成功', 'results': serializer.data})

    def delete(self,request,pk):
        book = self.get_object()
        book.delete()
        return Response({'code': 100, 'msg': '删除成功'})

【三】补充： 对象使用类属性

#  对象使用类属性
	对象.属性名即可
    类.属性名即可
   
    
#  如果对象中有跟类属性同名的，会怎么样？ 优先用自己的
class Person:
    school='清华大学'
person2=Person()
person2.school='北京大学'  # 只会改对象自己的，不会改类的
print(person2.school)  #  一旦对象自己有了，优先用对象自己的    '北京大学'

person=Person()
print(person.school) #对象没有，就用类的  清华大学

Ⅵ 五个视图扩展类

#  5个视图扩展类--->必须配合GenericAPIView
from rest_framework.mixins import RetrieveModelMixin, UpdateModelMixin, CreateModelMixin, DestroyModelMixin, ListModelMixin


#  继承 GenericAPIView+5个视图扩展类之一或更多
	编写一下 get 、post、delete、get、put-->就能实现某个或某几个接口
    # 例如以下代码 继承编写get实现查看全部
    class Publish(GenericAPIView,ListModelMixin):
        queryset = Publish.objects.all()
        serializer_class = PublishSerializer
        def get(self,request):
            return super().list(request)

• 路由和序列化类是一样的
• views.py

### 5个视图扩展类+GenericAPIView+序列化类+Response写接口
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import RetrieveModelMixin, UpdateModelMixin, CreateModelMixin, DestroyModelMixin, ListModelMixin


# class ListModelMixin:
#     def list(self, request):
#         # 4 self.get_queryset()  拿到我们在类属性上配置的queryset 的值
#         books = self.get_queryset()
#         serializer = self.get_serializer(instance=books, many=True)
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
#
#
# class CreateModelMixin:
#     def create(self, request):
#         # 3 self.get_serializer 拿到我们在类属性上配置的serializer_class 的值
#         serializer = self.get_serializer(data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '成功', 'result': serializer.data})


class BookView(GenericAPIView, ListModelMixin, CreateModelMixin):
    # 两个类属性，几个方法
    # 1 要序列化的数据
    queryset = Book.objects.all()
    # 2 序列化类
    serializer_class = BookSerialzier

    def get(self, request):
        return super().list(request)

    def post(self, request):
        return super().create(request)


class BookDetailView(GenericAPIView,DestroyModelMixin,RetrieveModelMixin,UpdateModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier

    def put(self, request, pk):
        return super(BookDetailView, self).update(request, pk)

    def get(self, request, pk):
        return super(BookDetailView, self).retrieve(request, pk)

    def delete(self, request, pk):
        return super(BookDetailView, self).destroy(request, pk)

Ⅶ 9 个视图子类

# 将不同功能组合到一起 

from rest_framework.generics import ListAPIView, CreateAPIView, UpdateAPIView, RetrieveAPIView, DestroyAPIView
from rest_framework.generics import ListCreateAPIView
from rest_framework.generics import RetrieveUpdateDestroyAPIView, RetrieveUpdateAPIView, RetrieveDestroyAPIView

from rest_framework.generics import ListAPIView, CreateAPIView, UpdateAPIView, RetrieveAPIView, DestroyAPIView
from rest_framework.generics import ListCreateAPIView
from rest_framework.generics import RetrieveUpdateDestroyAPIView, RetrieveUpdateAPIView, RetrieveDestroyAPIView

# 重点：重写某个方法-->做定制
#  ListCreateAPIView：查询所有和新增  使用不同的序列化类？
#  定制新增后返回格式 {code:100,msg:成功,result:{}}
class BookView(ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier
    # 重写了get_serializer_class-->self.get_get_serializer 返回的，就是它get_serializer_class返回的
    # def get_serializer_class(self):
    #     if self.request.method=='GET':
    #         return BookSerializer
    #     else:
    #         return BookDetailSerializer


    # 定制新增后返回格式 {code:100,msg:成功,result:{}}
    # def post(self, request):
    #     res=super().post(request)
    #     return Response({'code':100,'msg':'新增成功','result':res.data})

    # 定制新增后返回格式 {code:100,msg:成功,result:{}}
    def create(self, request, *args, **kwargs):
        res=super().create(request)
        return Response({'code':100,'msg':'新增成功','result':res.data})

class BookDetailView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier

• 路由和序列化类是一样的
• views.py

 # get  post
 # list create
# get  put delete
# retrieve   update  destroy
    # 现在里面的增删改查由原来的get,post.....
    # 其余还跟GenericAPIView里面的方法一样
    
class BookView(ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # get  post
    # list create
    # get_serializer
    # get_object
    # get_queryset
class BookDetailView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # get  put delete
    # retrieve   update  destroy
    # get_serializer
    # get_object
    # get_queryset
    

Ⅷ 视图集

• views.py

# 一个类实现五个接口
class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # get post ...? 没有
    # list，create，delete.....
    # get_serializer
    # get_object
    # get_queryset

• urls.py

# 直接做了映射

urlpatterns = [
    path('books/', BookView.as_view({'get':'list','post':'create'})),  #get
    path('books/<int:pk>/', BookView.as_view({'get':'retrieve','put':'update','delete':'destroy'})), # get
]

Ⅸ 所有代码

• urls.py

from django.contrib import admin
from django.urls import path
# from .views import BookView,BookDetailView
from .views import BookView

# 继承ModelViewSet 后，路由写法变了
urlpatterns = [
    path('books/', BookView.as_view({'get':'list','post':'create'})),  #get
    path('books/<int:pk>/', BookView.as_view({'get':'retrieve','put':'update','delete':'destroy'})), # get
]

• models.py

from django.db import models


class Student(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    @property
    def new_name(self):
        return self.name + '_NB'


# 之前学的book 5个表，我们用四个
class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    city = models.CharField(max_length=32)


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()
    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    # 多对多关系，需要有中间件表
    # 但是django的orm帮咱们优化了--》不用手动创建中间件，使用ManyToMany可以自动创建出来
    # authors 不是表里的字段，它是一个中间表
    authors=models.ManyToManyField(to='Author')

    def publish_detail(self):
        return {'name':self.publish.name,'addr':self.publish.addr,'city':self.publish.city}
    def author_list(self):
        # 拿出这本书的所有作者
        authors=self.authors.all()
        l=[]
        for author in authors:
            l.append({'name':author.name,'age':author.age})

        return l

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    addr = models.CharField(max_length=32)

• serializer.py

from rest_framework import serializers
from .models import Book


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['name', 'price', 'publish', 'authors', 'publish_detail', 'author_list']
        extra_kwargs = {
            'publish': {'write_only': True},
            'authors': {'write_only': True},
            'publish_detail': {'read_only': True},
            'author_list': {'read_only': True},
        }

• views.py

from django.shortcuts import render

from rest_framework.views import APIView
from .serializer import BookSerializer
from rest_framework.response import Response
#############1 请求和响应编码格式################
from rest_framework.parsers import JSONParser, FormParser, MultiPartParser
from .models import Book
from rest_framework.renderers import BrowsableAPIRenderer, JSONRenderer
#
# class BookView(APIView):
#     # 在视图类上，配置-->只运行json格式，如果不配，支持三种
#     parser_classes = [MultiPartParser]
#     renderer_classes = [JSONRenderer]
#     def post(self, request):
#         serializer = BookSerializer(data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '成功', 'result': serializer.data})
#
#     def get(self,request):
#         books=Book.objects.all()
#         serializer=BookSerializer(instance=books,many=True)
#
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})


###############2 基于APIView+序列化类+Response写5个接口
# class BookView(APIView):
#     def post(self, request):
#         serializer = BookSerializer(data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '成功', 'result': serializer.data})
#
#     def get(self, request):
#         books = Book.objects.all()
#         serializer = BookSerializer(instance=books, many=True)
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
#
#
# class BookDetailView(APIView):
#     def put(self, request, pk):
#         book = Book.objects.filter(pk=pk).first()
#         serializer = BookSerializer(instance=book, data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '修改成功', 'result': serializer.data})
#
#     def get(self, request, pk):
#         book = Book.objects.filter(pk=pk).first()
#         serializer = BookSerializer(instance=book)
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
#
#     def delete(self, request, pk):
#         Book.objects.filter(pk=pk).delete()
#
#         return Response({'code': 100, 'msg': '删除成功'})


###############2 基于GenericAPIView+序列化类+Response写5个接口
## 假设以后再写 Publish的5个接口--》代码只要改两个类属性即可
# from rest_framework.generics import GenericAPIView
#
# class BookView(GenericAPIView):
#     # 两个类属性，几个方法
#     # 1 要序列化的数据
#     queryset = Book.objects.all()
#     # 2 序列化类
#     serializer_class = BookSerializer
#
#     def post(self, request):
#         # 3 self.get_serializer 拿到我们在类属性上配置的serializer_class 的值
#         serializer = self.get_serializer(data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '成功', 'result': serializer.data})
#
#     def get(self, request):
#         # 4 self.get_queryset()  拿到我们在类属性上配置的queryset 的值
#         books = self.get_queryset()
#         serializer = self.get_serializer(instance=books, many=True)
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
#
#
# class BookDetailView(GenericAPIView):
#     queryset = Book.objects.all()
#     serializer_class = BookSerializer
#     def put(self, request, pk):
#         # 5 根据传入pk值，拿到一条记录
#         # self.get_object()---》根据queryset 配置的所有数据和 pk ，获取一条记录
#         book = self.get_object()
#         serializer = self.get_serializer(instance=book, data=request.data)
#         serializer.is_valid(raise_exception=True)
#         serializer.save()
#         return Response({'code': 100, 'msg': '修改成功', 'result': serializer.data})
#
#     def get(self, request, pk):
#         book = self.get_object()
#         serializer = self.get_serializer(instance=book)
#         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
#
#     def delete(self, request, pk):
#         self.get_object().delete()
#         return Response({'code': 100, 'msg': '删除成功'})


### 5个视图扩展类+GenericAPIView+序列化类+Response写接口
# from rest_framework.generics import GenericAPIView
# from rest_framework.mixins import RetrieveModelMixin, UpdateModelMixin, CreateModelMixin, DestroyModelMixin, \
#     ListModelMixin
#
#
# # class ListModelMixin:
# #     def list(self, request):
# #         # 4 self.get_queryset()  拿到我们在类属性上配置的queryset 的值
# #         books = self.get_queryset()
# #         serializer = self.get_serializer(instance=books, many=True)
# #         return Response({'code': 100, 'msg': '成功', 'results': serializer.data})
# #
# #
# # class CreateModelMixin:
# #     def create(self, request):
# #         # 3 self.get_serializer 拿到我们在类属性上配置的serializer_class 的值
# #         serializer = self.get_serializer(data=request.data)
# #         serializer.is_valid(raise_exception=True)
# #         serializer.save()
# #         return Response({'code': 100, 'msg': '成功', 'result': serializer.data})
#
#
# class BookView(GenericAPIView, ListModelMixin, CreateModelMixin):
#     # 两个类属性，几个方法
#     # 1 要序列化的数据
#     queryset = Book.objects.all()
#     # 2 序列化类
#     serializer_class = BookSerializer
#
#     def get(self, request):
#         return super().list(request)
#
#     def post(self, request):
#         return super().create(request)
#
#
# class BookDetailView(GenericAPIView,DestroyModelMixin,RetrieveModelMixin,UpdateModelMixin):
#     queryset = Book.objects.all()
#     serializer_class = BookSerializer
#
#     def put(self, request, pk):
#         return super(BookDetailView, self).update( request, pk)
#
#     def get(self, request, pk):
#         return super(BookDetailView, self).retrieve(request, pk)
#
#     def delete(self, request, pk):
#         return super(BookDetailView, self).destroy(request, pk)
#
#
#
#
# class Publish(GenericAPIView,ListModelMixin):
#     queryset = Publish.objects.all()
#     serializer_class = PublishSerializer
#     def get(self,request):
#         return super().list(request)


#### 9 个 视图子类---》是真的视图类
from rest_framework.generics import ListAPIView, CreateAPIView, UpdateAPIView, RetrieveAPIView, DestroyAPIView
from rest_framework.generics import ListCreateAPIView
from rest_framework.generics import RetrieveUpdateDestroyAPIView, RetrieveUpdateAPIView, RetrieveDestroyAPIView

# 重点：重写某个方法--》做定制
# 1 ListCreateAPIView：查询所有和新增  使用不同的序列化类？
# 2 定制新增后返回格式 {code:100,msg:成功,result:{}}
# class BookView(ListCreateAPIView):
#     queryset = Book.objects.all()
#     serializer_class = BookSerializer
#     # 重写了get_serializer_class--》self.get_get_serializer 返回的，就是它get_serializer_class返回的
#     # def get_serializer_class(self):
#     #     if self.request.method=='GET':
#     #         return BookSerializer
#     #     else:
#     #         return BookDetailSerializer
#
#     # def post(self, request):
#     #     res=super().post(request)
#     #     return Response({'code':100,'msg':'新增成功','result':res.data})
#
#     def create(self, request, *args, **kwargs):
#         res=super().create(request)
#         return Response({'code':100,'msg':'新增成功','result':res.data})
#
# class BookDetailView(RetrieveUpdateDestroyAPIView):
#     queryset = Book.objects.all()
#     serializer_class = BookSerializer



###### 视图集
from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
#
#     # 这个类里就没有  get  get       post     put     delete  方法了
#     # 这个类里有：    list retrieve  create  update   destroy 方法


# 两个查询接口，只读
# class BookView(ReadOnlyModelViewSet):
#     queryset = Book.objects.all()
#     serializer_class = BookSerializer