Files
state-corp-backend/src/apps/user/services.py
Aleksandr Meshchriakov 2259ee1209
All checks were successful
CI/CD Pipeline / Code Quality Checks (push) Successful in 2m59s
CI/CD Pipeline / Run Tests (push) Successful in 5m2s
CI/CD Pipeline / Build and Push Dev Images (push) Successful in 21m9s
CI/CD Pipeline / Deploy Dev via Compose (push) Successful in 54s
feat: add admin user management API
2026-08-05 11:24:49 +02:00

461 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from typing import Any
from apps.core.exceptions import NotFoundError
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.db import transaction
from django.db.models import F, Q
from rest_framework_simplejwt.tokens import RefreshToken
from .models import Profile
User = get_user_model()
class UserService:
"""Сервисный слой для работы с пользователями"""
ROLE_USER = "user"
ROLE_ADMIN = "admin"
ROLE_CHOICES = (
(ROLE_USER, "Пользователь"),
(ROLE_ADMIN, "Администратор"),
)
ROLE_LABELS = dict(ROLE_CHOICES)
@classmethod
def create_user(
cls, *, email: str, username: str, password: str, **extra_fields
) -> User:
"""
Создает нового пользователя
Args:
email: Email пользователя
username: Username пользователя
password: Пароль
**extra_fields: Дополнительные поля
Returns:
User: Созданный пользователь
Raises:
ValidationError: При некорректных данных
"""
with transaction.atomic():
user = User.objects.create_user(
email=email, username=username, password=password, **extra_fields
)
return user
@classmethod
def get_user_by_email(cls, email: str) -> User:
"""Получает пользователя по email
Raises:
NotFoundError: Если пользователь не найден
"""
try:
return User.objects.get(email=email)
except User.DoesNotExist as e:
raise NotFoundError(
message=f"User with email={email} not found",
details={"email": email},
) from e
@classmethod
def get_user_by_email_or_none(cls, email: str) -> User | None:
"""Получает пользователя по email или None"""
try:
return User.objects.get(email=email)
except User.DoesNotExist:
return None
@classmethod
def get_user_by_id(cls, user_id: int) -> User:
"""Получает пользователя по ID
Raises:
NotFoundError: Если пользователь не найден
"""
try:
return User.objects.get(id=user_id)
except User.DoesNotExist as e:
raise NotFoundError(
message=f"User with id={user_id} not found",
details={"user_id": user_id},
) from e
@classmethod
def get_user_by_id_or_none(cls, user_id: int) -> User | None:
"""Получает пользователя по ID или None"""
try:
return User.objects.get(id=user_id)
except User.DoesNotExist:
return None
@classmethod
def get_users_queryset(cls):
"""Базовый queryset для административного управления пользователями."""
return (
User.objects.all()
.select_related("profile")
.prefetch_related("groups")
.order_by("-created_at")
)
@classmethod
def get_filtered_users_queryset(
cls,
*,
search: str = "",
ordering: str = "",
):
"""Фильтрует и сортирует пользователей для административного API."""
queryset = cls.get_users_queryset()
search_term = search.strip()
if search_term:
queryset = queryset.filter(
Q(username__icontains=search_term)
| Q(email__icontains=search_term)
| Q(phone__icontains=search_term)
| Q(profile__first_name__icontains=search_term)
| Q(profile__mid_name__icontains=search_term)
| Q(profile__last_name__icontains=search_term)
).distinct()
ordering_fields = []
ordering_map = {
"id": ("id", False),
"email": ("email", False),
"username": ("username", False),
"phone": ("phone", False),
"is_active": ("is_active", False),
"is_verified": ("is_verified", False),
"created_at": ("created_at", False),
"updated_at": ("updated_at", False),
"first_name": ("profile__first_name", True),
"middle_name": ("profile__mid_name", True),
"last_name": ("profile__last_name", True),
"role": ("is_staff", False),
}
for raw_field in (item.strip() for item in ordering.split(",") if item.strip()):
is_desc = raw_field.startswith("-")
field_name = raw_field[1:] if is_desc else raw_field
mapped_config = ordering_map.get(field_name)
if not mapped_config:
continue
mapped_field, nulls_last = mapped_config
if nulls_last:
ordering_fields.append(
F(mapped_field).desc(nulls_last=True)
if is_desc
else F(mapped_field).asc(nulls_last=True)
)
continue
ordering_fields.append(f"-{mapped_field}" if is_desc else mapped_field)
if ordering_fields:
queryset = queryset.order_by(*ordering_fields, "-created_at")
return queryset
@classmethod
def update_user(cls, user_id: int, **fields) -> User:
"""
Обновляет данные пользователя
Args:
user_id: ID пользователя
**fields: Поля для обновления
Returns:
User: Обновленный пользователь
Raises:
NotFoundError: Если пользователь не найден
"""
user = cls.get_user_by_id(user_id)
for field, value in fields.items():
setattr(user, field, value)
user.save()
return user
@classmethod
@transaction.atomic
def create_managed_user(
cls,
*,
email: str,
username: str,
password: str,
role: str,
first_name: str,
last_name: str,
middle_name: str | None = None,
**extra_fields,
) -> User:
"""Создаёт пользователя администратором и назначает ему роль."""
user = User.objects.create_user(
email=email,
username=username,
password=password,
**extra_fields,
)
cls.assign_role(user, role)
cls._update_or_create_profile(
user=user,
first_name=first_name,
middle_name=middle_name or "",
last_name=last_name,
)
return cls.get_users_queryset().get(id=user.id)
@classmethod
@transaction.atomic
def update_managed_user(cls, user_id: int, **fields) -> User:
"""Обновляет учётные данные, профиль, пароль и роль пользователя."""
user = cls.get_user_by_id(user_id)
role = fields.pop("role", None)
password = fields.pop("password", None)
profile_fields = {
key: fields.pop(key)
for key in ("first_name", "middle_name", "last_name")
if key in fields
}
for field, value in fields.items():
setattr(user, field, value)
if password:
user.set_password(password)
user.save()
if role is not None:
cls.assign_role(user, role)
if profile_fields:
cls._update_or_create_profile(user=user, **profile_fields)
return cls.get_users_queryset().get(id=user.id)
@classmethod
def deactivate_user(cls, user_id: int) -> User:
"""Деактивирует пользователя без удаления записи."""
user = cls.get_user_by_id(user_id)
user.is_active = False
user.save(update_fields=["is_active"])
return user
@classmethod
def activate_user(cls, user_id: int) -> User:
"""Возвращает пользователя в активное состояние."""
user = cls.get_user_by_id(user_id)
user.is_active = True
user.save(update_fields=["is_active"])
return user
@classmethod
def delete_user(cls, user_id: int) -> None:
"""
Удаляет пользователя
Args:
user_id: ID пользователя
Raises:
NotFoundError: Если пользователь не найден
"""
user = cls.get_user_by_id(user_id)
user.delete()
@classmethod
def get_tokens_for_user(cls, user: User) -> dict[str, str]:
"""
Генерирует JWT токены для пользователя
Args:
user: Пользователь
Returns:
Dict[str, str]: refresh и access токены
"""
refresh = RefreshToken.for_user(user)
return {
"refresh": str(refresh),
"access": str(refresh.access_token),
}
@classmethod
def ensure_role_groups(cls) -> dict[str, Group]:
"""Гарантирует наличие системных групп ролей."""
groups: dict[str, Group] = {}
for role, _label in cls.ROLE_CHOICES:
group, _ = Group.objects.get_or_create(name=role)
groups[role] = group
return groups
@classmethod
def get_user_role(cls, user: User) -> str:
"""Возвращает прикладную роль пользователя."""
if user.is_superuser or user.is_staff:
return cls.ROLE_ADMIN
group_names = {group.name for group in user.groups.all()}
if cls.ROLE_ADMIN in group_names:
return cls.ROLE_ADMIN
return cls.ROLE_USER
@classmethod
def get_role_label(cls, role: str) -> str:
"""Возвращает человекочитаемое название роли."""
return cls.ROLE_LABELS.get(role, role)
@classmethod
def get_user_capabilities(cls, user: User) -> dict[str, bool]:
"""Возвращает доступные пользователю административные возможности."""
return {
"can_access_admin_page": cls.get_user_role(user) == cls.ROLE_ADMIN,
}
@classmethod
def assign_role(cls, user: User, role: str) -> User:
"""Назначает роль через auth.Group и согласует staff-флаги."""
if role not in cls.ROLE_LABELS:
raise ValueError(f"Unsupported role: {role}")
groups = cls.ensure_role_groups()
current_role_groups = list(user.groups.filter(name__in=groups))
if current_role_groups:
user.groups.remove(*current_role_groups)
user.groups.add(groups[role])
user.is_staff = role == cls.ROLE_ADMIN
if role == cls.ROLE_USER:
user.is_superuser = False
user.save(update_fields=["is_staff", "is_superuser"])
return user
@classmethod
def _update_or_create_profile(
cls,
*,
user: User,
first_name: str | None = None,
middle_name: str | None = None,
last_name: str | None = None,
) -> Profile:
profile, _ = Profile.objects.get_or_create(user=user)
if first_name is not None:
profile.first_name = first_name
if middle_name is not None:
profile.mid_name = middle_name
if last_name is not None:
profile.last_name = last_name
profile.save()
return profile
@classmethod
def verify_email(cls, user_id: int) -> User:
"""
Подтверждает email пользователя
Args:
user_id: ID пользователя
Returns:
User: Обновленный пользователь
Raises:
NotFoundError: Если пользователь не найден
"""
user = cls.get_user_by_id(user_id)
user.is_verified = True
user.save()
return user
class ProfileService:
"""Сервисный слой для работы с профилями"""
@classmethod
def get_profile_by_user_id(cls, user_id: int) -> Profile:
"""Получает профиль по ID пользователя
Raises:
NotFoundError: Если профиль не найден
"""
try:
return Profile.objects.select_related("user").get(user_id=user_id)
except Profile.DoesNotExist as e:
raise NotFoundError(
message=f"Profile for user_id={user_id} not found",
details={"user_id": user_id},
) from e
@classmethod
def get_profile_by_user_id_or_none(cls, user_id: int) -> Profile | None:
"""Получает профиль по ID пользователя или None"""
try:
return Profile.objects.select_related("user").get(user_id=user_id)
except Profile.DoesNotExist:
return None
@classmethod
def update_profile(cls, user_id: int, **fields) -> Profile:
"""
Обновляет профиль пользователя
Args:
user_id: ID пользователя
**fields: Поля для обновления
Returns:
Profile: Обновленный профиль
Raises:
NotFoundError: Если профиль не найден
"""
profile = cls.get_profile_by_user_id(user_id)
for field, value in fields.items():
setattr(profile, field, value)
profile.save()
return profile
@classmethod
def get_full_profile_data(cls, user_id: int) -> dict[str, Any]:
"""
Получает полные данные пользователя и профиля
Args:
user_id: ID пользователя
Returns:
Dict: Полные данные
Raises:
NotFoundError: Если профиль не найден
"""
profile = cls.get_profile_by_user_id(user_id)
user = profile.user
return {
"id": user.id,
"email": user.email,
"username": user.username,
"is_verified": user.is_verified,
"phone": user.phone,
"first_name": profile.first_name,
"mid_name": profile.mid_name,
"last_name": profile.last_name,
"full_name": profile.full_name,
"bio": profile.bio,
"avatar": profile.avatar.url if profile.avatar else None,
"date_of_birth": profile.date_of_birth,
"created_at": user.created_at,
"updated_at": user.updated_at,
}