1. django.contrib.auth.models.User
  • 内置的User模型拥有以下的字段：
    • username: 用户名。150个字符以内。可以包含数字和英文字符，以及_/@/+/.和-`字符。不能为空，且必须唯一。
    • email: 邮箱。 可以为空。
    • password: 密码。经过哈希过后的密码.
    • groups: 分组。多对多的组。一个分组可以拥有多个用户，groups这个字段是跟Group的一种多对多的关系.
    • user_permissions: 权限。一个用户可以拥有多个权限，一个权限可以被多个用户所有用。和Permission属于一种多对多的关系。
    • is_staff: 是否可以进入到admin的站点。代表是否是员工。
    • is_active: 是否是可用的。对于一些想要删除账号的数据，我们设置值为False就可以了，而不是真正的从数据库中删除.
    • is_superuser: 是否是超级管理员。如果是超级管理员，那么拥有整个网站的所有权限.
    • last_login: 上次登录的时间
    • date_joined: 注册时间，即账号创建的时间
  • User模型的基本用法
    • 创建用户> 通过 create_user方法可以快速的创建用户。这个方法必须传递 username, password和email可传可不传 示例代码如下。
      1. from django.contrib.auth.models import User
      2. user = User.objects.create_user(username='long', email='1987719593@qq.com', password='111111')
      3. # 创建完成后，还可以进行修改某个字段, 如
      4. user.password = 'yanyan_love'
      5. user.save()

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

    1. from django.contrib.auth.models import User
    2. user = User.objects.create_superuser(username='long', email='1987719593@qq.com', password='111111')

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

    我的创建用户代码

    ```python

    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.    # 1. 创建普通用户
    2.    user = User.objects.create_user(username="123",password="12345")
    3.    # 创建完成后，还可以对某个字段进行修改
    4.    user.password = '5201314'  # 这样子修改的密码是不加密的
    5.    user.email = 'haolong@163.com'
    6.    user.save()

    if username and email and password:

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

    return HttpResponse(‘fail’) ```

  • 修改密码> 因为密码是需要经过加密后才能存储进去的，所以如果想要修改密码，不能直接修改 password 字段。而需要调用 set_password 来达到修改密码的目的。 示例代码如下：
    1. # 修改密码
    2. from django.contrib.auth.models import User
    3. def set_password_user(request):
    4. user = User.objects.get(pk=1)
    5. user.set_password('new_password')  # 把新的密码放在括号中
    6. user.save()  # 记得保存
    7. return HttpResponse('success')
  • 登录验证> Django的验证系统已经帮我们实现了登录验证的功能。通过 django.contrib.auth.authenticate即可实现。这个方法只能通过 username 和 password 来进行验证。示例代码如下:
    1. # 登录验证
    2. from django.contrib.auth import authenticate
    3. def login(request):
    4. # user = authenticate(username='yan', password='adminadmin')
    5. user = authenticate(request, username='yan', password='adminadmin')
    6. print(user)
    7. # 如果验证通过了，就会返回一个 user 对象
    8. if user:
    9.    # 验证通过后的代码
    10.    print('登录成功: %s' % user.username)
    11. else:
    12.    # 验证失败后的代码
    13.    print('登录失败 用户名或密码错误')
    14. return HttpResponse('login')
  • 扩展用户模型> 简叙 Django 内置的 User 模型虽然已经足够强大了，但是有时候还是不能满足我们的需求。比如在验证用户登录的时候，他用的是用户名作为验证，而我们有时候需要通过手机号码或者邮箱来进行验证。还有比如我们想要增加一些新的的字段。那么这时候我们就需要扩展用户模型了。扩展用户模型有多种方式。这里我们一一讨论下。
  • 继承自 AbstractUser:(当需求和admin无法匹配时而且自己对权限系统较为满意时推荐使用)> 对于 authenticate 不满意，并且不想要修改原来的 User对象上的一些字段，但是想要增加一些字段，那么这时候可以直接继承自django.contrib.auth.models.AbstractUser,其实这个类也是 django.contrib.auth.models.User 的父类。
  1.   - **定义用户模型数据**> ```python

