Django笔记：内置的用户系统

Django中有一个内置的用户系统，包含了用户模型的定义、用户的分组、登录验证、权限的定义和管理等，可以帮助我们非常快速地创建用户模型以及实现用户管理相关的一系列功能。当然，也可以不采用内置的用户管理系统，自己重新定义用户模型和对用户的管理操作，具体使用哪种方式还是需要看个人习惯和实际工作来定。

一、用户模型

1. 默认的用户模型

默认的用户模型，即User模型类，这是Django内置用户系统的核心，源码位置在django.contrib.auth.models.User。
User模型的主要字段如下：

• username：用户名。不能为空，且必须唯一。
• first_name：姓名的first_name。可以为空。
• last_name：姓名的last_name。可以为空。
• email：邮箱。可以为空。
• password：密码。经过哈希过后的密码。
• groups：分组。一个用户可以属于多个分组，一个分组也可以拥有多个用户。和Group模型是多对多的关系。
• user_permissions：权限。一个用户可以拥有多个权限，一个权限也可以被多个用户使用。和Permission模型是多对多的关系。
• is_staff：是否是员工。表示是否可以进入到admin（管理员）的站点。
• is_active：是否可用。对于一些不再使用或者暂时不使用的账号数据，可以将这个值设置为False即可。
• is_superuser：是否是超级管理员。通常超级管理员拥有整个网站的所有权限。
• last_login：上次登录的时间。
• date_joined：账号创建的时间。

2. 常用基础操作

这里介绍一些常用的基础操作，只是作为参考，深入了解后可以根据自身需要来使用。

创建用户
可以通过create_user方法快速创建一个普通用户，通过create_superuser方法快速创建一个超级用户，创建超级用户还可以通过终端命令行的方式python manage.py createsuperuser。

# 导入内置的User模型
from django.contrib.auth.models import User
from django.http import HttpResponse


def index(request):
    # create_user创建一个普通用户
    user = User.objects.create_user(username='zhangsan', email='zhangsan@qq.com', password='123456')
    # create_superuser创建一个超级用户
    super_user = User.objects.create_superuser(username='lisi', email='lisi@qq.com', password='123456')
    return HttpResponse('index')

修改密码
在Django内置的用户系统中有一个针对密码的密码哈希系统，密码是经过加密后存储在数据库中的，修改用户的密码时不能直接使用password=xxx重新赋值的方式来修改，需要使用特定的方法set_password来重置密码。因为涉及到密码的加密和解密，所以其他关于密码的操作大多也是需要使用特定的方法来进行操作的。

from django.contrib.auth.models import User
# 随意获取一个用户，并给他重置密码
user = User.objects.get(pk=1)
user.set_password('654321')
user.save()

密码验证
可以使用authenticate函数进密码验证，会同时验证用户名和密码，验证成功后会返回一个User对象。

from django.contrib.auth import authenticate
from django.http import HttpResponse


def index(request):
    username = 'zhangsan'
    password = '123456'
    user = authenticate(request, username=username, password=password)
    if user:
        return HttpResponse('验证成功！')
    else:
        return HttpResponse('用户名或密码错误！')

3. 扩展User模型

默认的User模型肯定是不能满足我们的实际需要的，比如我们一般不用first_name和last_name两个字段来定义一个人的姓名，再比如我们通常使用邮箱或者手机号作为用户的唯一标识，而不是使用username，所以我们就需要根据实际情况来扩展或自定义User模型。扩展或自定义User模型主要有以下四种方法，可以根据实际需要来使用。

1）proxy代理扩展
这种方式需要定义一个代理类，通过操作代理类以达到扩展User模型的目的。代理类的定义方式Django已经为我们规定好了：代理类继承User模型，并在内部类Meta中指定proxy为True即可，随后可以根据自身需要定义额外的属性和方法了。
但是需要注意，Django内置的这种代理是不能在代理类中添加新的字段的，如telephone = models.CharField(max_length=11)，但是可以添加其他普通的属性和方法。所以使用代理的方式缺点也比较明显，就是扩展性较差。

from django.contrib.auth.models import User


