认证、权限、频率
认证类前奏登录功能
模型类
class User(models.Model):
name = 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)
登录视图类
class UserView(ViewSetMixin, CreateAPIView):
queryset = models.User.objects.all()
serializer_class = serializer.UserModelSerializer
authentication_classes = []
#基于原生session版
@action(methods=['POST'], detail=False)
def login(self, request):
username = request.data.get('username')
password = request.data.get('password')
user = models.User.objects.filter(name=username, password=password).first()
request.session['name'] = user.name
request.session['id'] = user.id
print(type(request.session))
request.session.save()
print(request.session.session_key)
if user:
return APIResponse(msg='登录成功', token=request.session.session_key)
else:
return APIResponse(status=101, msg='用户名或密码错误')
# 基于自己写的UserToken表版
@action(methods=['POST'], detail=False)
def login(self, request):
username = request.data.get('username')
password = request.data.get('password')
user = models.User.objects.filter(name=username, password=password).first()
token = uuid.uuid4() # 生成一个uuid的随机字符串
# 这个是错误的：user.usertoken是None
# user.usertoken.user=user
# user.usertoken.token=token
# 如果每次都是新增，如果它登录过，这个地方会报错
# models.UserToken.objects.create(user=user,token=token)
# 如果有就更新，如果没有就创建
# 根据user去查询，如果能查到，就修改token，如果查不到，就新增一条
models.UserToken.objects.update_or_create(defaults={'token': token}, user=user)
if user:
return APIResponse(msg='登录成功', token=token)
else:
return APIResponse(status=101, msg='用户名或密码错误')
路由
router = SimpleRouter()
router.register('user', views.UserView)
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include(router.urls)),
]
认证类
认证类的编写
####基于自己写的UserToken表
class LoginAuth(BaseAuthentication):
def authenticate(self, request):
token = request.GET.get('token')
user_token = models.UserToken.objects.filter(token=token).first()
if user_token:
# 登录了
# 返回两个值，第一个值，给了新的request对象的user属性，通常情况我们把当前登录用户给它
return user_token.user, ''
else:
raise AuthenticationFailed('您没有登录')
####基于session的
from django.contrib.sessions.models import Session
from importlib import import_module
from django.conf import settings
class LoginAuth(BaseAuthentication):
def authenticate(self, request):
token = request.GET.get('token')
#通过传入的token（session_key,取到当前key的session对象）
engine = import_module(settings.SESSION_ENGINE)
self.SessionStore = engine.SessionStore
request.session = self.SessionStore(token)
Session.objects.filter(session_key=token).first()
# print(request.session['name'])
if request.session.get('name',None):
print(request.session['name'])
print(request.session['id'])
return '',''
else:
raise AuthenticationFailed('您没有登录')
认证类的使用（全局用，局部用）
#全局用，setting中配置（所有接口都需要认证）
REST_FRAMEWORK={
"DEFAULT_AUTHENTICATION_CLASSES":["app01.auth.LoginAuth",]
}
# 登录功能需要局部禁用，在视图类中加入
authentication_classes = []
#只在局部使用，只在视图类中加
authentication_classes = [LoginAuth,]
权限类
权限类的编写
class MyPermission(BasePermission):
message='你没有权限'
def has_permission(self, request, view):
if request.user.user_type == 1:
return True
else:
self.message='你是%s用户，你没有权限'%request.user.get_user_type_display()
return False
权限类的使用（全局用，局部用）
# 局部使用（在视图类中加）
permission_classes = [MyPermission,]
# 全局使用（在配置文件中配置）
REST_FRAMEWORK={
"DEFAULT_PERMISSION_CLASSES":["app01.auth.MyPermission",],
}
频率类
定义一个频率类
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):
scope = 'ip_th'
def get_cache_key(self, request, view):
return self.get_ident(request)
在配置文件中配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_RATES': {
'ip_th': '5/m', #一分钟访问5次
},
}
权限类的使用（全局用，局部用）
# 局部用，在视图类中配置
throttle_classes = [MyThrottle,]
# 全局用，在配置文件中配置
REST_FRAMEWORK = {
"DEFAULT_THROTTLE_CLASSES": ["app01.auth.MyThrottle", ],
'DEFAULT_THROTTLE_RATES': {
'ip_th': '5/m', #一分钟访问5次
},
}
自定义频率类
class MyThrottling(BaseThrottle):
VISIT_RECORD = {} # 记录访问者的大字典
def __init__(self):
self.history = None
def allow_request(self, request, view):
# （1）取出访问者ip
# （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
# （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
# （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
# （1）取出访问者ip
# print(request.META)
ip = request.META.get('REMOTE_ADDR')
import time
ctime = time.time()
# （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问
if ip not in self.VISIT_RECORD:
self.VISIT_RECORD[ip] = [ctime, ]
return True
self.history = self.VISIT_RECORD.get(ip,[])
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
while self.history and ctime - self.history[-1] > 60:
self.history.pop()
# （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
# （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
if len(self.history) < 3:
self.history.insert(0, ctime)
return True
else:
return False
def wait(self):
import time
ctime = time.time()
# return 60 - (ctime - self.history[-1])
return 1
认证，权限，频率使用套路
写一个类继承一个基类
写方法（authenticate，has_permission,allow_request）
频率类 由于我们继承了SimpleRateThrottle，所以不需要写allow_request
重写get_cache_key，返回什么就以什么作为限制条件（ip，用户id）
返回ip,父类里又有get_ident
