18_django的用户模型和扩展django的用户模型

Posted 2020-11-13 nichengshishaonian

目录

• User 模型
  • 字段：
  • User模型的基本用法

User 模型

User模型是这个框架的核心部分。他的完整的路径是在django.contrib.auth.models.User。以下对这个User模型做一个简单的了解：

字段：

内置的User模型拥有以下的字段：
1. username: 用户名。150个字符以内。可以包含数字和英文字符，以及_/@/+/.和-字符。不能为空，且必须唯一。
2. email: 邮箱。 可以为空。
3. password: 密码。经过哈希过后的密码.
4. groups: 分组。多对多的组。一个分组可以拥有多个用户，groups这个字段是跟Group的一种多对多的关系.
5. user_permissions: 权限。一个用户可以拥有多个权限，一个权限可以被多个用户所有用。和Permission属于一种多对多的关系。
6. is_staff: 是否可以进入到admin的站点。代表是否是员工。
7. is_active: 是否是可用的。对于一些想要删除账号的数据，我们设置值为False就可以了，而不是真正的从数据库中删除.
8. is_superuser: 是否是超级管理员。如果是超级管理员，那么拥有整个网站的所有权限.
9. last_login: 上次登录的时间
10. date_joined: 注册时间，即账号创建的时间

User模型的基本用法

创建用户：

通过 create_user方法可以快速的创建用户。这个方法必须传递 username, password和email可传可不传 示例代码如下。

from django.contrib.auth.models import User
user = User.objects.create_user(username='long', email='[e-mail]', password='111111')
# 创建完成后，还可以进行修改某个字段, 如
user.password = 'yanyan_love'
user.save()

创建超级用户：

创建超级用户有两种方式。第一种是使用代码的方式。用代码创建超级用户跟创建普通用户非常的类似，只不过是使用 create_superuser, 并且必须要传递username, password, email。示例代码如下：

from django.contrib.auth.models import User
user = User.objects.create_superuser(username='long', email='[e-mail]', password='111111')

也可以通过命令行的方式。命令为： python manage.py create_superuser, 然后根据提示输入用户名和邮箱和密码

我的创建用户代码

# User 模型的基本用法
# 1. 创建用户
from django.contrib.auth.models import User
class CreateUser(View):
    def get(self, request):
        return render(request, 'blog/create_user.html')

    def post(self, request):
        username = request.POST.get('username')
        password = request.POST.get('password')
        email = request.POST.get('email')
        print(username, password, email)
        if username:
            # 1. 创建普通用户
            user = User.objects.create_user(username=username)
            # 创建完成后，还可以对某个字段进行修改
            user.password = '5201314'  # 这样子修改的密码是不加密的
            user.email = '[e-mail]'
            user.save()

        # if username and email and password:
            # 2. 创建超级用户，代码实现
            # super_user = User.objects.create_superuser(username=username, email=email, password=password)
            return HttpResponse('success')
        return HttpResponse('fail')

修改密码：

因为密码是需要经过加密后才能存储进去的，所以如果想要修改密码，不能直接修改 password 字段。而需要调用 set_password 来达到修改密码的目的。 示例代码如下：

# 修改密码
from django.contrib.auth.models import User
def set_password_user(request):
    user = User.objects.get(pk=1)
    user.set_password('new_password')  # 把新的密码放在括号中
    user.save()  # 记得保存
    return HttpResponse('success')

登录验证

Django的验证系统已经帮我们实现了登录验证的功能。通过 django.contrib.auth.authenticate即可实现。这个方法只能通过 username 和 password 来进行验证。示例代码如下:

# 登录验证
from django.contrib.auth import authenticate
def login(request):
    # user = authenticate(username='yan', password='adminadmin')
    user = authenticate(request, username='yan', password='adminadmin')
    print(user)
    # 如果验证通过了，就会返回一个 user 对象
    if user:
        # 验证通过后的代码
        print('登录成功: %s' % user.username)
    else:
        # 验证失败后的代码
        print('登录失败 用户名或密码错误')
    return HttpResponse('login')

扩展用户模型：

Django 内置的 User 模型虽然已经足够强大了，但是有时候还是不能满足我们的需求。比如在验证用户登录的时候，他用的是用户名作为验证，而我们有时候需要通过手机号码或者邮箱来进行验证。还有比如我们想要增加一些新的的字段。那么这时候我们就需要扩展用户模型了。扩展用户模型有多种方式。这里我们一一讨论下。

1. 设置Proxy模型

如果你对 Django提供的字段，以及验证的方法都比较满意，没有什么需要修改的，只是需要在他原有的基础之上增加一些操作的方法，那么建议使用这种方式。示例代码如下：

