路由、登录接口编写、认证

路由

只要继承了ViewSetMixin及其子类的视图类，它的路由需要换一种写法
drf提供了俩个路由类，以后继承了ViewSetMinxin及其子类的视图类，就可以使用这俩个路由类来自动生成路由

自动生成路由

1.导入生成路由的写法
    from rest_framework.routers import SimpleRouter, DefaultRouter
2.实例化
    router = SimpleRouter()
3.注册(可以注册多个)
    router.register('user',views.UserView,'user')
4.加入到urlpatterns中（两种方式）
    urlpatterns+=router.urls
    path('', include(router.urls))  # 路由分发

路由的俩种方式

urlpatterns = [
    ...
]
urlpatterns += router.urls
或

urlpatterns = [
    ...
    url('', include(router.urls))
]

可以看到截图中的现实已经讲映射关系注释掉了，但是，此时使用了自动生成路由后，我们可以正常的查看数据

那其实在这里是因为自动生成器的路由映射关系其实定死了

/books/--->get--->list
/books/--->post--->create
/books/1--->get--->retrieve
/books/1--->put--->update
/books/1--->delete--->destroy

以后写的视图类不需要写action装饰器的话，视图类中必须要有

list，destroy，retrieve，create，update方法之一
其实是必须是 5个视图扩展类之一+GenericAPIView   9个视图子类，ModelViewSet

俩个路由类SimpleRouter和DefaultRouter

DefaultRouter比SimpleRouter多一个根路径，显示所有注册过的路由

action装饰器的使用

在视图集中，如果想要让Router自动帮助我们为自定义的动作生成路由信息，需要使用rest_framework.decorators.action装饰器

在视图函数中，会有一些其他名字的方法，必须要使用action装饰器做映射
以action装饰器装饰的方法名会作为action动作名，与list、retrieve等同
使用drf提供路由类router给视图集生成路由列表

@action(methods=['GET','POST'], detail=True, url_path='login')
def login(self, request,pk):
    ...
"""
methods: 设置当前方法允许哪些http请求访问当前视图方法

detail：设置当前视图方法是否是操作一个数据
    detail为True，表示路径名格式应该为 router_stu/{pk}/login/
    @action(methods=['get'], detail=True)
    def login(self, request,pk):
        """登录"""
        ...
    detail为False 表示路径名格式应该为 router_stu/get_new_5/
    @action(methods=['get'], detail=False)
    def get_new_5(self, request):
        """获取最新添加的5学生信息"""
        ...

url_path: 控制生成的/user/后的路径是什么，如果不写，默认以方法名命名   /user/login/，一般跟函数名同名即可
url_name：别名，用于反向解析
"""

这样写了以后，就可以自动生成路由了，并且做到了映射

由路由器自动为此视图集自定义action方法形成的路由会是如下内容：

router/get_new_5/$    name: router-get_new_5
router/{pk}/login/$   name: router-login

登录接口编写

models.py

# 用户表
class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    def __str__(self):
        return self.username


# 用户登录记录表
# 如何区分用户是否登录了？
class UserToken(models.Model):
    # SET_NULL   SET_DEFAULT   CASCADE  SET(函数内存地址)
    user = models.OneToOneField(to='User', on_delete=models.CASCADE)
    token = models.CharField(max_length=32, null=True)  # 用户如果没有登录，就是空，如果登录了，就有值，登录多次以最后一次为准

views.py

class UserView(ViewSet):
    authentication_classes = []
    @action(methods=['POST', ], detail=False, url_path='login')
    def login(self, request):
        # 取出前端传入的用户名密码，校验，通过，返回登录成功，失败就返回用户名密码错误
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        if user:
            # 登录成功,不同人生成的token是不一样的，谁登录的，就把token存到UserToken表中
            token = str(uuid.uuid4())  # 生成一个永不重复的随机字符串
            # 存UserToken:如果没有记录，就是新增，如果有记录更新一下即可
            # 通过user去UserToken表中查数据，如果能查到，使用defaults的数据更新，如果查不到，直接通过user和defaults的数据新增
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            # 作用是为了添加数据时防止重复. 先去查询, 如果没有在创建, 如果有则更新.
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

urls.py

from rest_framework.routers import SimpleRouter, DefaultRouter

router = SimpleRouter()

router.register('user',views.UserView,'user')

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(router.urls)),
]

user表中有这条数据，就会登录成功

没有的话，就会返回错误信息

认证

写一个认证类

