day87

1 权限源码分析

2 模型层choice字段使用

3 自定义频率类

4 内置频率类使用

5 内置，第三方过滤功能

6 排序功能

## 1 权限源码分析

```python
8 源码分析
    -APIView的dispatch---》APIView的initial---》APIView的check_permissions(request)
        for permission in self.get_permissions(): # 权限类对象放到列表中
        if not permission.has_permission(request, self):
            self.permission_denied(
                 request,
                 message=getattr(permission, 'message', None),
                 code=getattr(permission, 'code', None)
                )
9 错误信息的中文显示
    在权限类中加一个 message=字符串
```



## 2 模型层choice字段使用（重点）

```python
1 模型表：Student表，写接口应该选择继承哪个视图类
2 推荐使用自动生成路由的方式（继承ViewSetMixin及它的子类）
3 但是目前来说，你先实现功能即可（至于选择哪个，慢慢体会）

4 choice的使用
    -在模型类中使用
    sex = models.SmallIntegerField(choices=((1, '男'), (2, '女'), (3, '未知')), default=1)
    -在视图类中，在序列化类中
        -get_字段名_dispaly()的方法，该方法获得choice字段对应的数据
```



## 3 自定义频率类（分析,了解）

```python
1 限制某个人，某个ip的访问频次

2 自定义频率类及使用
from rest_framework.throttling import BaseThrottle
class MyThrottle(BaseThrottle):
    VISIT_RECORD = {}  # 存用户访问信息的大字典
    def __init__(self):
        self.history = None
    def allow_request(self,request,view):
        # 根据ip进行频率限制，每分钟只能访问3次
        # 限制的逻辑
        '''
        #（1）取出访问者ip
        #（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        #（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        #（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        '''
        # （1）取出访问者ip
        # print(request.META)
        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, ]
            return True
        self.history = self.VISIT_RECORD.get(ip)
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        while self.history and ctime - self.history[-1] > 60:
            self.history.pop()
        # （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])
    
3 使用
    -局部使用
    -全局使用
    
```



## 4 内置频率类使用

```python
1 使用
    -局部使用
        throttle_classes = [auth.MyThrottle,]
    -全局使用
        REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES':['app01.auth.MyThrottle',],
        }
2 内置频率类
    BaseThrottle：基类
    AnonRateThrottle：限制匿名用户的访问次数
    SimpleRateThrottle：咱么自定义扩写它
    ScopedRateThrottle：
    UserRateThrottle：限制登录用户访问次数
    
    
3 扩展内置频率类（重点记住）
    -写一个类，继承SimpleRateThrottle
    class MySimpleThrottle(SimpleRateThrottle):
        scope = 'xxx'
        def get_cache_key(self, request, view):
            #以ip限制
            return self.get_ident(request)
    -setting.py中配置
        REST_FRAMEWORK = {
            'DEFAULT_THROTTLE_RATES' : {
                'xxx':'10/m'# key跟scope对应，value是一个时间
            }
        }
    -局部使用和全局使用
        

        
4 源码分析
    -继承SimpleRateThrottle---》allow_request（跟咱么写的一样）
    
    
5 其它内置频率类
    -限制未登录用户的频率（AnonRateThrottle）（根据ip限制）
        -使用：
            -局部使用，全局使用
            -setting.py中配置
               'DEFAULT_THROTTLE_RATES' : {
                    'anon':'1/m'
                }
    -限制登录用户访问次数UserRateThrottle（根据用户id限制）
        -使用：
        -局部使用，全局使用
        -setting.py中配置
        'DEFAULT_THROTTLE_RATES' : {
            'user':'1/m'
        }
    -ScopedRateThrottle(有兴趣看一下，没有就不看了)
        

```



## 5 内置，第三方过滤功能（次重点）

