MIDDLEWARE = [
    ‘django.middleware.security.SecurityMiddleware‘,
    ‘django.contrib.sessions.middleware.SessionMiddleware‘,
    ‘django.middleware.common.CommonMiddleware‘,
    ‘django.middleware.csrf.CsrfViewMiddleware‘,
    ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
    ‘django.contrib.messages.middleware.MessageMiddleware‘,
    ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
]

from django.contrib.sessions.middleware import SessionMiddleware

class SessionMiddleware(MiddlewareMixin):
        def process_request(self, request):
?
        def process_response(self, request, response):
        
class CsrfViewMiddleware(MiddlewareMixin):
        def process_request(self, request):
?
        def process_view(self, request, callback, callback_args, callback_kwargs):
?
        def process_response(self, request, response):
            
class AuthenticationMiddleware(MiddlewareMixin):
        def process_request(self, request):

process_request(self, request):
    请求过来的时候会按照配置文件中中间件从上到下的顺序依次执行每一个中间件中的process_request方法，如果没有直接跳到下一个
    若在定义中间件的process_request直接返回一个HttpResponse之类的则直接跳过剩下的部分从当前中间件的porcess_response执行后直接返回
?
    注意：Django是同级别直接返回，而flask是遇到这种情况会执行所有的process_response
            
process_response
    响应走的时候会按照配置文件中注册的中间件从下往上的顺序依次执行每一个中间件里面的
    process_response方法 该方法必须要有两个形参 并且需要将形参response返回
    如果你内部自己返回了HttpResponse对象 会将返回给用户浏览器的内容替换成你自己的

from django.utils.deprecation import MiddlewareMixin
?
class Mymid1(MiddlewareMixin):
    def process_request(self, request):
        print(‘我是第一个自定义中间件的process_request‘)
        若有同级别的返回则直接跳过剩下的部分直接返回 
        # return HttpResponse(‘一个返回值‘)
?
    def process_response(self, request, response):
        print(‘我是第一个自定义中间件的process_response‘)
        return response
    
class Mymid2(MiddlewareMixin):
    def process_request(self, request):
        print(‘我是第二个自定义中间件的process_request‘)
?
    def process_response(self, request, response):
        print(‘我是第二个自定义中间件的process_response‘)
        return response

# process_view方法   
def process_view(self, request, view_func, view_args, view_kwargs):
    print(‘我是第一个中间件里面的process_view‘)

request是HttpRequest对象。
?
view_func是Django即将使用的视图函数。 （它是实际的函数对象，而不是函数的名称作为字符串。）
?
view_args是将传递给视图的位置参数的列表.
?
view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数（request）。
?

它应该返回None或一个HttpResponse对象。 如果返回None，Django将继续处理这个请求，
执行任何其他中间件的process_view方法，然后在执行相应的视图。 如果它返回一个HttpResponse对象，
那么将不会执行Django的视图函数，而是直接在中间件中掉头，倒叙执行一个个process_response方法，最后返回给浏览器

def process_exception(self,request,exception):
    print(‘exception:‘,exception)
    print(‘我是第一个中间件里面的process_exception‘)
该方法两个参数:
?
一个HttpRequest对象
?
一个exception是视图函数异常产生的Exception对象。
?
这个方法只有在视图函数中出现异常了才执行，
它返回的值可以是一个None也可以是一个HttpResponse对象。
如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，
并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来

# 自定义中间件方法
def process_template_response(self,request,response):
    print(‘我是第一个中间件里面的process_template_reponse方法‘)
    return response

# views
def index(request):
    print(‘我是视图函数index‘)
    def render():
        return HttpResponse("你好啊 我是index里面的render函数")
    obj = HttpResponse("index")
    obj.render = render
    return obj

总结：process_template_response(self, request, response)
?
它的参数，一个HttpRequest对象，response是TemplateResponse对象（由视图函数或者中间件产生）。
?
process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render属性对应的render方法（或者表明该对象是一个TemplateResponse对象或等价方法）。

钓鱼网站
        本质搭建一个跟正常网站一模一样的页面
        用户在该页面上完成转账功能
        
        转账的请求确实是朝着正常网站的服务端提交
        唯一不同的在于收款账户人不同
        
        给用户书写form表单 对方账户的input没有name属性
        你自己悄悄提前写好了一个具有默认的并且是隐藏的具有name属性的input

# 真实网站
# views.py
def transfer(request):
    if request.method == ‘POST‘:
        username = request.POST.get(‘username‘)
        target_user = request.POST.get(‘target_user‘)
        money = request.POST.get(‘money‘)
        print(‘%s 给 %s 转了 %s元‘ %(username, target_user, money))
    return render(request, ‘transfer.html‘)
