Django

　　

前提：

    用户认证组件：

        功能：用session记录登录验证状态

        前提：用户表：django自带的auth_user表

        创建超极用户：Python3 manage.py createsuperuser


        API:
            from django.contrib import auth:

                1 # 如果 验证成功返回user对象，否则返回None
                    user = auth.authenticate(username=user, password=pwd)

                2 auth.login(request, user)   # session注册login， request.user:当前登录对象,若没有就是个匿名对象(全局对象)

                3 auth.logout(request) # 注销

            from django.contrib.auth.models import User # User==auth_user

                4 request.user.is_authenticated:  # 是否通过校验

                5 user = User.objects.create_user(username='',password='',email='')  # 注册用户

        补充：
            匿名用户对象：



        总结：

            if not: auth.login(request,user) request.user == AnonymousUser()

            else:reuqest.user==登录对象

            reuqest.user是一个全局变量，可以在任何视图和模板直接使用



之前我们自己创建session得到django_session表中，一个浏览器登录两个用户的时候他们的session_key不变，第二个用户省下的内容会进行更新

但是，当我们引入用户认证组件的时候，一个浏览器登录两个用户的时候，所有的内容都会改变，如下，登录mumu和mm两个用户在django_session表中数据：(第二条数据会覆盖第一条数据)

session_key                            session_data                                                                                                                                                                                                                                                           expire_date
hdnc2g9a6fuqf7svei9lb28vage8f0vz    N2Q1MjQ5MTBmMjMzZmVmYmJlMWE5YmE0NDA2ZTM4NGFkNWM1MWIzNzp7Il9hdXRoX3VzZXJfYmFja2VuZCI6ImRqYW5nby5jb250cmliLmF1dGguYmFja2VuZHMuTW9kZWxCYWNrZW5kIiwiX2F1dGhfdXNlcl9pZCI6IjEiLCJfYXV0aF91c2VyX2hhc2giOiJjM2Q4YmVmZmY0OTk0NDQwZmUxN2MyNzQ3MTkxMzljNjRhM2FmMWMwIn0           2019-03-01 08:21:08.066179
hrzi7dm7nmskrn3m1usofdg5edn6ar76    ZTczOTlkMzM2M2EyNmExZTZhYzU3YjlhZWQ3ZDU0MDY4N2Q1ZjAyNTp7Il9hdXRoX3VzZXJfaGFzaCI6ImY3NTc2ZmExNjYwNmU4YmQwZmZkMzRiYjdmYWNlZGY5ZTVlOTAzZjciLCJfYXV0aF91c2VyX2JhY2tlbmQiOiJkamFuZ28uY29udHJpYi5hdXRoLmJhY2tlbmRzLk1vZGVsQmFja2VuZCIsIl9hdXRoX3VzZXJfaWQiOiIyIn0           2019-03-01 08:36:15.915105



############################################

F:Python全栈开发_中级第六模块Web开发authDemo>python manage.py makemigrations
No changes detected

问题解决方法：
    先 python manage.py makemigrations --empty yourappname 生成一个空的initial.py

    再 python manage.py makemigrations 生成原先的model对应的migration file

一.基于用户认证组件的登录验证信息储存

from django.contrib import auth
django.contrib.auth中提供了许多方法，这里主要介绍其中的三个：

 

authenticate()   

提供了用户认证，即验证用户名以及密码是否正确,一般需要username  password两个关键字参数

如果认证信息有效，会返回一个  User  对象。authenticate()会在User 对象上设置一个属性来标识后端已经认证了该用户，且该信息在后续的登录过程中是需要的。

当我们试图登陆一个从数据库中直接取出来不经过authenticate()的User对象时会报错！！！

user = authenticate(username='theuser',password='thepassword')
 

login(HttpRequest, user)　

该函数接受一个HttpRequest对象，以及一个认证了的User对象

此函数使用django的session框架给某个已认证的用户附加上session id等信息。

复制代码
from django.contrib.auth import authenticate, login
   
def my_view(request):
  username = request.POST['username']
  password = request.POST['password']
  user = authenticate(username=username, password=password)
  if user is not None:
    login(request, user)
    # Redirect to a success page.
    ...
  else:
    # Return an 'invalid login' error message.
    ...
复制代码
 

logout(request) 注销用户　

from django.contrib.auth import logout
   
def logout_view(request):
  logout(request)
  # Redirect to a success page.
