路由

自己写的路由

path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'})),
path('admin/<int:pk>', views.BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),

自动生成路由

1.导入路由类
# drf提供了两个路由类，继承了ViewSetMixin及其子类的视图类，就可以使用这两路由来自动生成
from rest_framework.routers import SimpleRouter, DefaultRouter

2.实例化得到对象
router = SimpleRouter()
3.注册路由,可以注册多个
# 第一个参数是路径，第二个参数是视图类，第三个参数是别名(可以不写)
router.register('books', views.BookView, 'books')
4.将自动生成的路由加入urlpatterns
urlpatterns = [
    path('admin/', admin.site.urls),
    # 方式2：使用include添加
    path('', include(router.urls)),
]
# 方式1：把自动生成的路由添加到urlpatterns中
urlpatterns += router.urls
'''
在输入根路径时，DefaultRouter会显示你能访问的路径
在输入根路径时，SimpleRouter不会显示
-DefaultRouter比SimpleRouter多一个根路径，显示所有注册过的路由
'''

action装饰器的使用

1.继承了ViewSetMixin及其子类的视图类就可以使用自动生成路由，自动生成的路由映射关系其实是定死的
/books/的get请求--list
/books/的post请求--create
'''
如果视图类中不需要action装饰器的话，视图类中必须要有
list、destory、retrieve、create、update方法之一
也就是必须要有5个视图扩展类之一+GenericAPIView或9个视图子类或ModelViewSet
'''

2.在视图函数中，会有一些其它名字的方法，必需要使用action装饰器做映射
class UserView(ViewSet):
    '''
    methods：支持的请求方式，可以是多个
    detail：默认是False，控制生成的路由是/user/login/还是/user/pk/login/是不是代pk
    url_path：控制生成的/user/后的路径是什么，如果不写默认以方法名命名
    url_name：起别名，用于反向解析
    '''
    # 向/user/login/地址发送get请求，就会触发这个方法的执行
    @action(methods=['GET'], detail=False, url_path='login', url_name='login')
    def login(self, request):
        return Response('ok')

登录接口

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):
    '用户登录记录表'
    user = models.OneToOneField(to='User', on_delete=models.CASCADE)
    # 用户如果没有登录，就是空，如果登录了，就有值，登录多次以最后一次为准
    token = models.CharField(max_length=32, null=True)

views.py

from .models import User, UserToken
from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
from rest_framework.decorators import action
import uuid


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的数据更新，没有则新增
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        return Response({'code': 101, 'msg': '用户名或密码错误'})

urls.py

from rest_framework.routers import SimpleRouter

# 实例化得到对象
router = SimpleRouter()
# 注册路由,可以注册多个
router.register('user', views.UserView, 'user')
urlpatterns = [
    path('admin/', admin.site.urls),
    # 使用include添加
    path('', include(router.urls)),
]

认证

-必须登录之后才能访问接口，通过认证完成
'''
1.写一个认证类，继承BaseAuthentication
2.重写authenticate方法，在内部做认证
3.如果认证通过，返回2个值
4.如果认证不通过抛异常
5.只要返回2个值，则在后续的request.user就是当前登录用户
'''
1.方法1(导入认证类)：
from .auth import LoginAuth


class BookView(ModelViewSet):
    authentication_classes = [LoginAuth]

2.方式2(全局配置，在配置文件中)：
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth', ]
}

3.局部禁用：
'全局配置后，添加到不需要认证中'
authentication_classes = []

认证类

1.urls.py
from django.contrib import admin
from django.urls import path, include
from app01 import views
from rest_framework.routers import SimpleRouter

router = SimpleRouter()
router.register('user', views.UserView, 'user')
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(router.urls)),
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookDateView.as_view()),
    path('publish/', views.PublishView.as_view()),
    path('publish/<int:pk>/', views.PublishDataView.as_view()),
]

2.views.py
from .models import UserToken
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed


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
            return user_token.user, token
        raise AuthenticationFailed('你还没登录')

作业

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

2 图书的必须登录后才能方法，出版社的不登录就能访问

​ -全局配置，局部禁用

from .models import Book, User, UserToken, Publish
from rest_framework.viewsets import ModelViewSet, ViewSet
from .serializer import BookSerializer, PublishSerializer
from rest_framework.response import Response
from rest_framework.decorators import action
import uuid
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin, CreateModelMixin, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView, RetrieveUpdateAPIView, RetrieveDestroyAPIView


class BookView(GenericAPIView, ListModelMixin, CreateModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

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

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


class BookDateView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    serializer_class = BookSerializer
    queryset = Book.objects.all()

    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(ListCreateAPIView):
    authentication_classes = []
    serializer_class = PublishSerializer
    queryset = Publish.objects.all()


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


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 = str(uuid.uuid4())
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        return Response({'code': 101, 'msg': '用户名或密码错误'})

3 研究一下级联删除的其他（）

1.on_delete参数
on_delete=None'将关联表数据删除时，'
on_delete=SET_NULL'将关联表数据删除时，与之关联的字段为null'
on_delete=SET_DEFAULT'将关联表数据删除时，与之关联的字段为设置为默认值，默认值提前通过"default=默认值"设置'
on_delete=CASCADE'将关联表数据删除时，与之关联的字段也删除'
on_delete=SET()'将关联表数据删除时，括号内为值则与之关联的字段为括号内的值，括号内为可执行对象则与之关联的字段为执行对象的返回值'