from django.db import models
from django.contrib.auth.models import User
class Person(User):
    class Meta:
        proxy = True
    def get_blacklist(self):
        return self.objects.filter(is_active=False) # is_active 是否激活，判断该用户是否可用,=False即不可用

# models.py
from django.contrib.auth.models import User
# User  的代理模型
class Person(User):
    # 这种Field字段不可以有，有的话，数据库映射的时候会报错, 需要注意
    # telephone = models.CharField(max_length=11)
    class Meta:
        proxy = True
    @classmethod
    def get_blacklist(cls):
        """获取所有的黑名单"""
        return cls.objects.filter(is_active=False)
    # 不止可以定义这些，还可以定义一些其它的

# 使用 views.py
# 扩展用户模型
from .models import Person
def proxy_view(request):
    blacklist = Person.get_blacklist()  # 获取所有没有激活的用户， 即黑名单用户
    for person in blacklist:
        print(person.username)
    return HttpResponse('proxy 扩展用户模型')

# 如果没有未激活的用户， 可以设置用户为未激活
def set_active(reqeust):
    """设置黑名单用户"""
    user = User.objects.get(pk=1)
    user.is_active = 0
    user.save()
    return HttpResponse('设置黑名单成功: %s' % user.username)

在以上，我们定义了一个Person 对象，让他继承自 User, 并且在 Meta元类中设置了 proxy=True,说明这个Person 只是 User 的一个代理模型。他并不会影响原来 User模型在数据库中表的结构，以后如果你想方便的获取所有黑名单的人，那么你就可以通过 Person.get_blacklist() 就可以获取到。并且 User.objects.all()和Person.objects.all其实是等价的,加为他们都是从User这个模型中获取所有的数据
(注意： 如果一个模型是代理模型， 那么就不能在这个模型中添加新的Field)

2. 一对一外键

如果你对用户验证方法 authenticate 没有其他要求，就是使用 username 和 password 即可完成。但是想要在原来模型的基础上添加新的字段，那么可以使用 一对一外键 的方式。示例代码如下:

# models.py
# 一对一外键 扩展用户模型
from django.contrib.auth.models import User
from django.db import models
from django.dispatch import receiver
from django.db.models.signals import post_save

class UserExtension(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='extension')
    telephone = models.CharField(max_length=11, verbose_name='电话号码')
    birthday = models.DateField(null=True, blank=True, verbose_name='出生日期')
    school = models.CharField(max_length=20, verbose_name='学校')

@receiver(post_save, sender=User)
def create_user_extension(sender, instance, created, **kwargs):
    if created:
        UserExtension.objects.create(user=instance)
    else:
        instance.extension.save()

# 使用 views.py
# 一对一扩展 User 模型
def one_to_one_user(request):
    user = User.objects.create_superuser(username='yy', password='5021314yanyan', email='[e-mail]')
    user.extension.telephone = '13037200197'
    user.extension.school = '明瑞'
    user.save()
    return HttpResponse('一对一扩展User用户模型')

# 自定义字段验证登录
# 自定义验证登录
def my_authenticate(telephone, password):
    user = User.objects.filter(extension__telephone=telephone).first()
    print(user)
    if user:
        is_correct = user.check_password(password)
        print(is_correct)
        if is_correct:
            return user
        else:
            return None
    else:
        return None

def one_login(request):
    """使用自定义的验证 my_authenticate 来进行登录验证"""
    telephone = request.GET.get('telephone')
    password = request.GET.get('password')
    user = my_authenticate(telephone, password)
    print(user)
    if user:
        print('验证成功: %s' % user.username)
    else:
        print('验证失败')
    return HttpResponse('自定义验证字段登录')

以上定义了一个 UserExtension的模型，并且让他和 User 模型进行了一对一的绑定,以后我们新增的字段，就添加到 UserExtension 上。 并且还写了一个接受保存模型的信号处理方法，只要是 User调用了save() 方法，那么就会创建一个UserExtension 和 User 进行绑定。

3. 继承自 AbstractUser:

对于 authenticate 不满意，并且不想要修改原来的 User对象上的一些字段，但是想要增加一些字段，那么这时候可以直接继承自django.contrib.auth.models.AbstractUser,其实这个类也是 django.contrib.auth.models.User 的父类。比如我们想要在原来 User 模型的基础之上添加一个 telephone 和 school 字段。 示例代码如下:
(注意： 第一次映射数据库的时候就要创建好)

# models.py
# 继承自 AbstractUser