该函数接受一个HttpRequest对象，无返回值。当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错

User 对象属性：username， password（必填项）password用哈希算法保存到数据库

is_staff ： 用户是否拥有网站的管理权限.

is_active ： 是否允许用户登录, 设置为``False``，可以不用删除用户来禁止 用户登录

 

user对象的 is_authenticated()

如果是真正的 User 对象，返回值恒为 True 。 用于检查用户是否已经通过了认证。
通过认证并不意味着用户拥有任何权限，甚至也不检查该用户是否处于激活状态，这只是表明用户成功的通过了认证。 这个方法很重要, 在后台用request.user.is_authenticated()判断用户是否已经登录，如果true则可以向前台展示request.user.name

要求：

1  用户登陆后才能访问某些页面，

2  如果用户没有登录就访问该页面的话直接跳到登录页面

3  用户在跳转的登陆界面中完成登陆后，自动访问跳转到之前访问的地址

方法一：

def my_view(request):
  if not request.user.is_authenticated():
    return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
方法二：

django已经为我们设计好了一个用于此种情况的装饰器：login_requierd()

from django.contrib.auth.decorators import login_required
      
@login_required
def my_view(request):
  ...
若用户没有登录，则会跳转到django默认的 登录URL '/accounts/login/ ' (这个值可以在settings.py文件中通过LOGIN_URL进行修改)。并传递  当前访问url的绝对路径 (登陆成功后，会重定向到该路径)。

 

创建用户

使用 create_user 辅助函数创建用户:

from django.contrib.auth.models import User
user = User.objects.create_user（username='',password='',email=''）
 

check_password(passwd)

用户需要修改密码的时候，首先要让其输入原来的密码 ，如果给定的值通过了密码检查，返回 True

 

修改密码

使用 set_password() 来修改密码

user = User.objects.get(username='')
user.set_password(password='')
user.save()
 


http://www.cnblogs.com/yuanchenqi/articles/9064397.html

https://www.cnblogs.com/liwenzhou/p/9030211.html

用户认证组件：逻辑更完善！！严谨
自己写得 存 session字段必须要都一致，然而有一些超级用户和普通用户应该不一样！！
http://www.cnblogs.com/yuanchenqi/articles/9064397.html

前提：
    用户认证组件前提：
        功能：用session记录登录验证状态

        前提：用户表：django auth-user   # 用户认证组件表   扩展 auth-user one2one 或继承

        创建超级用户： python3 manage.py createsuperuser

        API:
            from django.contrib import auth
            from django.contrib.auth.models import User   # User == auth_user

                1.auth.authenticate()
                2.auth.login()      # request.user 当前用户对象  是 auth-user表对象 全局可随便用
                3.auth.logout()

                4.request.user.is_authenticated

                5.User.objects.create_user()
                6.user.set_password()

                补充：
                    匿名用户对象：
                    class models.AnonymousUser

                    django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：

                    id 永远为None。
                    username 永远为空字符串。
                    get_username() 永远返回空字符串。
                    is_staff 和 is_superuser 永远为False。
                    is_active 永远为 False。
                    groups 和 user_permissions 永远为空。
                    is_anonymous() 返回True 而不是False。
                    is_authenticated() 返回False 而不是True。
                    set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
                    New in Django 1.8:
                    新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。

        总结：
            if not auth.login(request,user)
                request.user  == AnonymouseUser()
            else:
                request.user == 登录对象

            request.user 是一个全局变量  在任何视图和模板直接使用！！