# 代理类需要继承User
class Person(User):
    # 在内部类Meta中指定proxy=True
    class Meta:
        proxy = True

    # 添加额外的方法
    @classmethod
    def get_blacklist(cls):
        return cls.objects.filter(is_active=False)

2）一对一关系外键扩展
这种方式是将User模型当作一个外键，但是需要定义为一对一的关系，同时还需要定义一个信号去监听User模型的save方法，以保证扩展的类和User模型在修改上的同步。
这种方式相比于代理的方式，优势在于可以添加一些额外的字段了。

from django.db import models
from django.contrib.auth.models import User
from django.dispatch import receiver
from django.db.models.signals import post_save


class UserExtension(models.Model):
    # 创建一个新的模型，将User映射为一对一关系的外键
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='userextension')
    # 添加一些额外的字段
    telephone = models.CharField(max_length=11)
    school = models.CharField(max_length=100)


# 定义一个信号，监听User的save操作
@receiver(post_save, sender=User)
def handler_user_extension(sender, instance, created, **kwargs):
    """
    :param sender: 发送者，即User模型
    :param instance: User实例
    :param created: 是否是第一次创建User实例
    :param kwargs: 其他参数定义
    """
    # 如果是第一次创建User实例，则同时创建UserExtension实例，
    # 并将User实例绑定到UserExtension实例上
    if created:
        UserExtension.objects.create(user=instance)
    # 否则，在User实例save后，UserExtension实例也需要同步save
    else:
        instance.extension.save()

3）继承AbstractUser重新定义User模型
其实User模型类本身也是直接继承自AbstractUser，所以自定义一个继承自AbstractUser的子类就相当于是定义另一个新的User类，但是由源码可知，继承AbstractUser其实是一种较“浅”自定义方式，因为自定义的新User类还是拥有原User类的所有字段，只不过是用新的User类代替了原User类的使用，当然，在新的User类中也是可以添加额外的字段以及其他方法的。
settings配置：自定义的User类还需要在settings.py中配置AUTH_USER_MODEL，该配置项的值为新User类的位置，但是需要注意，该User类必须定义在APP的models.py中，比如User类定义在名为front的APP下的models.py中，那么配置时就应配置为AUTH_USER_MODEL='front.User'，Django就会在对应APP的models.py中寻找User类。并且配置了该配置项后，可以通过from django.contrib.auth import get_user_model来获取配置的User模型。
objects对象重新定义：通常重新定义User模型后，也需要重新定义它的objects对象，因为原来的objects对象还是使用的是原User模型中的字段，自然就不能再用了。重新定义objects对象只需要定义一个继承自from django.contrib.auth.models import BaseUserManager的子类，然后将新的User类中的objects属性指定为新的objects类即可。
注：不同于之前的两种方式，代理和一对一关系外键的方式更注重“扩展”的概念，而使用继承AbstractUser的方式，虽然不是完全的自定义，但也是偏向于“重新定义”的概念。

from django.contrib.auth.models import AbstractUser


# 新定义一个User类，添加一个额外的字段
class User(AbstractUser):
    telephone = models.CharField(max_length=11)

    # 默认该属性为username，重新指定后from django.contrib.auth import authenticate就会使用该字段替代username来进行验证了
    USERNAME_FIELD = 'telephone'
    
    # 重新指定objects对象
    objects = UserManager()

from django.contrib.auth.models import BaseUserManager


# 原User模型默认的objects对象也是继承自BaseUserManager，
# 所以可以自定义一个新的objects子类来完成一些特殊的需要
class UserManager(BaseUserManager):
    def _create_user(self, telephone, username, password, **kwargs):
        if not telephone:
            raise ValueError('必须传递手机号码！')
        if not password:
            raise ValueError('必须传递密码！')
        user = self.model(telephone=telephone, username=username, **kwargs)
        user.set_password(password)
        user.save()
        return user

    # 重写create_user，默认是需要传入username属性，这里修改为传入telephone
    def create_user(self, telephone, username, password, **kwargs):
        # 设置为非超级管理员
        kwargs['is_superuser'] = False
        return self._create_user(telephone=telephone, username=username, password=password, **kwargs)

    # 重写create_superuser方法
    def create_superuser(self, telephone, username, password, **kwargs):
        # 设置为超级管理员
        kwargs['is_superuser'] = True
        return self._create_user(telephone=telephone, username=username, password=password, **kwargs)

