# 伪代码
# -新增
        ser=BookSerializer(data=request.data)
        ser.is_valid(raise_exception=True)# --->只要校验不通过，直接抛异常
        ser.save()  # 继承Serializer，需要在序列化类中重写create方法，完成新增
        # 序列化类中重写create方法
        def create(self, validated_data):
            # validated_data 前端传入，校验过后的数据
            # 新增一个对象
            return  新增的对象  # 后续再视图类中只要调用ser.data,这里必须返回
    
    #  -修改
    ser=BookSerializer(instance='要修改的对象',data=request.data)
    ser.is_valid(raise_exception=True)# --->只要校验不通过，直接抛异常
    ser.save()  # 继承Serializer，需要在序列化类中重写update方法，完成修改
    # 序列化类中重写update
    def update(self, instance, validated_data):
        # instance 要修改的对象，哪里来的？BookSerializer(instance=要修改的对象的id,data=request.data)
        # validated_data：校验过后数据
        res=Book.objects.filter(pk=instance).update(**validated_data)
        return res   # 返回的res最后干啥了？只要在  视图类中 调用ser.data,他会根据这个返回值做序列化

class Meta:
        model=表名
        fields=[需要序列化或反序列化的字段，表中没有也要写]
        extra_kwargs={} # 传入字段参数
    重写字段
    
    大部分情况下不需要写create和update了
    
    局部，全局钩子跟之前一模一样

# 1 两个视图基类
    APIVIew
        -类属性
            renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
            parser_classes = api_settings.DEFAULT_PARSER_CLASSES
            authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
            throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
            permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
    GenericAPIView：要使用序列化类，数据库打交道，就可以继承它
        -queryset = None
        -serializer_class = None
        -lookup_field = 'pk'
        -filter_backends = api_settings.DEFAULT_FILTER_BACKENDS
        -pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
        
        -get_queryset(self) #获取所有要序列化的数据，在里面拿到qs对象后要 .all()
        -get_object  # 获取单个对象
        -get_serializer()--->内部调用了get_serializer_class--》最终返回序列化类的对象，传入要传的参数---》instance ，data  many
        
        -filter_queryset---》给ListModelMixin用了--》把配置的filter_backends 依次执行完成过滤
# 5个视图扩展类 =不是视图类，需要搭配GenericAPIView
    ListModelMixin,
    CreateModelMixin,
    UpdateModelMixin,
    DestroyModelMixin,
    RetrieveModelMixin
    
    一个视图类中写四个接口--》必须借助于ViewSetMixin
class BookView(ViewSetMixin,GenericAPIView,ListModelMixin,CreateModelMixin,RetrieveModelMixin,DestroyModelMixin):
    queryset = None
    serializer_class = None
    
    
    
# 6 9个视图子类

# 7 视图集
    -ModelViewSet：重写方法实现你想要的功能
    -ReadOnlyModelViewSet
    -ViewSetMixin:路由写法变了
    -ViewSet：ViewSetMixin+APIView
    -GenericViewSet：ViewSetMixin+GenericAPIView
    

# 请求：
    -请求源码：request对象
        -request.data
        -request.query_params
        -跟之前一样
        -request._request
        -__getattr__
    -请求能解析编码格式：parser_classes
        -局部使用
        -全局使用
        
        
        
# 响应
    -响应Response  源码
        -data：响应体的内容，序列化后的数据给了他
        -headers:响应头    django原生响应头  响应对象['xx']=xxx
        -status:响应状态码
    -响应编码格式--》浏览器，postman，看到的样子
        -局部和全局配置
            
# 写了个视图类  获取所有接口
class BookView(ViewSetMixin,GenericAPIView,ListModelMixin):
    queryset = None
    serializer_class = None
    def list(self,request,*args,**kwargs):
        res=super().list(request,*args,**kwargs)
        res.data  # {code:100,msg:成功，data：[{},{}]}
        return Response({code:100,msg:成功,data:res.data})

# 1 只要继承ViewSetMixin及其子类，路由写法就变了
    -方式一：映射方式
        视图类.as_view({'get':'lqz'})
    -方式二：自动生成
        -SimpleRouter  DefaultRouter
        
        
# 2 action装饰器：methods  detail  

# 认证的使用
    1 写个类，继承BaseAuthentication
    2 重写autenticate
    3 取出用户传入的 token  ---》通过token能知道是谁
    4 认证通过取出用户，认证失败，抛出异常
    5 return 查到的对象，token---》后续再request.user中就是当时返回的第一个值
    6 视图类中配置
    7 全局配置
    
# 权限类
    1 写个类，继承BasePermission
    2 has_permission
    3 判断用户的权限  
        acl 权限，取出当前用户所有权限，判断当次请求是否在权限中
        rbac，根据当前用户取出所有角色，通过角色取出所有权限，去个重，判断是否在权限中
    4 有权限返回True，没有返回False
    5 视图类中配置
    6 全局配置
    
    
 # 频率类
    1 写个类，继承SimpleRatethrottle
    2 重写get_cache_key 返回值 唯一的  ip，userid
    3 类属性  scope='字符串'  
    4 配置文件配置 
    'DEFAULT_THROTTLE_RATES': {
        '字符串': '3/m',
    },
    5 视图类中配置
    6 全局配置
    
    
    
 # 权限---》认证---》频率