示例：
    from django.contrib import auth
    # 验证成功返回user对象，否则返回None

    def login(request):
        user = request.POST.get('name')
        pwd = request.POST.get('pwd')
        user = auth.authenticate(username=user,password=pwd)
        if user:
            auth.login(request,user)  # request.user  =  当前登录对象 ， 没有登录 取出来得是匿名用户(AnonymousUser)
                                      # session表里的 session-id session-data 一个浏览器，不同得用户，两个字段都会变
                                      # 自己写得session session-id 不会变 不同用户，同一浏览器，只会变session-data
            return redirect('/index/')

        return render(request,'login.html')

    def index(request):
        print(request.user)
        print(request.user.username)
        print(request.user.id)
        print(request.user.is_anonymouse)

        # if request.user.is_anonymous:
        if not request.user.is_authenticated:

            return redirect('/login/')

        return render(request,'index.html')

    <h3>hi,{{ request.user.username }}</h3>


    def logout(request):
        auth.logout(request)
        return redirect('/login/')

    from django.contrib.auth.models import User

    def reg(request):
        if request.method == 'POST':
            user = request.POST.get('user')
            pwd = request.POST.get('pwd')

            # User.objects.create(username = user, password = pwd )   # 不能用这个 pwd 是明文
            user = User.objects.create_user(username = user, password = pwd )

            return redirect('/login/')

        return render(request,'reg.html')


    修改密码：
        user = User.objects.get(username = '')
        user.set_password(password = '')
        user.save()


    基于用户认证组件 得 认证装饰器： ( @login_required )
        from django.contrib.auth.decorators import login_required
        settings:
        LOGIN_URL = '/login/'  # 一会跳转到哪里去！！  # http://127.0.0.1:8000/login/?next=/index/

        def login(request):
            user = request.POST.get('name')
            pwd = request.POST.get('pwd')
            user = auth.authenticate(username=user,password=pwd)

            if user:
                auth.login(request,user)
                next_url = request.GET.get('next','/index/')
                return redirect(next_url)

         return render(request,'login.html')

        @login_required
        def index(request):

            return render(request,'index.html')

　　views.py

# -*- encoding:utf-8 -*-
from django.shortcuts import render, HttpResponse, redirect

# Create your views here.

from django.contrib import auth  # 导入模块
from django.contrib.auth.models import User  # 导入用户表

def login(request):

    if request.method == "POST":
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        '''
            正常我们自己建表，下面认证需要引入我们自己的表进行过滤，但是我们现在
            使用的是django建的表auth_user表，所以要用下面几步：
            
            1. 导入模块 from django.contrib import auth
            2. 过滤数据
        '''
        # 如果 验证成功返回user对象，否则返回None
        user = auth.authenticate(username=user, password=pwd)

        if user:
            auth.login(request, user)   # session注册login， request.user:当前登录对象,若没有就是个匿名对象

            return redirect("/index/") return render(request, "login.html")


def index(request):

    # print("request.user:", request.user)
    # print("username:", request.user.username)
    # print("id:", request.user.id)
    # print("is_anonymous:", request.user.is_anonymous)
    '''
        没有登录的时候，访问index页面的时候，request.user会得到一个匿名用户AnonymousUser
        上述输出如下：
            request.user: AnonymousUser
            username: 
            id: None
            is_anonymous: True
            
        登录之后，访问index得到如下输出：
            request.user: mumu
            username: mumu
            id: 1
            is_anonymous: False
    '''

    if request.user.is_anonymous: # 是否是匿名函数
    # if not request.user.is_authenticated:  # 是否通过校验
    #         return redirect("/login/")
    #
    username = request.user.username

    return render(request, "index.html", {"username": username})

　　login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h3>登录用户</h3>
    <form action="" method="post">
        {% csrf_token %}
        用户名 <input type="text" name="user">
        密码 <input type="password" name="pwd">
        <input type="submit" value="submit">
    </form>

</body>
</html>