4）继承AbstractBaseUser重新定义User模型
这种方式就相当于创建一个全新的User模型，舍弃了原User模型中的大多字段，只保留password、last_login等基础的字段，这种方式同样也需要在settings.py中配置AUTH_USER_MODEL，以及重新定义objects对象。
通常除了继承AbstractBaseUser类外，还需要继承PermissionsMixin类，这个类是用于权限管理的，原User也是继承的这两个基础类。如果不是有特殊要求，User类的定义应该尽量和原User类保持一致，以免Django内置的方法在使用新的User模型时发生不必要的错误。

from django.contrib.auth.base_user import AbstractBaseUser
from django.contrib.auth.models import PermissionsMixin


# 继承两个基础类：AbstractBaseUser, PermissionsMixin
class User(AbstractBaseUser, PermissionsMixin):
    # 根据需要定义自己的字段
    telephone = models.CharField(max_length=11, unique=True)
    email = models.CharField(max_length=100, unique=True)
    username = models.CharField(max_length=100)
    # is_active是必须定义的，Django中许多内置的方法都会用到这个字段
    is_active = models.BooleanField(default=True)
    
    USERNAME_FIELD = 'telephone'
    # 这个属性是用于指定在终端使用命令create_superuser时提示用户需要填写哪些字段，如果是空列表，则默认只有username和password两个字段
    REQUIRED_FIELDS = []
    
    # 也是需要重新定义一个新的objects对象
    objects = UserManager()
    
    # 定义方法时，应该尽量模仿Django内置的User模型的方法，以避免Django在调用某些方法时使用了自定义User类没有的方法
    def get_full_name(self):
        return self.username
    
    def get_short_name(self):
        return self.username

二、登录验证

1. 登录和注销

可以使用内置的from django.contrib.auth import login函数进行登录，此函数会自动将用户信息添加到session当中。同样的，注销也可以使用内置的from django.contrib.auth import logout函数，此函数会自动将用户信息从session中清除。

from django.shortcuts import render, redirect, reverse
from django.contrib.auth import login
from .forms import LoginForm


def my_login(request):
    # 返回登录页面
    if request.method == 'GET':
        return render(request, 'login.html')
    else:
        # 获取并验证登录信息
        form = LoginForm(request.POST)
        if form.is_valid():
            telephone = form.cleaned_data.get('telephone')
            password = form.cleaned_data.get('password')
            remember = form.cleaned_data.get('remember')
            user = authenticate(request, username=telephone, password=password)
            # 如果该用户在数据库中存在并且有效
            if user and user.is_active:
                # 内置login函数会将用户信息添加到session中
                login(request, user)
                return HttpResponse('登录成功！')
            else:
                return HttpResponse('用户名或密码错误！')
        else:
            print(form.errors)
            return redirect(reverse('login'))

2. 登录验证

当某个url需要登录之后才能访问时，可以使用内置的from django.contrib.auth.decorators import login_required装饰器来检查用户是否登录。

from django.contrib.auth.decorators import login_required


# 如果访问该视图时没有登录，则会自动跳转到登录页面
# Django内置的登录url为`/accounts/login/`，可以通过参数login_url重新指定登录的url
@login_required(login_url='/login/')
def profile(request):
    return HttpResponse('这是一个需要登录的页面！')

三、权限管理

Django中内置的权限定义是针对表或模型级别的，比如表Article具有增加和查看两种权限操作，那么一个用户对于该表中的数据最多就只能拥有这两种权限，相当于表中的一个权限就对应了对该表中数据的一种操作，用户拥有对应的权限就可以执行对应操作，反之则不能操作。
Django存储权限信息的表在auth_permission表中，可以查看默认的权限信息及其他新添加的权限信息。但是需要注意，内置的权限管理系统并没有限定具体的操作，只是创建了对应的权限标识，开发者需要根据权限标识自己完成相应的判断和操作。

