drf框架,认证模块

models.py

from django.db import models
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):       # 继承AbstractUser类,使得
    # 用户表导入字段字段
    mobile = models.CharField(max_length=64, unique=True)
    
    # 表名设置
    class Meta:
        db_table = 'api_user'
        verbose_name = '用户表'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.username

将上面模型表迁移, 如果迁移不成功,需要将配置文件venv===>site-packages===>django===>contrib===>admin===>migration文件中除了__init__文件,都删除.

迁移到MySQL如下图: 用户是超级用户,使用迁移命令创建的用户

user表

分组表, 权限表, 用户表与分组表连表, 分组表与权限表连表          

 表操作

test.py测试文件

import os
import sys, django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day74.settings')
django.setup()

from django.contrib.auth.models import Group
group = Group.objects.all().first()
print(group.name)

# 从分组到用户查 user_set
print(group.user_set.first().username)
# 从分组到权限表, permissions
from api import models

user = models.User.objects.first()
print(user.username)
# 从用户表查分组表
print(user.groups.first().name)
print()

 认证组件

1）APIView的dispath(self, request, *args, **kwargs)
2）dispath方法内 self.initial(request, *args, **kwargs) 进入三大认证
    # 认证组件：校验用户 - 游客、合法用户、非法用户
    # 游客：代表校验通过，直接进入下一步校验（权限校验）
    # 合法用户：代表校验通过，将用户存储在request.user中，再进入下一步校验（权限校验）
    # 非法用户：代表校验失败，抛出异常，返回403权限异常结果
    self.perform_authentication(request)
    
    # 权限组件：校验用户权限 - 必须登录、所有用户、登录读写游客只读、自定义用户角色
    # 认证通过：可以进入下一步校验（频率认证）
    # 认证失败：抛出异常，返回403权限异常结果
    self.check_permissions(request)
    
    # 频率组件：限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数（3/s）
    # 没有达到限次：正常访问接口
    # 达到限次：限制时间内不能访问，限制时间达到后，可以重新访问
    self.check_throttles(request)
    
    
3) 认证组件
    Request类的 方法属性 user 的get方法 => self._authenticate() 完成认证
    
    认证的细则：
    # 做认证
    def _authenticate(self):
        # 遍历拿到一个个认证器，进行认证
        # self.authenticators配置的一堆认证类产生的认证类对象组成的 list
        for authenticator in self.authenticators:
            try:
                # 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象)
                # 返回值：登陆的用户与认证的信息组成的 tuple
                # 该方法被try包裹，代表该方法会抛异常，抛异常就代表认证失败
                user_auth_tuple = authenticator.authenticate(self)
            except exceptions.APIException:
                self._not_authenticated()
                raise

            # 返回值的处理
            if user_auth_tuple is not None:
                self._authenticator = authenticator
                # 如何有返回值，就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth
                self.user, self.auth = user_auth_tuple
                return
        # 如果返回值user_auth_tuple为空，代表认证通过，但是没有 登陆用户 与 登陆认证信息，代表游客
        self._not_authenticated()

4) 权限组件
    self.check_permissions(request)
    认证细则：
    def check_permissions(self, request):
        # 遍历权限对象列表得到一个个权限对象(权限器)，进行权限认证
        for permission in self.get_permissions():
            # 权限类一定有一个has_permission权限方法，用来做权限认证的
            # 参数：权限对象self、请求对象request、视图类对象
            # 返回值：有权限返回True，无权限返回False
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request, message=getattr(permission, 'message', None)
                )

 自定义认证组件

1) 创建继承BaseAuthentication的认证类
2) 实现authenticate方法
3) 实现体根据认证规则 确定游客、非法用户、合法用户
4) 进行全局或局部配置

认证规则
i.没有认证信息返回None(游客)
ii.有认证信息认证失败抛异常(非法用户)
iii.有认证信息认证成功返回用户与认证信息元组(合法用户)