# 为什么我们写了 权限类，配置行，它就会执行权限控制？
    -APIView 的dispatch中执行了3大认证---》
     def dispatch(self, request, *args, **kwargs):
         self.initial(request, *args, **kwargs) # 三大认证
        
        
    - self.initial   需要从根上
      def initial(self, request, *args, **kwargs):
        self.perform_authentication(request)
        self.check_permissions(request) # 权限类的执行位置
        self.check_throttles(request)
        
    -self.check_permissions(request)
      def check_permissions(self, request):
        for permission in self.get_permissions(): # 你配置在视图类上一个个权限类的对象列表 [权限对象1，权限对象2]
            if not permission.has_permission(request, self): # self，是视图类的对象，因为在APIView中
                self.permission_denied(
                    request,
                    message=getattr(permission, 'message', None),
                    code=getattr(permission, 'code', None)
                )
                
    - def get_permissions(self):
        return [permission() for permission in self.permission_classes]
    
    
    
    
# 认证类源码---》难
-APIView 的dispatch中执行了3大认证---》
     def dispatch(self, request, *args, **kwargs):
         self.initial(request, *args, **kwargs) # 三大认证
        
        
    - self.initial   需要从根上
      def initial(self, request, *args, **kwargs):
        self.perform_authentication(request)# 认证类的执行位置
        self.check_permissions(request) 
        self.check_throttles(request)
        
   - def perform_authentication(self, request):
        request.user
   -去Request类中找user---》方法包装成了数据属性
        @property
        def user(self):
            if not hasattr(self, '_user'):
                with wrap_attributeerrors():
                    self._authenticate()
            return self._user
        
    -去Request类中找self._authenticate()
        def _authenticate(self):
            for authenticator in self.authenticators: # 配置在视图类上一个个认证类的对象列表
                try:
                    # 调用认证类对象的authenticate方法，传入 self，是request对象
                    user_auth_tuple = authenticator.authenticate(self) # 当前登录用户，token
                except exceptions.APIException:
                    self._not_authenticated()
                    raise

                if user_auth_tuple is not None:
                    self._authenticator = authenticator
                    #self就是request对象，后续 request.user就是认证类返回的第一个参数
                    self.user, self.auth = user_auth_tuple  # 解压赋值
                    return

            self._not_authenticated()
            
     -认证类可以配置多个，但是如果有一个返回了，后续的就不走了
    
    -self.authenticators 是request对象的属性，是在Request实例化的时候传入的，它什么时候实例化的，包装新的Reqeust时传入的---》APIView的dispatch--》

# 1 频率源码
    -APIView----disaptch---》self.initial(request, *args, **kwargs)---》416行：self.check_throttles(request)----》352行 check_throttles
    
    def check_throttles(self, request):
        # self.get_throttles()就是咱们配置在视图类上频率类的对象列表[频率类对象,]
        for throttle in self.get_throttles():
            # 执行频率类对象的allow_request，传了2个，返回True或False
            if not throttle.allow_request(request, self):
                # 反会给前端失败，显示还剩多长时间能再访问
                throttle_durations.append(throttle.wait())

                
# 2 频率类要写
    1 写一个类，继承，BaseThrottle
    2 在类中重写：allow_request方法，传入 3个参数
    3 在allow_request写限制逻辑，如果还能访问--》返回True
    4 如果超了次数，就不能访问，返回False
    5 局部配置在视图类上
    6 全局配置在配置文件中
    
# 3 我们在drf中写的时候，不需要继承 BaseThrottle，继承了SimpleRateThrottle，重写get_cache_key
   -我们猜测：一定是 SimpleRateThrottle帮咱们写了咱们需要写的
    
    
    
# 4 自定义频率类，实现一分钟只能访问三次的控制：
        # （1）取出访问者ip
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        
        
        
#5  SimpleRateThrottle 源码分析
    - SimpleRateThrottle内部一定有：allow_request---》
    def allow_request(self, request, view):
        # 咱们没写，以后咱们可以在频率类中直接写
        # rate='3/m'   以后不用写scope了，就会按一分钟访问3次现在
        if self.rate is None:
            return True
        # 取出：重写的get_cache_key返回的值，咱们返回了访问者ip
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
        # 根据当前访问者ip，取出 这个人的访问时间列表  [访问时间1，访问2，访问3，访问4]
        self.history = self.cache.get(self.key, [])
        # 取出当前时间
        self.now = self.timer()
        # 把访问时间列表中超过 限制时间外的时间剔除
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        # 判断访问时间列表是否大于 3 
        if len(self.history) >= self.num_requests:
            return self.throttle_failure()
        return self.throttle_success()
     

