[TOC]
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