标签：06 models request rest Django token user import class

目录

• 1. 自动生成路由
  • 1.1 本质
  • 1.2 使用步骤
  • 1.3 SimpleRouter与DefaultRouter区别
  • 1.4 自动生成的路由映射关系其实定死了
  • 1.5 action 装饰器的使用
  • 1.6 action装饰器的使用
  • 1.7 视图类不写action装饰器
• 2. 登录接口编写
  • 2.1 models.py
  • 2.2 views.py
  • 2.3 urls.py
• 3. 认证
  • 3.1 认证类 auth.py
  • 3.2 book的所有接口要登录才能访问
  • 3.3 通过认证类完成使用步骤
  • 3.4 让某个视图类登录后才能访问
• 作业
  • 1. 关联的关系
  • 2. 代码
  • 3.研究一下级联删除的其他

1. 自动生成路由

1.1 本质

drf 提供了两个路由类(SimpleRouter,DefaultRouter)，以后继承了ViewSetMixin及其子类的视图类，就可以使用这个路由类来自动生成路由

1.2 使用步骤

# 第一步：导入路由类
from rest_framework.routers import SimpleRouter, DefaultRouter

# 第二步：实例化得到的对象
router = SimpleRouter()
# router = DefaultRouter()
 
# 第三步：注册路由(可以注册多个)
# 第一个参数：路径 第二个参数：视图类 第三个参数：别名，可以不写
router.register('books', views.BookView, 'books')

# 第四步：把自动生成的路由添加到urlpatterns中(两种方式)
# 方式一
urlpatterns+=router.urls
# 方式二
urlpatterns = [
    path('', include(router.urls))
]

1.3 SimpleRouter与DefaultRouter区别

SimpleRouter

DefaultRouter

DefaultRouter比SimpleRouter区别：DefaultRouter会多附带一个默认的API根视图,返回一个包含所有列表视图的超链接响应数据。(多一个根路径，显示所有注册过的路由)

1.4 自动生成的路由映射关系其实定死了

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

1.5 action 装饰器的使用

# 注意：继承了ViewSetMixin及其子类的视图类就可以自动生成路由，但是映射关系是定死的（get:list,post:create）,自己想做映射关系需要定死
from rest_framework.response import Response
from rest_framework.decorators import action


class UserView(ViewSet):
    # /user/login/ 地址发送get请求，就会触发这个方法的执行
    @action(methods=['GET', ], detail=False, url_path='login', url_name='login')
    def login(self, request):
        return Response('ok')

1.6 action装饰器的使用

参数：
1. methods: 支持的请求方式，列表
2. detail: 默认是False 控制生成的路由是 /user/login/ 还是 /user/pk/login
3. url_path: 控制生成的/user/后的路径是什么，如果不写，默认以方法名命名   /user/login/
4. url_name: 别名，用于反向解析

@action(methods=['GET','POST'], detail=True, url_path='login')
def login(self, request,pk):

1.7 视图类不写action装饰器

视图类不需要写action装饰器的话，视图类中必须要有list,destroy,retrieve,create,update方法之一
其实必须是  5个视图扩展类之一+GenericAPIView  或9个视图子类,ModelViewSet

2. 登录接口编写

2.1 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)  # 用户如果没有登录就是空，如果登陆了就是值,登录多次以最后一次为准

2.2 views.py

from .models import User, UserToken
import uuid


# 登录接口，只要带数据，一般都用post
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': '用户名或密码错误'})

2.3 urls.py

# 第一步：导入路由类
from rest_framework.routers import SimpleRouter, DefaultRouter

# 第二步：实例化得到的对象
router = SimpleRouter()
# router = DefaultRouter()
# 第三步：注册路由(可以注册多个)
# 第一个参数：路径 第二个参数：视图类 第三个参数：别名，可以不写
router.register('user', views.UserView, 'user')
# 第四步：把自动生成的路由添加到urlpatterns中(两种方式)
# 方式一
urlpatterns+=router.urls

3. 认证

3.1 认证类 auth.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:
            return user_token.user, token  # 返回两个值，一个是当前登录用户，一个是token
        else:
            raise AuthenticationFailed('您没有登录')

3.2 book的所有接口要登录才能访问

# book的所有接口要登录才能访问
from .auth import LoginAuth


class BookView(ModelViewSet):
    authentication_classes = [LoginAuth, ]
    serializer_class = BookSerializer
    queryset = Book.objects.all()

3.3 通过认证类完成使用步骤

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

3.4 让某个视图类登录后才能访问

方式一：
    class BookView(ModelViewSet):
        authentication_classes = [LoginAuth,]
方式二：
    REST_FRAMEWORK={
            'DEFAULT_AUTHENTICATION_CLASSES':['app01.auth.LoginAuth',]
        }


局部禁用：
     authentication_classes = []

作业

1. 关联的关系

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

图书表和出版社表： 一对多
用户表和用户登录记录表：一对一

2. 代码

图书的必须登录后才能方法，出版社的不登录就能访问,全局配置，局部禁用

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', on_delete=models.CASCADE)


class Publish(models.Model):
    name = models.CharField(max_length=32)
    address = models.CharField(max_length=32)


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


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

serializer.py

from .models import Book, Publish
from rest_framework import serializers


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'


class PublishSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = '__all__'

views.py

from django.shortcuts import render

# Create your views here.

from .models import Book, Publish
from rest_framework.mixins import ListModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin, \
    RetrieveModelMixin
from .serializer import BookSerializer, PublishSerializer
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView, GenericAPIView


class BookView(ListCreateAPIView):
    serializer_class = BookSerializer
    queryset = Book.objects.all()


class BookDetailView(RetrieveUpdateDestroyAPIView):
    serializer_class = BookSerializer
    queryset = Book.objects.all()


class PublishView(GenericAPIView, ListModelMixin, CreateModelMixin):
    authentication_classes = []
    serializer_class = PublishSerializer
    queryset = Publish.objects.all()

    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 PublishDetailView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    authentication_classes = []
    serializer_class = PublishSerializer
    queryset = Publish.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)


from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
from rest_framework.decorators import action
from .models import User, UserToken
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 = 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': '用户名或密码错误'})

auth.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 = request.GET.get('token')
        user_token = UserToken.objects.filter(token=token).first()
        if user_token:
            return user_token.user, token
        else:
            raise AuthenticationFailed('您没有登录')

urls.py

from django.contrib import admin
from django.urls import path
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('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookDetailView.as_view()),
    path('publish/', views.PublishView.as_view()),
    path('publish/<int:pk>/', views.PublishDetailView.as_view()),
]

urlpatterns += router.urls

settings.py

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

图书的必须登录后才能访问

出版社的不登录就能访问

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

当删除关联表中数据时，当前表与其关联的行的行为。

models.CASCADE: 删除关联数据，与之关联也删除
models.DO_NOTHING：删除关联数据，引发错误IntegrityError
models.PROTECT：删除关联数据，引发错误ProtectedError
models.SET_NULL：删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
models.SET_DEFAULT：删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
models.SET：删除关联数据
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

标签：06,models,request,rest,Django,token,user,import,class
From： https://www.cnblogs.com/cainiaozhy/p/16770194.html