?
# transfer.html
<h2>我是真实的网站</h2>
<form action="" method="post">
    <p>username:<input type="text" name="username"></p>
    <p>target_user:<input type="text" name="target_user"></p>
    <p>money<input type="text" name="money"></p>
    <input type="submit">
</form>
?
?
# 钓鱼网站
# views.py
def transfer(request):
    if request.method == ‘POST‘:
        username = request.POST.get(‘username‘)
        target_user = request.POST.get(‘target_user‘)
        money = request.POST.get("money")
        print(‘%s 给 %s 转了 %s元‘%(username,target_user,money))
    return render(request,‘transfer.html‘)
?
?
# transfer.html
<h2>我是钓鱼网站</h2>
# 将传输数据的网站改为真实网站网址
<form action="http://127.0.0.1:8000/transfer/" method="post">
    <p>username:<input type="text" name="username"></p>
    <p>target_user:<input type="text"></p>
     # 在转账人下面新建一个隐藏的input框，默认值为jason，这样上面这个框就失效了
    <input type="text"  name="target_user" style="display: none" value="jason">
    <p>money:<input type="text" name="money"></p>
    <input type="submit">
</form>

# 只要在上面的form表单中加上下面这个{% csrf_token %}，就可以启动django配置中的django.middleware.csrf.CsrfViewMiddleware中间件，这样每次访问服务端都会随机产生一个字符串，用于识别身份（注意是没有绝对安全的web的）
?
{% csrf_token %}

# 写一个ajax请求
<script>
    $(‘#d1‘).click(function () {
        $.ajax({
            url:‘‘,
            type:‘post‘,
            data:{‘username‘:‘jason‘},
            success:function (data) {
                alert(data)
            }
        })
    })
</script>

<script>
    $(‘#d1‘).click(function () {
        $.ajax({
            url:‘‘,
            type:‘post‘, 
            data:{‘username‘:‘jason‘,‘csrfmiddlewaretoken‘:$(‘input[name="csrfmiddlewaretoken"]‘).val()},
            success:function (data) {
                alert(data)
            }
        })
    })
</script>

<script>
    $(‘d1‘).click(fnction(){
        $.ajax({
            url:‘‘,
            type:‘post‘,
            data:{‘username‘:‘jason‘,‘csrfmiddlewaretoken‘:‘‘{{csrf_token}}‘‘},
            success:function(data){
                alert(data)
            }
            
        })
    })
</script>

#第一步，配置静态文件
设置一个static文件夹
?
#第二步，在settings文件中配置静态文件路径
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, ‘satic‘)
]
# 第三步，在static文件夹下新建一个配置js文件，内容如下
function getCookie(name) {
    var cookieValue = null;
    if (document.cookie && document.cookie !== ‘‘) {
        var cookies = document.cookie.split(‘;‘);
        for (var i = 0; i < cookies.length; i++) {
            var cookie = jQuery.trim(cookies[i]);
            // Does this cookie string begin with the name we want?
            if (cookie.substring(0, name.length + 1) === (name + ‘=‘)) {
                cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                break;
            }
        }
    }
    return cookieValue;
}
var csrftoken = getCookie(‘csrftoken‘);
function csrfSafeMethod(method) {
  // these HTTP methods do not require CSRF protection
  return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
}
?
$.ajaxSetup({
  beforeSend: function (xhr, settings) {
    if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
      xhr.setRequestHeader("X-CSRFToken", csrftoken);
    }
  }
});
?
#第四步，在ajax请求中引入这个js文件
{% load static %}
<script src="{% static ‘myset.js‘ %}"></script>
<script>
    $(‘#d1‘).click(function () {
        $.ajax({
            url:‘‘,
            type:‘post‘,
            data:{‘username‘:‘jason‘},
            success:function (data) {
                alert(data)
            }
        })
    })
</script>
?

from django.views.decorators.csrf import csrf_exempt, csrf_protect

# 在指定视图函数上面添加下面这个装饰器
@csrf_exempt

# 可以将中间件 ‘django.middleware.csrf.CsrfViewMiddleware‘,注释掉
# 然后在指定视图函数上面添加下面这个装饰器
@csrf_protect

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from django.utils.decorators import method_decorator # 不论是自己写的装饰器还是别人写好的装饰器都要记得用这个method_decorator方法

from django.views import View
class MyHome(View): 
     def get(self,request):
        return HttpResponse(‘get‘)
    def post(self,request):
        return HttpResponse(‘post‘)
?
注意在urls.py文件中的写法
 url(r‘^home/‘,views.MyHome.as_view()),