from rest_framework.throttling import BaseThrottle


class MyThrottle(BaseThrottle):
    # VISIT_RECORD = {'192.168.1.1':[当前时间，当前时间，访问时间列表]}
    VISIT_RECORD = {}

    def __init__(self):
        self.history = []

    def allow_request(self, request, view):
        ip = request.META.get('REMOTE_ADDR')
        import time
        ctime = time.time()
        # （2）判断当前ip不在访问字典里，说明是第一次访问，添加进去，并且直接返回True,表示第一次访问
        if ip not in self.VISIT_RECORD:
            self.VISIT_RECORD[ip] = [ctime, ]  # VISIT_RECORD = {'192.168.1.1':[当前时间2，当前时间1，]}
            return True
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        self.history = self.VISIT_RECORD[ip]  # 访问时间列表
        while self.history and ctime - self.history[-1] > 60:  # 循环删除1分钟之前访问的实际
            self.history.pop()

        # 最后self.history都剩下是一分钟之内的时间了
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        if len(self.history) < 3:
            self.history.insert(0, ctime)
            return True
        else:
            return False

    def wait(self):
        import time
        ctime = time.time()
        return 60 - (ctime - self.history[-1])

#1 针对于查询所有接口---》继承：GenericAPIView+ListModelMixin---》只需要在视图类中写一个类属性---》filter_backends = [过滤类，过滤类2]


# 过滤类：
    1 内置的：SearchFilter  类属性：search_fields=[可以按字段过滤]
        127.0.0.1:8080/books/?search=红
    2 第三方
        -django-filter
        -精准匹配
         127.0.0.1:8080/books/?name=红楼梦
        -能更强大
    3 自定义的
        写一个类，继承：BaseFilterBackend
        重写 filter_queryset
        在filter_queryset中完成过滤，会把qs传入，返回过滤后的qs即可

# 2 源码分析
    ListModelMixin---》list方法---》queryset = self.filter_queryset(self.get_queryset()) 过滤后的数据----》执行了GenericAPIView的---》filter_queryset---》取出一个个配置在视图类上的过滤类，依次实例化得到对象后执行对象的filter_queryset方法完成过滤---》最终返回的数据，就是过滤后的数据
    
    
 # 3 继承APIView写过滤
    request 取出过滤条件
    book_list=Book.objects.all().filter(过滤)

#1 针对于查询所有接口-->才有分页

# 2 三种分页方式，必须继承分页类，重写几个类属性实现--->配置在视图类上--》继承：GenericAPIView+ListModelMixin
PageNumberPagination：用的最多，之前常见的分页方式，查询第几页，每页有多少条的分页方式 ：page=10&size=3
LimitOffsetPagination：从第几条开始，取几条  offset=10&limit=3  从第10条开始，取3条
CursorPagination：只能上一页和下一页，需要排好序再分页


# 3 继承APIView 写分页
class  Pager(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
        ret=models.Book.objects.all()
        # 创建分页对象
        page=PageNumberPagination()
        # 在数据库中获取分页的数据
        page_list=page.paginate_queryset(ret,request,view=self)
        # 对分页进行序列化
        ser=BookSerializer1(instance=page_list,many=True)
        # return Response(ser.data)
        # 这个也是返回Response对象，但是比基本的多了上一页，下一页，和总数据条数（了解即可）
        return page.get_paginated_response(ser.data)
        return Response(ser.data) # 只会有数据，不会有上一页和下一页，总条数

# 前后端分离了，后期，后端出了异常，我们不想让前端看到，我们需要捕获全局异常，统一返回格式

# drf 源码中已经处理
    APIView--->dispatch--->
     try:
        # 1 执行三大认证
        # 2 执行视图类的方法
    except Exception as exc:
        response = self.handle_exception(exc)
        
    -463行左右：
    # exception_handler就是配置文件中配置的一个函数-->默认的
    # 后期自己写了
    exception_handler = self.get_exception_handler()
    response = exception_handler(exc, context)
    
# 默认执行的是：rest_framework.views.exception_handler函数---》只处理了drf的异常    
# 咱们处理全局异常的步骤：
    1 写一个函数，在内部处理
    from rest_framework.views import exception_handler
    def common_exception_handler(exc,context):
        res=exception_handler(exc,context)
        if res: #这次异常是drf的，并且它处理了
            # 我们要统一返回格式
            return Response({'code':888,'msg':"系统异常（drf异常），请联系系统管理员：%s"%res.data.get('detail',None)})
        else:
            return Response({'code': 999, 'msg': "系统异常（非drf异常），请联系系统管理员：%s" % str(exc)})
    2 配置在配置文件上

# 自定义用户表
    签发
        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)
    认证：认证类
        token = request.META.get('HTTP_TOKEN')
        payload = jwt_decode_handler(token)
        user = User.objects.get(pk=payload.get('user_id'))
    
# 多方式登录（auth的user表）
    -把校验和签发token逻辑写在序列化类的 全局钩子中了
    -在全局钩子中，只要校验不通过，就抛异常