```python
1 过滤：筛选查询结果
2 内置筛选的使用
    -在视图类中配置
        filter_backends =[SearchFilter,]
        search_fields=('name',) # 表模型中的字段
    -查询的时候
        http://127.0.0.1:8000/students/?search=e
                
3 第三方扩展的过滤功能
    -pip3 install django-filter  ：最新版本（2.4.0）要跟django2.2以上搭配
    
    -在视图类中配置
        filter_backends =[DjangoFilterBackend,]
        filter_fields=['name','age']
    -查询的时候
        http://127.0.0.1:8000/students/?name=lqz&age=18
```



## 6 排序功能(次重点)

```python
-在视图类中配置
    filter_backends =[OrderingFilter,]
    ordering_fields=['id','age']
-查询的时候
    http://127.0.0.1:8000/students/?ordering=-age
            
            
 ### 过滤后再排序
  -在视图类中配置
    filter_backends = [OrderingFilter,DjangoFilterBackend]
    ordering_fields = ('id', 'age')
    filter_fields=['name','age']
  -查询的时候
    http://127.0.0.1:8000/students/?name=lqz&age=19&ordering=-age,-id

```

# views.py
from django.shortcuts import render

# Create your views here.
from app01 import models
from app01.serializer import StudentSerializer
from rest_framework.views import APIView
from rest_framework.generics import GenericAPIView, ListAPIView
from rest_framework.mixins import ListModelMixin, CreateModelMixin
from rest_framework.viewsets import ViewSetMixin, ViewSet, GenericViewSet
from rest_framework.response import Response
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.filters import BaseFilterBackend, SearchFilter, OrderingFilter
from rest_framework.throttling import AnonRateThrottle
from app01 import auth


class StudentView(GenericViewSet, ListModelMixin, CreateModelMixin):
    queryset = models.Student.objects.all()
    serializer_class = StudentSerializer
    throttle_classes = [auth.MyThrottle, ]
    # throttle_classes = [auth.MySimpleThrottle,]
    # throttle_classes = [AnonRateThrottle,]

    # 筛选功能
    # filter_backends =[SearchFilter,]
    # search_fields=('name','age')

    # django-filter的筛选功能
    # filter_backends =[DjangoFilterBackend,]
    # filter_fields=['name','age']

    # 排序功能
    # filter_backends =[OrderingFilter,]
    # ordering_fields=['id','age']

    # 既有排序，又有过滤
    filter_backends = [OrderingFilter, DjangoFilterBackend]
    ordering_fields = ('id', 'age')
    filter_fields = ['name', 'age']

# serializer.py
from rest_framework import serializers
from app01 import models


class StudentSerializer(serializers.ModelSerializer):
    sex = serializers.CharField(source='get_sex_display')

    class Meta:
        model = models.Student
        fields = '__all__'

# auth.py
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle


class MyThrottle(BaseThrottle):
    VISIT_RECORD = {}  # 存用户访问信息的大字典

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        # 根据ip进行频率限制，每分钟只能访问3次
        # 限制的逻辑
        '''
        #（1）取出访问者ip
        #（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        #（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        #（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        '''
        # （1）取出访问者ip
        # print(request.META)
        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, ]
            return True
        self.history = self.VISIT_RECORD.get(ip)
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        while self.history and ctime - self.history[-1] > 60:
            # while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        # （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])


class MySimpleThrottle(SimpleRateThrottle):
    scope = 'xxx'

    def get_cache_key(self, request, view):
        # get_cache_key返回什么，就以什么为key来限制
        # self.get_ident(request)内置的，返回ip地址

        return self.get_ident(request)

        # ip = request.META.get('REMOTE_ADDR')      # 等同于self.get_ident(request)
        # return ip

# settings.py
REST_FRAMEWORK = {
    # 'DEFAULT_THROTTLE_CLASSES':['app01.auth.MyThrottle',],
    'DEFAULT_THROTTLE_RATES': {
        # 'xxx':'10/m'
        'anon': '1/m'
    }

}

# models.py
from django.db import models


# Create your models here.


class Student(models.Model):
    choice_sex = [(1, '男'), (2, '女'), (0, '未知')]

    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # sex = models.IntegerField(choices=[(1, '男'), (2, '女'), (0, '未知')], default=0)
    sex = models.IntegerField(choices=choice_sex, default=0)