drf-认证、权限、频率

一、认证组件

1.认证组件的作用

　　一些接口，想要限制登录之后才能访问，没登录不能访问

　　做登录认证，限制如果没有登录，不允许访问该接口

2. 认证类的使用：

　　1.在auth.py中 写一个类，去继承BaseAuthentication

　　2. 在这个类中重写：authenticate方法

　　3. 在authenticate完成登录认证，如果登录了，返回两个值：

　　　　- 当前登录的用户：user_token.user

　　　　- 前端传入的token：token 

　　4.  如果没登录，抛异常：raise AuthenticationFailed('您没有登录')

　　5 认证类写好，在视图类中配置使用

　　　　1. 局部使用：配置在视图类上

　　　　2. 全局使用：在配置文件中配置，所有的接口都必须登录后才能使用

　　　　3. 在全局使用的情况下，局部禁用：在视图类中，authentication_classes=[ ]

前端传入的token，从哪里拿，怎么拿？

　　1. 在请求地址中拿：token = requset.qusery_params.get('token')

　　2. 在请求体中拿：token = request.data.get('token')

　　3. 在请求头中拿：token = request.META.get('HTTP_TOKEN')

2.1 以登录为例，做一个登录认证：

auth.py文件中：

from .models import UserToken
from rest_framework.viewsets import ViewSetMixin
from rest_framework.views import APIView
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
"""
1. 写一个类，继承BaseAuthentication
2. 在这个类中。重写authenticate方法
3. 在authenticate方法中完成登录认证，认证成功，返回两个参数，user_token.user,token
4. 认证失败，就抛出异常：AuthenticationFailed 会被drf捕获，处理，不会报错到前端
5. 在视图类中配置使用
"""
class LoginAuth(BaseAuthentication):
    # 重写authenticate方法
    def authenticate(self, request,*args,**kwargs):
        # 从前端拿到token值，与UserToken表中的token进行比较
        token = request.query_params.get('token')
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            return user_token.user,token
        else:
            raise AuthenticationFailed('您还没有登录')

from .models import User,UserToken
from rest_framework.decorators import action
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSetMixin,ViewSet
from rest_framework.response import Response
import uuid
# Viewset(ViewSetMixin,APIView),继承这个类是因为，我们只查一条数据，不用查所有的数据，也不需要写序列化类
# 不需要自己写路由，可以自动生成路由
class UserView(ViewSet):

    # 写一个登录方法
    @action(methods=['POST'],detail=False)
    def login(self,request,*args,**kwargs):
        # 从前端获取用户名和密码
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username,password=password).first()
        # 如果有这用户，就生成一个随机字符串存入UserToken表中
        if user:
            token = str(uuid.uuid4())
            # 两中情况：一个是用户之前没登录过，直接存入token，二：用户之前登录过，就把之前的token改成新生成de
            # 方式一：
            # user_token = UserToken.objects.filter(user=user).first()
            # if user_token:
            #     user_token.token=token
            #     user_token.save() # 保存数据
            # else:
            #     UserToken.objects.create(token=token,user=user)
            # 方式二：通过user去UserToken表中查，如果能查到用defaults的更新，如果查不到，就用user和defaults新增一条记录
            UserToken.objects.update_or_create(defaults={'token':token},user=user)
            return Response({'ccode':100,'msg':'登录成功','username':user.username,'token':token})
        else:
            return Response({'code':101,'msg':'用户名或者密码错误'})
# 通过这个接口去判断有没有登录认证
from .auth import LoginAuth
class UserAuthView(ViewSet):
    authentication_classes = [LoginAuth]
    def list(self,requset):
        print(requset.user.username)
        print(requset.auth)
        return Response('用户%s已登录'%requset.user.username)

路由配置：

postman：

从请求地址中获取token

从请求头中获取token

 总结：

