auth组件
-auth组件
-auth是什么?
-django内置的用户认证系统,可以快速的实现,登录,注销,修改密码....
-怎么用?
-(1)先创建超级用户:
-python3 manage.py createsuperuser
-输入用户名,邮箱(可以不输入),密码,敲回车,这样就创建出一个超级用户
-也就是在auth_user这个表中插入了一条数据(密码是加密的,所以我不能手动插入)
-(2)验证用户:
-from django.contrib import auth
-user = auth.authenticate(request, username=name, password=pwd)
-相当于在查询:user=models.User.objects.filter(name=name,pwd=pwd).first()
-如果校验通过,会返回一个user对象,通过判断user对象,校验是否验证成功
-(3)登录
-auth.login(request,user)
-其实就是在session中写了一条数据
-(4)一旦登录成功,调了这个函数login(request,user)
-以后再视图类,函数中的request对象中,就有一个user对象,就是当前登录的用户对象
-如果没有登录,request.user=AnonymousUser,匿名用户
-(5)注销
-auth.logout(request)
-内部:调用了request.session.flush(),删除了登录状态
-(6)登录认证装饰器
-from django.contrib.auth.decorators import login_required
-@login_required(redirect_field_name='eee',login_url='/login/')
-redirect_field_name:修改?后面的key值,
-login_url:如果没有登录,跳转到的页面
-可以局部配置
-可以全局配置(在setting中)
# 全局的配置,如果没有登录,跳到这个路由
LOGIN_URL='/login/'
-(7)创建用户:
-from django.contrib.auth.models import User
- 创建超级用户和普通用户
# 不能用create
# user=User.objects.create(username=name,password=pwd)
# 创建超级用户
# user=User.objects.create_superuser(username=name,password=pwd)
# 创建普通用户
user=User.objects.create_user(username=name,password=pwd)
-(8)校验密码
-request.user.check_password(pwd)
-先拿到用户(可以是登录用户,可以现查)
-(9)修改密码:
-user.set_password(pwd)
-user.save()
-注意:一定要调用save(),否则是不保存的
-(10)is_authenticated()
-如果通过验证,是true反之false
-(11)其他方法(了解):
-is_active:禁止登录网站(用户还存在,封号)
-is_staff:是否对网站有管理权限(能不能登录admin)
-(12)删除用户
-orm删除
如果想在认证组件上加手机号等其他字段:如何处理
-(1) 定义一个表模型,跟User一对一管理
class UserDetail(models.Model):
phone=models.CharField(max_length=32)
# 一对一跟auth_user表做关联
# 如果是从外部引入的表模型,是不能加引号的
# 如果加引号,只是在当前model找
user=models.OneToOneField(to=User)
-(2)定义一个表模型,继承(AbstractUser)
-from django.contrib.auth.models import AbstractUser
class UserInfo(AbstractUser):
# username,password...都有
phone=models.CharField(max_length=32)
sex=models.BooleanField()
-在setting中配置:
AUTH_USER_MODEL ='app01.UserInfo'
-做数据库迁移,以后就没有auth_user这个表了,以后认证组件用的表就是UserInfo
-原来auth中的其他操作:
-authentication
-login
-logout
-set_password
....
---一样用,完全一样
-不一样的地方:
如果之前用到User这个表模型的地方,都换成UserInfo
forms组件
-forms是什么?
就是一个类,可以校验字段(前台传过来的字段)
-怎么用:
-校验字段功能:
from django import forms
from django.db import models
# Create your models here.
from django.contrib.auth.models import AbstractUser
from django.core.exceptions import ValidationError
-先写一个类,继承Form
class Myform(forms.Form):
#min_length属性 检验规范:最小长度
#max_length
#error_messages:将违反对应规则的错误信息改为中文
#label 渲染前台信息的时候,将label设置为中文
#widget = forms.widgets.PasswordInput(attrs = 'class':'form-control')
#widget 渲染前台时采用密文的方式,还可以设置样式,attrs =
#invalid:格式错误,邮箱
name = forms.CharField(min_length=3, max_length=8, label="姓名",
error_messages={
'min_length': '长度不短于3',
'max_length': '长度不长于8',
'required': '不能为空',
})
pwd = forms.CharField(min_length=3, max_length=8, label="密码",
widget=forms.widgets.PasswordInput(attrs={'class': 'form-control'}),
error_messages={
'min_length': '长度不短于3',
'max_length': '长度不长于8',
'required': '不能为空',
})
email = forms.EmailField(label="邮箱",
error_messages={
'min_length': '长度不短于3',
'max_length': '长度不长于8',
'required': '不能为空',
'invalid': '格式错误'
}
渲染模板
-渲染模板
-第一种方式:(灵活性最高)
<form action="">
姓名:{{ myform.name }}
密码:{{ myform.pwd }}
邮箱:{{ myform.email }}
<input type="submit" value="注册">
</form>
-第二种方式:for循环form对象(用的比较多):
<form action="" method="post" novalidate>
{% for obj in myform %}
<p>{{obj.label }}:{{ obj }}
<span>{{ obj.errors.0 }}</span>
</p>
{% endfor %}
<input type="submit" value="注册">
<span>{{ error_msg }}</span>
</form>
-第三种方式(不建议用):
<form action="" method="post" >
{# {{ myform.as_p }}#}
{{ myform.as_ul }}
<input type="submit" value="提交">
</form>
渲染错误信息
-渲染错误信息
- myforms有errors
-属性(name)也有errors
-错误信息,变成中文:
- error_messages={'max_length': '最长是8', 'min_length': '最短是3', 'required': '这个必须填','invalid': '不符合邮箱格式'}
-给input标签指定样式,指定格式:
-widget=widgets.TextInput(attrs={'class':'form-control'})
-模板,渲染错误信息:<span>{{ myform.name.errors.0 }}</span>
局部钩子
局部校验,只要form中name校验过了,就可以执行到
#导入validationError
from django.core.exceptions import ValidationError
#编写需要增加校验项的字段
def clean_name(self):
#取出字段校验通过的信息,用来再进行判断,如果没通过就不会执行到此函数
name = self.cleaned_data.get('name')
import re
pattern = '^d+'
if re.match(pattern,name):
raise ValidationError("不能以数字开头")
return name
全局钩子
#导入validationError
from django.core.exceptions import ValidationError
#一定会被执行,不管前面是否校验通过
def clean(self):
pwd = self.cleaned_data.get('pwd')
re_pwd = self.cleaned_data.get('re_pwd')
if pwd!=re_pwd:
raise ValidationError("两次密码不同")#会放在errors的__all__属性里
return self.cleaned_data
前台
<form action="" method="post" novalidate>
<form action="">
{% for obj in myform %}
<p>{{obj.label }}:{{ obj }}
<span>{{ obj.errors.0 }}</span>
</p>
{% endfor %}
<input type="submit" value="注册">
<span>{{ error_msg }}</span>#放在for循环里,会打多次
</form>
</form>
def register(request):
if request.method == "GET":
myform = Myform()
if request.method == "POST":
myform = Myform(request.POST)
if not myform.is_valid():#判断是否通过验证
# {'__all__': [ValidationError(['两次密码不同'])]}
try:
error_msg = myform.errors.as_data().['__all__'][0]#errors.as_data()得到的是字典
except:
pass
return render(request,"register.html",locals())
中间件
## 中间件
```python
1.中间件是什么:
请求和响应之间的一道屏障
2.中间件的作用:
控制请求和响应
3.自定义中间件
一.导入类
from django.utils.deprecation import MiddlewareMixin
二.定义一个我们自己的中间件(类),继承MiddlewareMixin
from django.utils.deprecation import MiddlewareMixin
class Mymiddle1(MiddlewareMixin):
def process_request(self,request):
pass
def process_response(self,request,response):
pass
三.在配置文件中注册自定义中间件
MIDDLEWARE = [
'app01.mymiddle.Mymiddle1'
]
```
## 中间件的方法
```python
process_request(self,request)
process_view(self, request, callback, callback_args, callback_kwargs)
process_template_response(self,request,response)
process_exception(self, request, exception)
process_response(self, request, response)
```
## process_request process_response
```python
返回值
①process_request
如果return HttpResponse对象,直接返回,其后的中间件就不起作用了
如果return None(默认就是return none) 继续往下走
②process_reponse
必须要return Httpresponse的对象
执行顺序
中间件的process_request方法是在执行视图函数之前执行的。
当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
不同中间件之间传递的request都是同一个对象
多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。
```
## process_view
```python
process_view(self, request, view_func, view_args, view_kwargs)
该方法有四个参数
request是HttpRequest对象。
view_func是Django即将使用的视图函数。 （它是实际的函数对象，而不是函数的名称作为字符串。）
view_args是将传递给视图的位置参数的列表.
view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数（request）
Django会在调用视图函数之前调用process_view方法。
它应该返回None或一个HttpResponse对象。 如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。 如果它返回一个HttpResponse对象，Django不会调用适当的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。
```
## process_template_response(了解)
```python
该方法对视图函数返回值有要求，必须是一个含有render方法类的对象，才会执行此方法
class Test:
def __init__(self,status,msg):
self.status=status
self.msg=msg
def render(self):
import json
dic={'status':self.status,'msg':self.msg}
return HttpResponse(json.dumps(dic))
def index(response):
return Test(True,'测试')
```
## 中间件的应用场景
```python
1.做ip访问频率的限制
某些IP访问服务器的频率过高，进行拦截，比如限制每分钟不能超过20次。
2.url访问过滤
如果用户访问的是login视图（放过）
如果访问其他视图，需要检测是不是有session认证，已经有了放行，没有返回login，这样就省得在多个视图函数上写装饰器了！
```
CSRF
cross site request
是什么
攻击者盗用了你的身份,以你的名义发送恶意请求,对服务器来说这个请求是完全合法的
原理,你登陆后拿到了服务端的cookie,当你不关闭网站A,打开了黑客网站B,点击了网站B的按钮发请求,请求发到了网站A的服务器,B也带着你的cookie
如何防范:
1.通过refer
2.加一个随机字符串检验(加载请求的路径里,加载请求体中)
3.在请求头加字符串校验
form表单:{% csrf_token %}
视图函数:request.POST.csrfmiddlewaretoken
django中的应用:
1.中间件不注释
2.以后发post请求,携带那个随机字符串
ajax中的应用:
属性选择器:
1.data{
'csrfmiddlewaretoken':
$('[name = 'csrfmiddlewaretoken']').val()
}
2.data{
'csrfmiddlewaretoken':'{{csrf_token}}'
}
3.
需要导入插件 jquery.cookie.js
从cookie中取,放入请求头
var token = $.cookie('csrftoken')
# var token = '{{csrf_token}}'
$.ajax(
{
headers:{'X-CSRFToken':token}
})
csrf局部禁用
导一个装饰器
from django.views.decorators.csrf import csrf_exempt,csrf_protect
#局部禁用装饰器
@csrf_exempt
#局部保护装饰器
@csrf_protect
CBV的局部禁用和局部使用
from django.views import View
from django.utils.decorators import method_decorator
#2.@method_decorator(csrf_protect,name= 'dispatch')加在类上,标注名称
class Csrf_disable(View):
#1.@method_decorator(csrf_protect)加在dispatch方法上
def dispath(self,request,*args,**kwargs):
res= super().dispatch(request,*args,**kwargs)
return res
def get(self,request):
return
def post(self,request):
return