feat: add admin user management API
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

This commit is contained in:
2026-08-05 11:24:49 +02:00
parent 2b9ecc2681
commit 2259ee1209
5 changed files with 796 additions and 21 deletions

View File

@@ -2,7 +2,9 @@ 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
@@ -13,6 +15,14 @@ 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
@@ -84,6 +94,74 @@ class UserService:
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:
"""
@@ -107,6 +185,79 @@ class UserService:
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:
"""
@@ -138,6 +289,74 @@ class UserService:
"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:
"""