1. 添加权限

如果想要给某个模型或者表添加额外的权限，有两种方式可以做到，一种是直接在定义模型的时候指定具体的权限，另一种方式就是动态添加权限。注意，这两种方式添加的权限都是针对表级别的，即该表中的所有数据都会有相同的权限。

class Article(models.Model):
    ...
    
    class Meta:
        # 元组的第一个元素是权限名称，第二个是权限的描述
        permissions = [
            ('view_article', '查看文章的权限'),
        ]

from django.contrib.auth.models import Permission, ContentType
from .models import Article


def edit_permission(request):
    content_type = ContentType.objects.get_for_model(Article)
    permission = Permission.objects.create(codename='edit_article', name='编辑文章的权限', content_type=content_type)
    return HttpResponse('添加权限成功！')

2. 常用权限操作

示例代码如下：

def operate_permission(request):
    # 给某个用户添加所有的关于“文章”表的权限
    user = User.objects.first()
    content_type = ContentType.objects.get_for_model(Article)
    permissions = Permission.objects.filter(content_type=content_type)

    # 以列表形式添加一个或多个权限
    user.user_permissions.set(permissions)

    # 清除所有权限
    user.user_permissions.clear()

    # 以参数形式添加一个或多个权限
    user.user_permissions.add(permissions[0], permissions[1])
    # user.user_permissions.add(*permissions)

    # 以参数形式移除一个或多个权限
    user.user_permissions.remove(permissions[0], permissions[1])
    # user.user_permissions.remove(*permissions)

    # 判断用户是否拥有某个权限，参数是一个字符串app_name.codename的格式
    # 另一个方法has_perms则需要传入一个权限列表，表示判断用户是否拥有多个权限
    if user.has_perm('front.view_article'):
        print('拥有view_article权限！')
    else:
        print('没有view_article权限！')
        
    # 获取用户的所有权限
    print(user.get_all_permissions())

    return HttpResponse('操作权限成功！')

3. 权限验证

执行某个视图时可能要求用户需要具有某个特殊的权限，对于这种权限的验证，也可以使用内置的装饰器from django.contrib.auth.decorators import permission_required来进行验证。

from django.contrib.auth.decorators import login_required, permission_required

# 用户只有登录之后，并且拥有add_article权限才能进入视图，如果需要验证多个权限，则传入一个列表即可，权限字符串格式为app_name.codename
# 如果没有登录或者权限验证不通过，则会重定向到默认的登录url，也可以通过login_url重新指定登录的url
# 如果登录成功，但是没有指定的权限，又不想重定向到登录页面，可以指定raise_exception为True，此时没有权限就会重定向到一个403错误页面了
@permission_required('front.add_article', login_url='/login/', raise_exception=True)
def add_article(request):
    ...
    return HttpResponse('添加文章成功！')

4. HTML模板中进行权限验证

Django默认在settings.TEMPLATES.OPTIONS.context_processors中添加django.contrib.auth.context_processors.auth上下文处理器，所以我们可以在模板中直接使用perms来判断用户是否拥有某个权限。

{% if perms.front.add_article %}
    <a href="#">添加文章</a>
{% endif %}

四、分组管理

分组可以使用Django内置的分组模型from django.contrib.auth.models import Group，这个模型中除了外键就只有id和name两个普通字段。常用分组操作示例代码如下：

def operate_group(request):
    content_type = ContentType.objects.get_for_model(Article)
    permissions = Permission.objects.filter(content_type=content_type)

    # 创建一个分组，并在分组中添加若干权限
    # group.permissions另外还有add/remove/clear等方法
    group = Group.objects.create(name='文章作者')
    group.permissions.set(permissions)
    group.save()

    # 给用户添加分组
    group = Group.objects.filter(name='文章作者').first()
    user = User.objects.first()
    user.groups.add(group)
    user.save()

    # 获取用户的所有分组的权限
    print(user.get_group_permissions())
    
    # 获取用户的所有分组
    print(user.groups)

    return HttpResponse('操作分组成功！')

注：本文为学习笔记，发现错误欢迎指出。