Django 重写用户模型的实现

from django.contrib.auth import get_user_model

User = get_user_model()

from django.conf import settings
from django.db import models

class Article(models.Model):
  author = models.ForeignKey(settings.AUTH_USER_MODEL)

class MyUser(AbstractBaseUser):
  identifier = models.CharField(max_length=40, unique=True)
  ...
  USERNAME_FIELD = 'identifier'

class MyUser(AbstractBaseUser):
  ...
  date_of_birth = models.DateField()
  height = models.FloatField()
  ...
  REQUIRED_FIELDS = ['date_of_birth', 'height']

def create_user(self, email, date_of_birth, password=None):
  # create user here
  ...

def create_superuser(self, email, date_of_birth, password):
  # create superuser here
  ...

class PermissionsMixin(models.Model):
  """
  A mixin class that adds the fields and methods necessary to support
  Django's Group and Permission model using the ModelBackend.
  """
  is_superuser = models.BooleanField(_('superuser status'), default=False,
    help_text=_('Designates that this user has all permissions without '
          'explicitly assigning them.'))
  groups = models.ManyToManyField(Group, verbose_name=_('groups'),
    blank=True, help_text=_('The groups this user belongs to. A user will '
                'get all permissions granted to each of '
                'their groups.'),
    related_name="user_set", related_query_name="user")
  user_permissions = models.ManyToManyField(Permission,
    verbose_name=_('user permissions'), blank=True,
    help_text=_('Specific permissions for this user.'),
    related_name="user_set", related_query_name="user")

  class Meta:
    abstract = True

  def get_group_permissions(self, obj=None):
    """
    Returns a list of permission strings that this user has through their
    groups. This method queries all available auth backends. If an object
    is passed in, only permissions matching this object are returned.
    """
    permissions = set()
    for backend in auth.get_backends():
      if hasattr(backend, "get_group_permissions"):
        permissions.update(backend.get_group_permissions(self, obj))
    return permissions

  def get_all_permissions(self, obj=None):
    return _user_get_all_permissions(self, obj)

  def has_perm(self, perm, obj=None):
    """
    Returns True if the user has the specified permission. This method
    queries all available auth backends, but returns immediately if any
    backend returns True. Thus, a user who has permission from a single
    auth backend is assumed to have permission in general. If an object is
    provided, permissions for this specific object are checked.
    """

    # Active superusers have all permissions.
    if self.is_active and self.is_superuser:
      return True

    # Otherwise we need to check the backends.
    return _user_has_perm(self, perm, obj)

  def has_perms(self, perm_list, obj=None):
    """
    Returns True if the user has each of the specified permissions. If
    object is passed, it checks if the user has all required perms for this
    object.
    """
    for perm in perm_list:
      if not self.has_perm(perm, obj):
        return False
    return True

  def has_module_perms(self, app_label):
    """
    Returns True if the user has any permissions in the given app label.
    Uses pretty much the same logic as has_perm, above.
    """
    # Active superusers have all permissions.
    if self.is_active and self.is_superuser:
      return True

    return _user_has_module_perms(self, app_label)

class AbstractUser(AbstractBaseUser, PermissionsMixin):
  """
  An abstract base class implementing a fully featured User model with
  admin-compliant permissions.
  Username, password and email are required. Other fields are optional.
  """
  username = models.CharField(_('username'), max_length=30, unique=True,
    help_text=_('Required. 30 characters or fewer. Letters, digits and '
          '@/./+/-/_ only.'),
    validators=[
      validators.RegexValidator(r'^[\w.@+-]+$',
                   _('Enter a valid username. '
                    'This value may contain only letters, numbers '
                    'and @/./+/-/_ characters.'), 'invalid'),
    ],
    error_messages={
      'unique': _("A user with that username already exists."),
    })
  first_name = models.CharField(_('first name'), max_length=30, blank=True)
  last_name = models.CharField(_('last name'), max_length=30, blank=True)
  email = models.EmailField(_('email address'), blank=True)
  is_staff = models.BooleanField(_('staff status'), default=False,
    help_text=_('Designates whether the user can log into this admin '
          'site.'))
  is_active = models.BooleanField(_('active'), default=True,
    help_text=_('Designates whether this user should be treated as '
          'active. Unselect this instead of deleting accounts.'))
  date_joined = models.DateTimeField(_('date joined'), default=timezone.now)

  objects = UserManager()

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

  class Meta:
    verbose_name = _('user')
    verbose_name_plural = _('users')
    abstract = True

  def get_full_name(self):
    """
    Returns the first_name plus the last_name, with a space in between.
    """
    full_name = '%s %s' % (self.first_name, self.last_name)
    return full_name.strip()

  def get_short_name(self):
    "Returns the short name for the user."
    return self.first_name

  def email_user(self, subject, message, from_email=None, **kwargs):
    """
    Sends an email to this User.
    """
    send_mail(subject, message, from_email, [self.email], **kwargs)