　　index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <h3>Hi,{{ username }}!</h3>
{#    <h3>Hi,{{ request.user.username }}!</h3>#}  {# 由于request.user在整个项目中是个全局变量，所以不需要在视图中传入数据映射到模板中 #}

</body>
</html>

创建用户：

C:UsersAdministratorPycharmProjectsauthDemo>python manage.py createsuperuser
Username (leave blank to use 'administrator'): mm
Email address:
Password:mm123456
Password (again):mm123456
Superuser created successfully.

创建成功后得到的auth_user表：

更新的时候它不像之前那样子，它把session_key 和session_data数据都更新了，之前都是只更新session_data，现在逻辑跟严谨了。

二.注册/注销用户功能

　　views.py

def logout(request): # 注销

    auth.logout(request)

    return redirect("/login/")

def reg(request): # 注册

    if request.method == "POST":
        # 获取user和pwd方便插入数据库
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        # User.objects.create(username=user, password=pwd)  # 这种方式是不对的，插入的是明文，而实际表中需要的是密文
        user = User.objects.create_user(username=user, password=pwd)  # 这种方法会转为密文

        return redirect("/login/")

    return render(request, "reg.html")

　　reg.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h3>注册用户</h3>
    <form action="" method="post">
        {% csrf_token %}
        用户名 <input type="text" name="user">
        密码 <input type="password" name="pwd">
        <input type="submit" value="submit">
    </form>

</body>
</html>

　　index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <h3>Hi,{{ username }}!</h3>
{#    <h3>Hi,{{ request.user.username }}!</h3>#}  {# 由于request.user在整个项目中是个全局变量，所以不需要在视图中传入数据映射到模板中 #}

    <a href="/logout/">注销</a>
</body>
</html>

一点击注销按钮，就把django_session里边的记录都给清除了。

三.基于用户认证组件的认证装饰器

如果是真正的 User 对象，返回值恒为 True 。 用于检查用户是否已经通过了认证。
通过认证并不意味着用户拥有任何权限，甚至也不检查该用户是否处于激活状态，这只是表明用户成功的通过了认证。 这个方法很重要, 在后台用request.user.is_authenticated()判断用户是否已经登录，如果true则可以向前台展示request.user.name

要求：

1  用户登陆后才能访问某些页面，

2  如果用户没有登录就访问该页面的话直接跳到登录页面

3  用户在跳转的登陆界面中完成登陆后，自动访问跳转到之前访问的地址

方法一：

def order(request):
    print("order")

    if not request.user.is_authenticated:
    
        redirect("/login/")

    return render(request, "order.html")

方法二：

django已经为我们设计好了一个用于此种情况的装饰器：login_requierd()

先在settings里边设置下我要跳转到哪个页面

STATIC_URL = '/static/'

LOGIN_URL = "/login/"  #跳转到哪里由我自己决定; 不加这个django会给你默认跳转到 127.0.0.1:8000/accounts/login/?next=/index/;设置好这个后跳转到:/login/?next=/index/（是访问index进行跳转的）

　　view.py

# -*- encoding:utf-8 -*-

from django.shortcuts import render, HttpResponse, redirect

# Create your views here.

from django.contrib import auth  # 导入模块
from django.contrib.auth.models import User  # 导入用户表
from django.contrib.auth.decorators import login_required # 认证装饰器

def login(request):

    if request.method == "POST":
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        '''
            正常我们自己建表，下面认证需要引入我们自己的表进行过滤，但是我们现在
            使用的是django建的表auth_user表，所以要用下面几步：
            
            1. 导入模块 from django.contrib import auth
            2. 过滤数据
        '''
        # 如果 验证成功返回user对象，否则返回None
        user = auth.authenticate(username=user, password=pwd)

        if user:
            auth.login(request, user)   # session注册login， request.user:当前登录对象,若没有就是个匿名对象

            # return redirect("/index/") # 切勿写死，可以根据获取的值来跳转
            next_url = request.GET.get('next', '/index/') # 如果取不到，跳转到index

            return redirect(next_url)  # 动态的根据参数来配

    return render(request, "login.html") 

@login_required()   # 有了装饰器，就不需要写下面的认证了
def index(request):

    # print("request.user:", request.user)
    # print("username:", request.user.username)
    # print("id:", request.user.id)
    # print("is_anonymous:", request.user.is_anonymous)
    '''
        没有登录的时候，访问index页面的时候，request.user会得到一个匿名用户AnonymousUser
        上述输出如下：
            request.user: AnonymousUser
            username: 
            id: None
            is_anonymous: True
            
        登录之后，访问index得到如下输出：
            request.user: mumu
            username: mumu
            id: 1
            is_anonymous: False
    '''

    # # if request.user.is_anonymous: # 是否是匿名函数
    # if not request.user.is_authenticated:  # 是否通过校验
    #         return redirect("/login/")
    #
    username = request.user.username

    return render(request, "index.html", {"username": username})


def logout(request):

    auth.logout(request)

    return redirect("/login/")

def reg(request):

    if request.method == "POST":
        # 获取user和pwd方便插入数据库
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        # User.objects.create(username=user, password=pwd)  # 这种方式是不对的，插入的是明文，而实际表中需要的是密文
        user = User.objects.create_user(username=user, password=pwd)  # 这种方法会转为密文

        return redirect("/login/")

    return render(request, "reg.html")

@login_required()
def order(request):
    print("order")

    # if not request.user.is_authenticated:
    #
    #     redirect("/login/")    # 可以加装饰器，就不需要这样写了

    return render(request, "order.html")

　　若用户没有登录，则会跳转到django默认的 登录URL '/accounts/login/ ' (这个值可以在settings文件中通过LOGIN_URL进行修改)。并传递  当前访问url的绝对路径 (登陆成功后，会重定向到该路径)。