Django: Как Использовать Пользовательскую Модель (User Model) для Аутентификации и Управления Пользователями?

python manage.py startapp users

# users/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models
from django.utils.translation import gettext_lazy as _

class CustomUser(AbstractUser):
    """Расширенная модель пользователя.

    Наследует все поля от AbstractUser, но позволяет добавлять новые.
    """
    email = models.EmailField(_('email address'), unique=True) # Делаем email уникальным и основным для логина
    phone_number = models.CharField(_('phone number'), max_length=20, blank=True, null=True)
    date_of_birth = models.DateField(_('date of birth'), blank=True, null=True)

    # Указываем email как поле для аутентификации
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['username'] # Список полей, запрашиваемых при создании суперпользователя

    def __str__(self) -> str:
        return self.email

# users/models.py
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin
from django.db import models
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from typing import Optional

class CustomUserManager(BaseUserManager):
    """Менеджер для кастомной модели пользователя.

    Определяет методы для создания обычных пользователей и суперпользователей.
    """
    def _create_user(self, email: str, password: Optional[str], **extra_fields) -> 'CustomUser':
        """Создает и сохраняет пользователя с указанным email и паролем."""
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password) # Хеширование пароля
        user.save(using=self._db)
        return user

    def create_user(self, email: str, password: Optional[str] = None, **extra_fields) -> 'CustomUser':
        extra_fields.setdefault('is_staff', False)
        extra_fields.setdefault('is_superuser', False)
        return self._create_user(email, password, **extra_fields)

    def create_superuser(self, email: str, password: Optional[str] = None, **extra_fields) -> 'CustomUser':
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

        return self._create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    """Полностью кастомная модель пользователя.

    Использует email как основной идентификатор.
    """
    email = models.EmailField(_('email address'), unique=True)
    first_name = models.CharField(_('first name'), max_length=150, blank=True)
    last_name = models.CharField(_('last name'), max_length=150, 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 = CustomUserManager() # Подключение кастомного менеджера

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = [] # При использовании email как USERNAME_FIELD, email автоматически обязателен

    def __str__(self) -> str:
        return self.email

    # Методы has_perm и has_module_perms наследуются от PermissionsMixin

python manage.py makemigrations users
python manage.py migrate

# settings.py
AUTH_USER_MODEL = 'users.CustomUser' # Замените users.CustomUser на актуальный путь

# users/forms.py
from django import forms
from django.contrib.auth import get_user_model
from django.contrib.auth.forms import UserCreationForm, UserChangeForm

# Получаем модель пользователя, определенную в settings.AUTH_USER_MODEL
UserModel = get_user_model()

class CustomUserCreationForm(UserCreationForm):
    """Форма для создания нового пользователя.

    Добавляет или изменяет поля по сравнению со стандартной формой.
    """
    class Meta(UserCreationForm.Meta):
        model = UserModel
        # Указываем поля, которые будут в форме регистрации
        # Если используем email как USERNAME_FIELD, 'username' можно убрать
        fields = ('email', 'first_name', 'last_name') # Пример

class CustomUserChangeForm(UserChangeForm):
    """Форма для изменения данных пользователя в админке.

    Исключает поле пароля, т.к. оно управляется отдельно.
    """
    class Meta(UserChangeForm.Meta):
        model = UserModel
        # Поля, доступные для редактирования в админке
        fields = ('email', 'first_name', 'last_name', 'is_active', 'is_staff', 'groups', 'user_permissions') # Пример

# users/admin.py
from django.contrib import admin
from django.contrib.auth import get_user_model
from django.contrib.auth.admin import UserAdmin
from .forms import CustomUserCreationForm, CustomUserChangeForm # Импорт кастомных форм

UserModel = get_user_model()

@admin.register(UserModel)
class CustomUserAdmin(UserAdmin):
    """Кастомизация отображения модели пользователя в админке."""
    add_form = CustomUserCreationForm # Форма для создания пользователя
    form = CustomUserChangeForm # Форма для редактирования пользователя
    model = UserModel
    list_display = ['email', 'username', 'first_name', 'last_name', 'is_staff', 'is_active'] # Отображаемые колонки в списке
    list_filter = ['is_staff', 'is_active', 'groups'] # Фильтры
    search_fields = ['email', 'username', 'first_name', 'last_name'] # Поля для поиска
    ordering = ['email'] # Сортировка по умолчанию

    # Настройка полей, отображаемых на странице редактирования/создания
    # Fieldsets наследуются от UserAdmin, но их нужно адаптировать под вашу модель
    # Особенно важно указать правильное USERNAME_FIELD
    fieldsets = (
        (None, {'fields': ('email', 'password')}), # Используем email вместо username
        ('Personal info', {'fields': ('first_name', 'last_name', 'date_of_birth', 'phone_number')}),
        ('Permissions', {'fields': ('is_active', 'is_staff', 'is_superuser', 'groups', 'user_permissions')}),
        ('Important dates', {'fields': ('last_login', 'date_joined')}),
    )
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            # Указываем поля для формы создания, включая обязательные (REQUIRED_FIELDS)
            'fields': ('email', 'password', 'password2', 'first_name', 'last_name', 'username'), 
        }),
    )

from django.contrib.auth import get_user_model

UserModel = get_user_model()

def get_active_users_emails() -> list[str]:
    """Возвращает список email активных пользователей."""
    return list(UserModel.objects.filter(is_active=True).values_list('email', flat=True))

def update_user_phone(user_id: int, new_phone: str) -> bool:
    """Обновляет номер телефона пользователя."""
    try:
        user = UserModel.objects.get(pk=user_id)
        user.phone_number = new_phone
        user.save(update_fields=['phone_number'])
        return True
    except UserModel.DoesNotExist:
        return False

# Получение текущего пользователя в представлении (view)
# request.user будет экземпляром вашей CustomUser модели
# user = request.user
# print(user.phone_number)

# users/models.py
from django.db import models
from django.conf import settings # Импортируем настройки для ссылки на AUTH_USER_MODEL

class Profile(models.Model):
    """Модель профиля пользователя, связанная с основной моделью."""
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL, 
        on_delete=models.CASCADE, 
        primary_key=True, # Делаем связь первичным ключом для эффективности
        related_name='profile' # Позволяет обращаться user.profile
    )
    bio = models.TextField(blank=True)
    avatar = models.ImageField(upload_to='avatars/', null=True, blank=True)
    website = models.URLField(blank=True)

    def __str__(self) -> str:
        return f"Profile for {self.user.email}"

# Сигнал для автоматического создания профиля при создании пользователя
from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

# В модели, где нужны кастомные права
class MarketingCampaign(models.Model):
    name = models.CharField(max_length=200)
    # ... другие поля

    class Meta:
        permissions = [
            ("can_launch_campaign", "Can launch marketing campaign"),
            ("can_view_report", "Can view campaign report"),
        ]

# Проверка прав в коде
# if request.user.has_perm('app_label.can_launch_campaign'):
#     # Логика запуска кампании