from django.contrib.auth.models import AbstractUser from django.db import models

class UserModels(AbstractUser): avatar = models.URLField(max_length=500, verbose_name=”头像img地址”, help_text=”头像img地址”, null=True, blank=True) slogan = models.CharField(max_length=30, verbose_name=”用户简介”, help_text=”用户简介”, null=False, blank=False) domain = models.URLField(max_length=500, verbose_name=”文章地址”, help_text=”文章地址”, null=True, blank=True) notice = models.CharField(max_length=30, verbose_name=”用户对外名片”, help_text=”用户对外名片”, null=False, blank=False) hiders_backImg = models.URLField(max_length=500, verbose_name=”用户自定义显示图片”, help_text=”用户自定义显示图片”, null=True, blank=True) desc = models.TextField(max_length=3000, verbose_name=”用户自我评价”, help_text=”用户自我评价”, null=False, blank=False)

  1. class Meta:
  2.     db_table = "Users_Table"
  3.     verbose_name = "用户管理"
  4.     ordering = ["-id"]
  5.     verbose_name_plural = verbose_name
  3.       - 对模型进行反向注册> 在`settings.py`中添加以下代码
  4. > 参数说明：
  5. > `AUTH_USER_MODE`：进行反向注册的操作的关键
  6. > `userApp`：自定义`app`名称
  7. > `UserModels`：自定`models`名称
  8. > ```python
  9. AUTH_USER_MODEL = 'userApp.UserModels'
  1.   - 在后台中进行显示> ```python

from django.contrib import admin

from apps.userApp.models import UserModels