@method_decorator(csrf_protect, name=post) # 第一种方法：指定某个方法名添加csrf
class MyHome(View): 
    def get(self,request):
        return HttpResponse(‘get‘)
    @method_decorator(csrf_protect）  #第二种方法：直接在方法名上添加装饰器
    def post(self,request):
        return HttpResponse(‘post‘)

from django.views import View
from django.utils.decorators import method_decorator
?
@method_decorator(csrf_protect,name=‘dispatch‘)  # 第三种方法这样写也可以
class MyHome(View):  
    
    @method_decorator(csrf_protect)  # 第三种方法 类中所有的方法都装
    def dispatch(self, request, *args, **kwargs):
        return super().dispatch(request,*args,**kwargs)
?
    def get(self,request):
        return HttpResponse(‘get‘)
  
    def post(self,request):
        return HttpResponse(‘post‘)

createsuperuser

# 第一步导入auth模块和auth模块中的User表
from django.contrib import auth
from django.contrib.auth.models import User
?
def register(request):
    if request.method == ‘POST‘:
        username = request.POST.get(‘username‘)
        password = request.POST.get(‘password‘)
        # User.objects.create(username=username,password=password)  # 不能使用 密码变成明文的了
        User.objects.create_user(username=username,password=password) # 这样就可以了 
        # User.objects.create_superuser(username=username,password=password,email=‘123@qq.com‘)  # 这种创建超级用户的方式需要填入邮箱，否则报错
    return render(request,‘register.html‘)
?

# 登陆认证
def login(request):
    if request.method == ‘POST‘:
        username = request.POST.get(‘username‘)
        password = request.POST.get(‘password‘)  # 明文
        # 数据库校验用户名和密码是否正确，这样是用明文校验是不对的
        # User.objects.filter(username=username,password=password)
        # 通过auth的内置方法来校验
        user_obj = auth.authenticate(request,username=username,password=password)
        print(user_obj)
        """
        用户名密码正确返回的是用户对象
        错误返回None
        """
        print(res.username)
        print(res.password)
        if user_obj:
            # 保存用户登录状态
            # request.session
            auth.login(request,user_obj)
            """
            只要执行了这一句话 之后在任意可以获取到request对象的地方
            都可以通过request.user获取到当前登录的用户对象
            """
            return HttpResponse("登录成功")
    return render(request,‘login.html‘)
?
?
?
def get_user(request):
    print(request.user)
    """
    用户登录成功之后 request.user拿到的就是用户对象
    没有登录 获取到的匿名用户
    """
    print(request.user.is_authenticated())
    # 返回的是布尔值
    return HttpResponse("get_user")
?
?
?
# 局部配置校验用户是否登录装饰器
# 先导入模块
from django.contrib.auth.decorators import login_required
?
# 若里面不传指定login_url参数就会导入到django内置的的登陆界面
#@login_required
@login_required(login_url=‘/login/‘) # 这样可以跳转到自定义的登陆界面
def xxx(request):
    return HttpResponse(‘xxx页面‘)
?
?
# @login_required
@login_required(login_url=‘/login/‘)
def yyy(request):
    return HttpResponse(‘yyy页面‘)
?
?
#@login_required
@login_required(login_url=‘/login/‘)
def zzz(request):
    return HttpResponse(‘zzz页面‘)
?
?
# 如何设置全局配置校验用户是否登录装饰器
# 在settings.py文件中写入下面这个代码
LOGIN_URL = ‘/login/‘
?
# 然后在指定视图函数上只要写下面这个就可以看，不需要在指定url了
@login_required
?
?
# 若同时有局部和全局配置，优先使用局部的
?
?
#如何进行密码修改
# 首先一定是登陆状态
@login_required
def set_password(request):
    if request.method == ‘POST‘:
        old_password = request.POST.get(‘old_password‘)
        new_password = request.POST.get(‘new_password‘)
        # 1 先校验旧密码是否正确
        is_right = request.user.check_password(old_password)
        # print(is_right) 是布尔值
        # 2 再去修改新密码
        if is_right:
            request.user.set_password(new_password)
            request.user.save()  # 一定要save一下  否则数据库无影响
    return render(request,‘set_password.html‘)
?
?
?
# 如何注销登陆状态
@login_required
def logout(request):
    auth.logout(request)
    return HttpResponse(‘注销成功‘)

# 第一种方法可以利用一对一表关系,就是新建一张表，与其是一对一关系，则两张表就是一张表，实现了扩展字段功能
?
#第二种，类的继承
# 在models.py文件中导入下面模块（实际上原先的django默认设置的表都是来源于AbstracterUser,因此我们也可以继承这个类来创建自己的表）
from django.contrib.auth.models import User,AbstractUser
# Create your models here.
class Userinfo(AbstractUser):
    phone = models.BigIntegerField()
    avatar = models.FileField()
# 扩展的字段 尽量不要与原先表中的字段冲突
    
        
 # 然后在配置文件写上下面这个代码
AUTH_USER_MODEL = ‘app01.Userinfo‘
# AUTH_USER_MODEL = ‘应用名.表名‘
"""
django就会将userinfo表来替换auth_user表
并且之前auth模块所有的功能不变 参照的也是userinfo表
"""