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='1987719593@qq.com', 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='1987719593@qq.com', 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 = 'haolong@163.com'
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='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('自定义验证字段登录')
以上定义了一个 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