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

目录

  • 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='[email protected]', 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='[email protected]', 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 = '[email protected]'
            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即可实现。这个方法只能通过 usernamepassword 来进行验证。示例代码如下:

# 登录验证
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 没有其他要求,就是使用 usernamepassword 即可完成。但是想要在原来模型的基础上添加新的字段,那么可以使用 一对一外键 的方式。示例代码如下:

# 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='[email protected]')
    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() 方法,那么就会创建一个UserExtensionUser 进行绑定。

3. 继承自 AbstractUser:

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

# 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

原文地址:https://www.cnblogs.com/nichengshishaonian/p/11523555.html

时间: 2024-11-10 05:03:39

18_django的用户模型和扩展django的用户模型的相关文章

analysed of J-SON/XML processing model Extend to java design model (J-SON/XML处理模型分析 扩展到Java设计模型 )

一.JSON和XML 1.JSON JSON(JavaScript Object Notation)一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性.可在不同平台之间进行数据交换.JSON采用兼容性很高的.完全独立于语言文本格式,同时也具备类似于C语言的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)体系的行为.这些特性使JSON成为理想的数据交换语言. 2.XML 扩展标记语言 (Extensible Markup Language

【Python-Django定义用户模型类】Python-Django定义用户模型类详解!!!

定义用户模型类 1. Django默认用户认证系统 Django自带用户认证系统 它处理用户账号.组.权限以及基于cookie的用户会话. Django认证系统位置 django.contrib.auth包含认证框架的核心和默认的模型. django.contrib.contenttypes是Django内容类型系统,它允许权限与你创建的模型关联. Django认证系统同时处理认证和授权 认证:验证一个用户是否它声称的那个人,可用于账号登录. 授权:授权决定一个通过了认证的用户被允许做什么. D

Django 重写用户模型

目录 Django 重写用户模型 修改配置文件,覆盖默认的User模型 引用User模型 指定自定义的用户模型 Django 期望你自定义的 User model 满足一些最低要求: 下面为一些AbstractBaseUser的子类必须定义的关键的字段和方法: 下面为一些AbstractBaseUser的子类可以使用的方法: 为你的User模型自定义一个管理器 扩展Django默认的User 自定义用户与内置身份验证表单 自定义用户和django.contrib.admin 自定义用户和权限 如

Python学习---Django的request扩展【获取用户设备信息】

关于Django的request扩展[获取用户设备信息] settings.py INSTALLED_APPS = [ ... 'app01', # 注册app ] STATICFILES_DIRS = (os.path.join(BASE_DIR, "statics"),) # 现添加的配置,这里是元组,注意逗号 TEMPLATES = [ ... 'DIRS': [os.path.join(BASE_DIR, 'templates')], ] urls.py from django

Window上python开发--4.Django的用户登录模块User

在搭建网站和web的应用程序时,用户的登录和管理是几乎是每个网站都必备的.今天主要从一个实例了解以下django本身自带的user模块.本文并不对user进行扩展. 主要使用原生的模块. 1.User模块基础: 在使用user 之前先import到自己的iew中.相当与我们自己写好的models.只不过这个是系统提供的models. from django.contrib.auth.models import User # 导入user模块 1.1User对象属性 User 对象属性:usern

Django自定义用户认证系统Customizing authentication

扩展已有的用户模型Extending the existing User model 有两种方法来扩展默认的User Model而不用重写自己的模型.如果你不需要改变存储在数据库中的字段,而只是需要改变Model的行为,您可以创建一个基于User的代理Model.允许的行为包括默认的ordering,custom managers, 或者 custom model methods. 如果你想存储与User有关的信息,可以使用一个OneToOneField字段关联到一个存储额外信息的Model.这

Django--分页器(paginator)、Django的用户认证、Django的FORM表单

分页器(paginator) >>> from django.core.paginator import Paginator >>> objects = ['john', 'paul', 'george', 'ringo'] >>> p = Paginator(objects, 2) >>> p.count #数据总数 4 >>> p.num_pages #总页数 2 >>> type(p.page

python Django教程 之 模型(数据库)、自定义Field、数据表更改、QuerySet API

python  Django教程  之 模型(数据库).自定义Field.数据表更改.QuerySet API 一.Django 模型(数据库) Django 模型是与数据库相关的,与数据库相关的代码一般写在 models.py 中,Django 支持 sqlite3, MySQL, PostgreSQL等数据库,只需要在settings.py中配置即可,不用更改models.py中的代码,丰富的API极大的方便了使用. 本节的代码:(Django 1.6, Python 2.7 测试环境) 大

Django Authentication 用户认证系统

一. Django的认证系统 Django自带一个用户认证系统,用于处理用户账户.群组.许可和基于cookie的用户会话. 1.1 概览 Django的认证系统包含了身份验证和权限管理两部分.简单地说,身份验证用于核实某个用户是否是合法用户,权限管理则是决定一个合法用户具有哪些权限.这里,"身份验证"这个词同时代指上面两部分的含义. 系统主要包括: 用户 许可 组 可配置的密码哈希系统 用于用户登录或者限制访问的表单和视图工具 可插拔的后端 类似下面的问题,请使用第三方包: 密码强度检