FRI.认证类

DRF 之路由

基本使用

自动生成路由
# 第一步：导入
from rest_framework.routers import DefaultRouter, SimpleRouter

# 第二步：实例化得到对象
router = SimpleRouter()  # 使用次数相对更多
# router = DefaultRouter()  # 它自动生成的路由多一条，多个根路径

# 第三步：注册路由
# 第一个参数是路径，第二个参数是视图类（必须继承 ViewSet 及子类），第三个参数是别名（反向解析使用）
router.register('books', views.BookView, basename='books')
router.register('publish', views.PublishView, basename='publish')

router.register('test', views.TestView, basename='testview')

print(router.urls)

urlpatterns = [
    path('admin/', admin.site.urls),
    path('index/', views.index),

    # 第四步：把自动生成的路由添加到总路由中（方式二：路由分发方式）
    path('', include(router.urls)),
]

# 第四步：把自动生成的路由添加到总路由中（方式一:列表相加）
urlpatterns += router.urls

actions

# 视图函数
class TestView(GenericViewSet):
    '''action参数
    methods:做一个映射，就是http的请求方式，就会映射当前方法
    detail：True 或 False
        - test/login/
        - ^test/pk/login
    url_path：访问的路径，可以不写，如果不写，以方法名作为路径 通过 get 请求访问这个路径 test/login 就能触发 login 的执行
    url_name：别名
    '''
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get_serializer_class(self):
        # 当前视图类的对象中就有action属性，我们可以通过这个属性判断当前请求会执行哪个视图类中的方法
        if self.action=='login':
            return PublishSerializer
        else:
            return self.serializer_class

    # @action(methods=['GET'],detail=False,url_path='login',url_name='login')
    @action(methods=['GET'],detail=True)
    def login(self, request,pk):
        print(self.action)
        print(pk)
        # self.get_serializer()
        return Response('登录成功')
    
    
## 路由
router.register('test', views.TestView, basename='testview')

DRF 之认证功能

判断用户是否登录
某个接口登录后才能访问，需要使用认证功能

登录功能

#如果全局使用了认证类，登录接口需要局部禁用掉
class LoginView(ViewSet):
    authentication_classes = []  #不使用任何认证类
    @action(methods=['POST'], detail=False)
    def login(self, request):
        name = request.data.get('name')
        password = request.data.get('password')
        user=User.objects.filter(name=name,password=password).first()
        if user:
            # 生成一个随机字符串
            # 通过伪随机数生成一个永不重复的字符串
            token=str(uuid.uuid4())
            # 把随机字符串存入表，UserToken 表，如果存在，就更新 token，如果不存在，就新增
            # UserToken.objects.create(token=token,user=user)
            UserToken.objects.update_or_create(defaults={'token':token},user=user)
            return Response({'code':100,'msg':'登录成功','token':token})
        else:
            return Response({'code':101,'msg':'用户名或密码错误'})

认证类

###自定义认证类，要继承 BaseAuthentication，重写 authenticate，如果认证通过，返回两个值，如果认证失败，抛认证失败的异常
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .models import UserToken


class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        # 校验用户是否登录：看它有没有带 token 来，以及 token 是不是合法的（是不是我给的）
        token = request.GET.get('token')
        # 校验 token 是否合法（根据 token 去库中查询是否存在，如果存在，就是登陆了，放行）
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            # 带的 token 是有效的
            # user_token.user 当前登录用户
            return user_token.user, token
        else:
            raise AuthenticationFailed('token不合法或没有迭代token')

认证类的使用

# 局部使用（在视图类中加入）

#认证类的局部配置
from app01.auth import LoginAuth
class PublishView(ModelViewSet):
    #局部配置
    authentication_classes = [LoginAuth,]
    

#全局使用
# 认证类的全局配置
REST_FRAMEWORK={
    "DEFAULT_AUTHENTICATION_CLASSES":["app01.auth.LoginAuth",]
}

DRF 之权限

# 继承 BasePermission，重写 has_permission，如果有权限，就返回 True，没有权限就返回 False
from rest_framework.permissions import BasePermission


class PermissionUser(BasePermission):
    def has_permission(self, request, view):
        # 如果有权限，返回 True
        if request.user.user_type == 1:
            return True  # 超级用户允许访问
        else:
            return False

局部和全局使用

#认证类的局部配置
from app01.auth import LoginAuth
class PublishView(ModelViewSet):
     # 权限类: publish 的5个接口，必须超级用户才能访问
    permission_classes = [PermissionUser]
    

#全局使用
REST_FRAMEWORK={
    "DEFAULT_PERMISSION_CLASSES":["app01.auth.PermissionUser",]
}