1 认证类写好，使用
　　-配置在视图类上---》局部使用
　　-配置文件中配置--》全局使用---》所有接口都必须登录后才能用
　　REST_FRAMEWORK = {
　　　　'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth'],

　　　　}
　　-局部禁用：
　　class UserView(ViewSet):
　　　　authentication_classes = []
 2 写的认证类：要重写authenticate方法，必须返回两个参数：当前登录用户：user_token.user,用户的 token----》后续再视图类中：request.user 就是认证类返回的第一个参数，request.auth 就是认证类返回的第二个参数

3 如果认证失败，抛异常AuthenticationFailed，会被drf捕获，处理，不会报错到前端

4 前端传入的token，从哪取？
-后端定的，我们这个项目是从请求地址中取
-还可以从请求头或请求体中取

二、 权限组件

　　在系统中，有普通用户，超级用户，超级管理员，他们都登录了，有的人有权限，就能访问这个接口

1. 使用的步骤：

　　1.在throttling.py文件中写一个类，继承Basepermission

　　2. 在这个类中，重写has_permission方法，在方法进行校验用户是否有权限，有权限，就返回True，没有权限，就返回False

　　　　- 权限的执行是在认证的后面，所以此时用户是已经登录的状态，就可以从requset.user中拿出当前登录的用户，对用户的类型进行判断

　　3. 在视图类中的使用：

　　　　- 配置在视图类中使用：进行局部配置：permission_classes = [UserPermission]

　　　　局部配置的时候要注意登录认证是全局配置还是局部配置，如果是全局配置，直接在需要权限的视图类中加permission_classes = [UserPermission]，

　　　　如果是局部配置，需要在权限认证之前加上登录认证，不然就会出现一下的错误，request.user获取不到值

　　　　- 配置在配置文件中：全局使用：

　　　　　　REST_FRAMEWORK = {

　　　　　　'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth'],

　　　　　　'DEFAULT_PERMISSION_CLASSES': ['app01.permissions.UserPermission'],

　　　　　　}

　　- 全局配置了，但是某个接口不需要：局部禁用：permission_classes = [ ]

2. 代码执行：

# 进行权限认证
from rest_framework.permissions import BasePermission

class UserPermission(BasePermission):

    def has_permission(self, request, view):
        # request 当次请求的request，  新的，它是在认证类之后执行的，如果认证通过了request.user 就是当前登录用户
        # 拿到当前登录用户，查看它的类型，确定有没有权限
        if request.user.user_type == 3:
            return True
        else:
            self.message = '您的用户类型是：%s，您没有权限操作' % (request.user.get_user_type_display())
            return False

views中：

class UserPermissionView(ViewSet):
    authentication_classes = [LoginAuth]
    permission_classes = [UserPermission]
    # 局部使用，必须在登录认证的基础上
    def create(self, request,*args,**kwargs):
        return Response('您新增了一条记录')

结果：

三、频率组件

作用：对接口进行访问次数限制，控制一个接口，访问频次，比如一分钟只能访问1次

1. 使用步骤：

　1. 在throllting.py文件中，写一个类继承SimpleRateThrottle

　2. 在这个类中，重写get_cache_key方法，返回什么，就以什么做限制：

　　-1. IP地址，当用户没有登录的时候，以他的IP地址做限制，返回他的IP号

　　-2. 用户id限制，当用户登录了，就以他的id号进行限制，返回他的id号

　3. 写一个类属性   scope = 'drf_day8'

　4. 在配置文件中配置：

　 'DEFAULT_THROTTLE_RATES': {'drf_day08': '3/m', # 一分钟访问三次},

　5 局部使用，全局使用，局部禁用

四、排序

只有5个接口中的查询所有，才涉及到排序，所以继承GenericViewSet,

 使用步骤：

　　1. 必须写在继承：GenericAPIView 类的视图中才行

　　2. 配置类属性：

　　filter_backends = [OrderingFilter]

　　ordering_fields=['id','user_type'] # 可以排序的字段

　　3. 使用：

　　　　http://127.0.0.1:8000/user/?ordering=user_type #按用户类型升序排

　　　　http://127.0.0.1:8000/user/?ordering=-user_type #按用户类型降序排

　　　　http://127.0.0.1:8000/user/?ordering=user_type,-id#先按用户类型升序排，如果用户类型一样，再按id降序排