from django.contrib.auth.models import BaseUserManager
class UserManager(BaseUserManager):
    use_in_migrations = True
    def _create_user(self, telephone, username, password, **extra_fields):
        if not telephone:
            raise ValueError('必须要传递手机号码')
        if not password:
            raise ValueError('必须要传递手机号码')
        user = self.model(telephone=telephone, *extra_fields)
        user.set_password(password)
        user.save()
        return user
    def create_user(self, telephone, username, password, **kwargs):
        kwargs['is_superuser'] = False
        return self._create_user(telephone=telephone, username=username, password=password, **kwargs)
    def create_superuser(self, telephone, username, password, **kwargs):
        kwargs['is_superuser'] = True
        return self._create_user(telephone=telephone, username=username, password=password, **kwargs)

# 继承自 AbstractUser
from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
    telephone = models.CharField(max_length=11, unique=True, verbose_name='电话号码')
    school = models.CharField(max_length=100)

    # 指定 telephone 作为 USERNAME_FIELD, 以后使用 authenticate
    # 函数验证的时候，就可以根据 telephone 来验证
    # 而不是原来的 username
    USERNAME_FIELD = 'telephone'
    REQUIRED_FIELDS = []

    objects = UserManager()

# settings.py
# 并且在 settins.py 中添加这样一句话：
AUTH_USER_MODEL = 'blog.User'  # blog 是 app 名字， User 是blog.models 下面新建的一个类，即上面那个

from django.contrib.auth.models import AbstractUser, UserManager as _UserManager

class UserManager(_UserManager):
    """"""
    # def create_superuser(self, username, mobile, password, email=None, **extra_fields):
    #     super().create_superuser(username=username, mobile=mobile, password=password, email=None, **extra_fields)

    def create_superuser(self, username, password, email=None, **extra_fields):
        super().create_superuser(username=username, password=password, email=email, **extra_fields)

class Users(AbstractUser):
    """
    add mobile  、 email_active fields to Django uswers models
    """
    mobile = models.CharField(max_length=11, unique=True, verbose_name='手机号', help_text='手机号', error_messages={
        'unique': '此手机号已经被注册过了',
    })
    email_active = models.BooleanField(default=False, verbose_name='邮箱验证状态')

    REQUIRED_FIELDS = ['mobile']
    objects = UserManager()   # objects 管理器 UserManager

    class Meta:
        db_table = 'tb_users'
        verbose_name = '用户'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.username

4. 继承自 AbstractBaseUser 模型：

如果你想修改默认的验证方式，并且对于原来 User模型上的一些字段不想要，那么可以自定义一个模型，然后继承自 AbstractBaseUser ，再添加你想要的字段。这种方式会比较麻烦，最好是确定自己对 Django 比较才推荐使用。

完整例子：

from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from shortuuidfield import ShortUUIDField


# 用户管理器
class UserManager(BaseUserManager):
    """
    自定义用户管理器
    """
    def _create_user(self, telephone, username, password, **kwargs):
        if not telephone:
            raise ValueError('请传入手机号码')
        if not username:
            raise ValueError('请传入用户名')
        if not password:
            raise ValueError('请传入密码')

        user = self.model(telephone=telephone, username=username, **kwargs)
        user.set_password(password)
        return user

    def create_user(self, telephone, username, password, **kwargs):
        """创建普通用户"""
        kwargs['is_superuser'] = False
        return self._create_user(telephone, username, password, **kwargs)

    def create_superuser(self, telephone, username, password, **kwargs):
        """创建超级用户"""
        kwargs['is_superuser'] = True
        return self._create_user(telephone, username, password, **kwargs)


# 定义用户模型
class User(AbstractBaseUser):
    # 我们不使用默认的自增长的主键
    # uuid/shortuuid
    # shortuuidfield: pip install django-shortuuidfield
    uid = ShortUUIDField(primary_key=True, verbose_name='以uuid作为主键，不使用默认的主键')
    telephone = models.CharField(max_length=11, unique=True, verbose_name='手机号', help_text='手机号')
    # password = models.CharField(max_length=200, verbose_name='密码', help_text='密码')
    email = models.EmailField(unique=True, verbose_name='邮箱', help_text='邮箱')
    username = models.CharField(max_length=100, unique=True, verbose_name='用户名', help_text='用户名')
    is_active = models.BooleanField(default=True, verbose_name='是否是可用的, 默认是可用的，即默认该用户就是激活了的', help_text='该用户是否是可用的')
    is_staff = models.BooleanField(default=False, verbose_name='是否是员工, 即是否能够登录到后台', help_text='是否是员工')
    join_time = models.DateTimeField(auto_now_add=True, verbose_name='用户加入时间')

    USERNAME_FIELD = 'telephone'
    REQUIRED_FIELDS = ['username']
    EMAIL_FIELD = 'email'

    # 用户管理器
    objects = UserManager()

    def get_full_name(self):
        return self.username

    def get_short_name(self):
        return self.username

    class Meta:
        db_table = 'cms_user'
        verbose_name = '用户'
        verbose_name_plural = verbose_name