# 通过认证类完成，使用步骤
    1 写一个认证类，继承BaseAuthentication
    2 重写authenticate方法，在内部做认证
    3 如果认证通过，返回2个值
    4 认证不通过抛AuthenticationFailed异常
    5 只要返回了两个值，在后续的request.user 就是当前登录用户

auth.py

from .models import UserToken
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed


class LoginAuth(BaseAuthentication):
    # 重写authenticate
    def authenticate(self, request):
        # 在这里做认证，校验用户是否登录（带了token，并且能查到，就是登录,返回两个值，否则就是没登录，抛异常）
        # 用户带的token从哪取？后端人员定的：放在请求地址中
        token = request.GET.get('token')
        # 通过token查询该token是否是在表中有记录
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            return user_token.user, token  # 返回两个值，一个是当前登录用户，一个是token
        else:
            raise AuthenticationFailed('您没有登录')

在settings.py中 LANGUAGE_CODR修改为 LANGUAGE_CODR = “ sh-hans”

可以在配置文件中配置全局默认的认证方案

在settings.py文件里面

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth', ]
}

也可以在每个视图中通过设置authentication_classess属性来设置

from .auth import LoginAuth


# book的所有接口要登录后才能访问
class BookView(ModelViewSet):
    authentication_classes = [LoginAuth, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    ...

局部禁用

class UserView(ViewSet):
    # 局部禁用,给authentication_classe设置空
    authentication_classes = []

    @action(methods=['POST', ], detail=False, url_name='login')
    def login(self, request):
        # 取出前段传入的用户名和密码，校验、通过，返回登录成功·，失败就返回用户名密码错误
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        # 登录成功，不同人生成的token是不一样的，谁登录的，就把token存到UserToken表中
        if user:
            token = str(uuid.uuid4())
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

认证失败会有俩种可能的返回值

401  Unauthorized  未认证
403  Permission Denied  权限被禁止

作业：

登录接口，图书5个接口，出版社5个接口（关联的关系），，使用9个视图子类，5个视图扩展类写

views.py

import uuid

from django.shortcuts import render

# Create your views here.
from rest_framework.decorators import action
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response

from .models import Book, Publish, User, UserToken
from rest_framework.viewsets import ViewSetMixin, ModelViewSet, ViewSet
from rest_framework.mixins import ListModelMixin, CreateModelMixin, RetrieveModelMixin, DestroyModelMixin, \
    UpdateModelMixin

from rest_framework.generics import ListAPIView, CreateAPIView, RetrieveAPIView, DestroyAPIView, UpdateAPIView
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView, RetrieveDestroyAPIView, \
    RetrieveUpdateAPIView
from .serializer import BookSerializer, PublishSerializer
from .auth import LoginAuth


# book的所有接口要登录后才能访问
class BookView(ViewSetMixin, GenericAPIView, ListModelMixin, CreateModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, *args, **kwargs):
        return self.list(*args, **kwargs)

    def post(self, *args, **kwargs):
        return self.create(*args, **kwargs)


class BookDetailView(ViewSetMixin, GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)


class PublishView(ViewSetMixin, ListCreateAPIView):
    authentication_classes = []
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class PublishDetailView(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    authentication_classes = []
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class UserView(ViewSet):
    # 局部禁用

    @action(methods=['POST', ], detail=False, url_name='login')
    def login(self, request):
        # 取出前段传入的用户名和密码，校验、通过，返回登录成功·，失败就返回用户名密码错误
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        # 登录成功，不同人生成的token是不一样的，谁登录的，就把token存到UserToken表中
        if user:
            token = str(uuid.uuid4())
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

urls.py

from django.contrib import admin
from django.urls import path
from rest_framework.routers import SimpleRouter
from app01 import views
from rest_framework.routers import SimpleRouter, DefaultRouter

router = SimpleRouter()
router.register('books', views.BookView, 'books')
router.register('publish', views.BookView, 'publish')
router.register('user', views.UserView, 'user')

urlpatterns = [
    path('admin/', admin.site.urls),
]
urlpatterns += router.urls

models.py

from django.db import models


# Create your models here.
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    publish = models.ForeignKey(to='Publish', to_field='nid', on_delete=models.CASCADE)

    def __str__(self):
        return self.name


class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    address = models.CharField(max_length=32)

    def __str__(self):
        return self.name


class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

    def __str__(self):
        return self.username


class UserToken(models.Model):
    user = models.OneToOneField(to='User', on_delete=models.CASCADE)
    token = models.CharField(max_length=32, null=True)

settings.py

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth', ]
}