自定义认证组件实例

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from . import models
class MyAuthentication(BaseAuthentication):
    """
    同前台请求头拿认证信息auth（获取认证的字段要与前台约定）
    没有auth是游客，返回None
    有auth进行校验
        失败是非法用户，抛出异常
        成功是合法用户，返回 (用户, 认证信息)
    """
    def authenticate(self, request):
        # 前台在请求头携带认证信息，
        #       且默认规范用 Authorization 字段携带认证信息，
        #       后台固定在请求对象的META字段中 HTTP_AUTHORIZATION 获取
        auth = request.META.get('HTTP_AUTHORIZATION', None)

        # 处理游客
        if auth is None:
            return None

        # 设置一下认证字段小规则(两段式)："auth 认证字符串"
        auth_list = auth.split()

        # 校验合法还是非法用户
        if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
            raise AuthenticationFailed('认证信息有误，非法用户')

        # 合法的用户还需要从auth_list[1]中解析出来
        # 注：假设一种情况，信息为abc.123.xyz，就可以解析出admin用户；实际开发，该逻辑一定是校验用户的正常逻辑
        if auth_list[1] != 'abc.123.xyz':  # 校验失败
            raise AuthenticationFailed('用户校验失败，非法用户')

        user = models.User.objects.filter(username='admin').first()

        if not user:
            raise AuthenticationFailed('用户数据有误，非法用户')
        return (user, None)

REST_FRAMEWORK = {
    # 全局配置异常模块
    'EXCEPTION_HANDLER': 'utils.exception.exception_handler',
    # 认证类配置
    'DEFAULT_AUTHENTICATION_CLASSES': [
        # 'rest_framework.authentication.SessionAuthentication',
        # 'rest_framework.authentication.BasicAuthentication',
        'utils.authentications.MyAuthentication',
    ],

    # 权限类配置
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
        'utils.permissions.MyPermission'
    ],
}

 在视图类中添加属性导入

permission_classes = [MyAuthentication]

 自定义权限组件

1) 创建继承BasePermission的权限类
2) 实现has_permission方法
3) 实现体根据权限规则 确定有无权限
4) 进行全局或局部配置

认证规则
i.满足设置的用户条件，代表有权限，返回True
ii.不满足设置的用户条件，代表有权限，返回False

自定义权限组件实例

from rest_framework.permissions import IsAuthenticated
from utils.permissions import MyPermission
class TestAuthenticeatedAPIView(APIView):
    permission_classes = [IsAuthenticated, MyPermission]

    def get(self, request, *args, **kwargs):
 
        return APIResponse(0, 'test 登陆才能访问!')

    def post(self, request, *args, **kwargs):
      
        return APIResponse(0, "自定义 ok!")

from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
    def has_permission(self, request, view):
        # 只读接口判断
        r1 = request.method in ('GET', 'HEAD', 'OPTIONS')
        # group为有权限的分组
        group = Group.objects.filter(name='管理员').first()
        # groups为当前用户所属的所有分组
        groups = request.user.groups.all()
        r2 = group and groups
        r3 = group in groups
        # 读接口大家都有权限，写接口必须为指定分组下的登陆用户
        return r1 or (r2 and r3)

 setting文件配置上面setting文件配置

自定义频率认证组件

setting.py文件

REST_FRAMEWORK = {
    # 频率限制条件配置
    'DEFAULT_THROTTLE_RATES': {
        'sms': '1/min'
    },
}

自定义频率组件

from rest_framework.throttling import SimpleRateThrottle

class MySimpleRateThrottle(SimpleRateThrottle):
    scope = 'sms'

    def get_cache_key(self, request, view):
        print(request)
        mobile = request.query_params.get('mobile')

        if not mobile:
            return None
        return "throttle_%(scope)s_%(ident)s" % {"scope":self.scope, 'ident': mobile}

 视图类

from utils.throttles import MySimpleRateThrottle

class TestSMSAPIView(APIView):
    throttle_classes = [MySimpleRateThrottle]

    def get(self, request, *args, **kwargs):
       return APIResponse(0, 'get 获取验证码 ok')

    def post(self, request, *args, **kwargs):
        return APIResponse(0, 'post 获取验证码 ok')