class User(AbstractUser):
  """
  Users within the Django authentication system are represented by this
  model.
  Username, password and email are required. Other fields are optional.
  """
  class Meta(AbstractUser.Meta):
    swappable = 'AUTH_USER_MODEL'

# models.py

from django.db import models
from django.contrib.auth.models import (
  BaseUserManager, AbstractBaseUser
)


class MyUserManager(BaseUserManager):
  def create_user(self, email, date_of_birth, password=None):
    """
    Creates and saves a User with the given email, date of
    birth and password.
    """
    if not email:
      raise ValueError('Users must have an email address')

    user = self.model(
      email=self.normalize_email(email),
      date_of_birth=date_of_birth,
    )

    user.set_password(password)
    user.save(using=self._db)
    return user

  def create_superuser(self, email, date_of_birth, password):
    """
    Creates and saves a superuser with the given email, date of
    birth and password.
    """
    user = self.create_user(email,
      password=password,
      date_of_birth=date_of_birth
    )
    user.is_admin = True
    user.save(using=self._db)
    return user


class MyUser(AbstractBaseUser):
  email = models.EmailField(
    verbose_name='email address',
    max_length=255,
    unique=True,
  )
  date_of_birth = models.DateField()
  is_active = models.BooleanField(default=True)
  is_admin = models.BooleanField(default=False)

  objects = MyUserManager()

  USERNAME_FIELD = 'email'
  REQUIRED_FIELDS = ['date_of_birth']

  def get_full_name(self):
    # The user is identified by their email address
    return self.email

  def get_short_name(self):
    # The user is identified by their email address
    return self.email

  def __str__(self):       # __unicode__ on Python 2
    return self.email

  def has_perm(self, perm, obj=None):
    "Does the user have a specific permission"
    # Simplest possible answer: Yes, always
    return True

  def has_module_perms(self, app_label):
    "Does the user have permissions to view the app `app_label`"
    # Simplest possible answer: Yes, always
    return True

  @property
  def is_staff(self):
    "Is the user a member of staff"
    # Simplest possible answer: All admins are staff
    return self.is_admin

# admin.py
from django import forms
from django.contrib import admin
from django.contrib.auth.models import Group
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField

from customauth.models import MyUser


class UserCreationForm(forms.ModelForm):
  """A form for creating new users. Includes all the required
  fields, plus a repeated password."""
  password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
  password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)

  class Meta:
    model = MyUser
    fields = ('email', 'date_of_birth')

  def clean_password2(self):
    # Check that the two password entries match
    password1 = self.cleaned_data.get("password1")
    password2 = self.cleaned_data.get("password2")
    if password1 and password2 and password1 != password2:
      raise forms.ValidationError("Passwords don't match")
    return password2

  def save(self, commit=True):
    # Save the provided password in hashed format
    user = super(UserCreationForm, self).save(commit=False)
    user.set_password(self.cleaned_data["password1"])
    if commit:
      user.save()
    return user


class UserChangeForm(forms.ModelForm):
  """A form for updating users. Includes all the fields on
  the user, but replaces the password field with admin's
  password hash display field.
  """
  password = ReadOnlyPasswordHashField()

  class Meta:
    model = MyUser
    fields = ('email', 'password', 'date_of_birth', 'is_active', 'is_admin')

  def clean_password(self):
    # Regardless of what the user provides, return the initial value.
    # This is done here, rather than on the field, because the
    # field does not have access to the initial value
    return self.initial["password"]


class MyUserAdmin(UserAdmin):
  # The forms to add and change user instances
  form = UserChangeForm
  add_form = UserCreationForm

  # The fields to be used in displaying the User model.
  # These override the definitions on the base UserAdmin
  # that reference specific fields on auth.User.
  list_display = ('email', 'date_of_birth', 'is_admin')
  list_filter = ('is_admin',)
  fieldsets = (
    (None, {'fields': ('email', 'password')}),
    ('Personal info', {'fields': ('date_of_birth',)}),
    ('Permissions', {'fields': ('is_admin',)}),
  )
  # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
  # overrides get_fieldsets to use this attribute when creating a user.
  add_fieldsets = (
    (None, {
      'classes': ('wide',),
      'fields': ('email', 'date_of_birth', 'password1', 'password2')}
    ),
  )
  search_fields = ('email',)
  ordering = ('email',)
  filter_horizontal = ()

# Now register the new UserAdmin...
admin.site.register(MyUser, MyUserAdmin)
# ... and, since we're not using Django's built-in permissions,
# unregister the Group model from admin.
admin.site.unregister(Group)

AUTH_USER_MODEL = 'customauth.MyUser'