@admin.register(UserModels) class UserAdmin(admin.ModelAdmin): pass

  3.       - 操作结果![Dingtalk_20210112214949.jpg](https://cdn.nlark.com/yuque/0/2021/jpeg/620912/1610462144843-302ff1de-a63b-48c3-a7b9-2ed6c8cec41e.jpeg#align=left&display=inline&height=646&margin=%5Bobject%20Object%5D&name=Dingtalk_20210112214949.jpg&originHeight=646&originWidth=1334&size=53068&status=done&style=none&width=1334)
  4.    - **设置`Proxy`模型**（需求与django的admin的后台逻辑较为符合时推荐使用）
  5. > 如果你对 `Django`提供的字段，以及验证的方法都比较满意，没有什么需要修改的，只是需要在他原有的基础之上增加一些操作的方法，那么建议使用这种方式。示例代码如下：
  6. > ```python
  7. from django.db import models
  8. from django.contrib.auth.models import User
  9. class Person(User):
  10.     class Meta:
  11.         proxy = True
  12.     def get_blacklist(self):
  13.         return self.objects.filter(is_active=False) # is_active 是否激活，判断该用户是否可用,=False即不可用
  14. # models.py
  15. from django.contrib.auth.models import User
  16. # User  的代理模型
  17. class Person(User):
  18.     # 这种Field字段不可以有，有的话，数据库映射的时候会报错, 需要注意
  19.     # telephone = models.CharField(max_length=11)
  20.     class Meta:
  21.         proxy = True
  22.     @classmethod
  23.     def get_blacklist(cls):
  24.         """获取所有的黑名单"""
  25.         return cls.objects.filter(is_active=False)
  26.     # 不止可以定义这些，还可以定义一些其它的
  28. # 使用 views.py
  29. # 扩展用户模型
  30. from .models import Person
  31. def proxy_view(request):
  32.     blacklist = Person.get_blacklist()  # 获取所有没有激活的用户， 即黑名单用户
  33.     for person in blacklist:
  34.         print(person.username)
  35.     return HttpResponse('proxy 扩展用户模型')
  37. # 如果没有未激活的用户， 可以设置用户为未激活
  38. def set_active(reqeust):
  39.     """设置黑名单用户"""
  40.     user = User.objects.get(pk=1)
  41.     user.is_active = 0
  42.     user.save()
  43.     return HttpResponse('设置黑名单成功: %s' % user.username)

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

  • 一对一外键（因人而异吧，与第一种不同在于自己写权限）

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

    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=’1599962587@qq.com’) 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(‘自定义验证字段登录’)

  1. > 以上定义了一个 `UserExtension`的模型，并且让他和 `User` 模型进行了`一对一`的绑定,以后我们新增的字段，就添加到 `UserExtension` 上。 并且还写了一个接受保存模型的信号处理方法，只要是 `User`调用了`save()` 方法，那么就会创建一个`UserExtension` 和 `User` 进行绑定。
  3.    - **继承自 AbstractBaseUser 模型**（同上一批注相同）
  4. > 如果你想修改默认的验证方式，并且对于原来 `User`模型上的一些字段不想要，那么可以自定义一个模型，然后继承自 `AbstractBaseUser` ，再添加你想要的字段。这种方式会比较麻烦，最好是确定自己对 Django 比较才推荐使用。
  5. > 完整例子：
  6. > ```python
  7. from django.db import models
  8. from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
  9. from shortuuidfield import ShortUUIDField
  12. # 用户管理器
  13. class UserManager(BaseUserManager):
  14.     """
  15.     自定义用户管理器
  16.     """
  17.     def _create_user(self, telephone, username, password, **kwargs):
  18.         if not telephone:
  19.             raise ValueError('请传入手机号码')
  20.         if not username:
  21.             raise ValueError('请传入用户名')
  22.         if not password:
  23.             raise ValueError('请传入密码')
  25.         user = self.model(telephone=telephone, username=username, **kwargs)
  26.         user.set_password(password)
  27.         return user
  29.     def create_user(self, telephone, username, password, **kwargs):
  30.         """创建普通用户"""
  31.         kwargs['is_superuser'] = False
  32.         return self._create_user(telephone, username, password, **kwargs)
  34.     def create_superuser(self, telephone, username, password, **kwargs):
  35.         """创建超级用户"""
  36.         kwargs['is_superuser'] = True
  37.         return self._create_user(telephone, username, password, **kwargs)
  40. # 定义用户模型
  41. class User(AbstractBaseUser):
  42.     # 我们不使用默认的自增长的主键
  43.     # uuid/shortuuid
  44.     # shortuuidfield: pip install django-shortuuidfield
  45.     uid = ShortUUIDField(primary_key=True, verbose_name='以uuid作为主键，不使用默认的主键')
  46.     telephone = models.CharField(max_length=11, unique=True, verbose_name='手机号', help_text='手机号')
  47.     # password = models.CharField(max_length=200, verbose_name='密码', help_text='密码')
  48.     email = models.EmailField(unique=True, verbose_name='邮箱', help_text='邮箱')
  49.     username = models.CharField(max_length=100, unique=True, verbose_name='用户名', help_text='用户名')
  50.     is_active = models.BooleanField(default=True, verbose_name='是否是可用的, 默认是可用的，即默认该用户就是激活了的', help_text='该用户是否是可用的')
  51.     is_staff = models.BooleanField(default=False, verbose_name='是否是员工, 即是否能够登录到后台', help_text='是否是员工')
  52.     join_time = models.DateTimeField(auto_now_add=True, verbose_name='用户加入时间')
  54.     USERNAME_FIELD = 'telephone'
  55.     REQUIRED_FIELDS = ['username']
  56.     EMAIL_FIELD = 'email'
  58.     # 用户管理器
  59.     objects = UserManager()
  61.     def get_full_name(self):
  62.         return self.username
  64.     def get_short_name(self):
  65.         return self.username
  67.     class Meta:
  68.         db_table = 'cms_user'
  69.         verbose_name = '用户'
  70.         verbose_name_plural = verbose_name

结语：

当我们遇到权限问题时，我们可以自己写的最好（个人推荐） 但是当我们无法或自己写的权限出现的问题无法解决时，可以尝试去改它的业务逻辑（不太推荐，因为后期可能会发生一些需求变出现不必要问题）