Files
state-corp-backend/src/apps/user/serializers.py
2026-09-28 14:00:04 +02:00

488 lines
16 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 __future__ import annotations
from typing import Any
from django.contrib.auth import get_user_model
from rest_framework import serializers
from rest_framework.validators import UniqueValidator
from .models import Profile
from .services import UserService
User = get_user_model()
class UserRegistrationSerializer(serializers.ModelSerializer):
"""Сериализатор для регистрации пользователя"""
email = serializers.EmailField(
validators=[UniqueValidator(queryset=User.objects.all())],
help_text="Email пользователя (уникальный)",
)
password = serializers.CharField(
write_only=True, min_length=8, help_text="Пароль (минимум 8 символов)"
)
password_confirm = serializers.CharField(
write_only=True, min_length=8, help_text="Подтверждение пароля"
)
class Meta:
model = User
fields = ("email", "username", "password", "password_confirm", "phone")
extra_kwargs = {
"username": {
"validators": [UniqueValidator(queryset=User.objects.all())],
"help_text": "Username пользователя (уникальный)",
}
}
def validate(self, attrs):
if attrs["password"] != attrs["password_confirm"]:
raise serializers.ValidationError("Пароли не совпадают")
return attrs
def create(self, validated_data):
validated_data.pop("password_confirm")
password = validated_data.pop("password")
user = User.objects.create_user(**validated_data)
user.set_password(password)
user.save()
return user
class UserProfileSerializer(serializers.ModelSerializer):
"""Сериализатор для профиля пользователя"""
full_name = serializers.ReadOnlyField(help_text="Полное имя")
avatar = serializers.ImageField(required=False, allow_null=True)
class Meta:
model = Profile
fields = (
"id",
"first_name",
"mid_name",
"last_name",
"full_name",
"bio",
"avatar",
"date_of_birth",
)
read_only_fields = ("id",)
class UserSerializer(serializers.ModelSerializer):
"""Сериализатор для пользователя"""
profile = UserProfileSerializer(read_only=True)
class Meta:
model = User
fields = (
"id",
"email",
"username",
"phone",
"is_verified",
"profile",
"created_at",
"updated_at",
)
read_only_fields = ("id", "is_verified", "created_at", "updated_at")
extra_kwargs = {
"email": {"required": True, "allow_null": False, "allow_blank": False},
}
class CurrentUserProfileSerializer(serializers.ModelSerializer):
"""Профиль текущего пользователя в контракте `/users/me/`."""
middle_name = serializers.SerializerMethodField()
full_name = serializers.ReadOnlyField()
class Meta:
model = Profile
fields = (
"first_name",
"middle_name",
"last_name",
"full_name",
)
@staticmethod
def get_middle_name(obj: Profile) -> str:
return obj.mid_name or ""
class CurrentUserCapabilitiesSerializer(serializers.Serializer):
"""Возможности пользователя для UI-контрактов."""
can_access_admin_page = serializers.BooleanField()
class CurrentUserSerializer(serializers.ModelSerializer):
"""Расширенный сериализатор текущего пользователя."""
profile = CurrentUserProfileSerializer(read_only=True)
role = serializers.SerializerMethodField()
role_label = serializers.SerializerMethodField()
capabilities = serializers.SerializerMethodField()
@staticmethod
def get_role(obj) -> str:
return UserService.get_user_role(obj)
def get_role_label(self, obj) -> str:
return UserService.get_role_label(self.get_role(obj))
@staticmethod
def get_capabilities(obj) -> dict[str, bool]:
return UserService.get_user_capabilities(obj)
class Meta:
model = User
fields = (
"id",
"username",
"email",
"phone",
"is_active",
"role",
"role_label",
"capabilities",
"profile",
)
class UserManagementSerializer(serializers.Serializer):
"""Serializer for users listed in admin management endpoint."""
id = serializers.IntegerField(read_only=True)
username = serializers.CharField(read_only=True)
email = serializers.EmailField(read_only=True, allow_null=True)
phone = serializers.CharField(read_only=True, allow_null=True)
is_active = serializers.BooleanField(read_only=True)
is_verified = serializers.BooleanField(read_only=True)
role = serializers.SerializerMethodField()
role_label = serializers.SerializerMethodField()
capabilities = serializers.SerializerMethodField()
profile = CurrentUserProfileSerializer(read_only=True)
first_name = serializers.SerializerMethodField()
middle_name = serializers.SerializerMethodField()
last_name = serializers.SerializerMethodField()
progress_message = serializers.SerializerMethodField()
result = serializers.SerializerMethodField()
error = serializers.SerializerMethodField()
started_at = serializers.SerializerMethodField()
completed_at = serializers.SerializerMethodField()
duration = serializers.SerializerMethodField()
is_successful = serializers.SerializerMethodField()
@staticmethod
def _get_profile_value(profile: Profile | None, field_name: str) -> str:
if profile is None:
return ""
value = getattr(profile, field_name, "")
return value or ""
def get_first_name(self, obj: User) -> str:
return self._get_profile_value(getattr(obj, "profile", None), "first_name")
def get_middle_name(self, obj: User) -> str:
return self._get_profile_value(getattr(obj, "profile", None), "mid_name")
def get_last_name(self, obj: User) -> str:
return self._get_profile_value(getattr(obj, "profile", None), "last_name")
@staticmethod
def get_role(obj: User) -> str:
return UserService.get_user_role(obj)
def get_role_label(self, obj: User) -> str:
return UserService.get_role_label(self.get_role(obj))
@staticmethod
def get_capabilities(obj: User) -> dict[str, bool]:
return UserService.get_user_capabilities(obj)
@staticmethod
def _get_latest_job(obj: User) -> Any | None:
return getattr(obj, "latest_job", None)
def get_progress_message(self, obj: User) -> str | None:
job = self._get_latest_job(obj)
if job is None:
return None
return job.progress_message or None
def get_result(self, obj: User):
job = self._get_latest_job(obj)
if job is None:
return None
return job.result
def get_error(self, obj: User) -> str | None:
job = self._get_latest_job(obj)
if job is None:
return None
return job.error or None
def get_started_at(self, obj: User):
job = self._get_latest_job(obj)
if job is None:
return None
return job.started_at
def get_completed_at(self, obj: User):
job = self._get_latest_job(obj)
if job is None:
return None
return job.completed_at
def get_duration(self, obj: User) -> float | None:
job = self._get_latest_job(obj)
if job is None:
return None
return job.duration
def get_is_successful(self, obj: User) -> bool | None:
job = self._get_latest_job(obj)
if job is None:
return None
return job.is_successful
class AdminUserListResponseSerializer(serializers.Serializer):
"""Пагинированный ответ списка пользователей для административного UI."""
count = serializers.IntegerField(read_only=True)
next = serializers.URLField(read_only=True, allow_null=True)
previous = serializers.URLField(read_only=True, allow_null=True)
results = UserManagementSerializer(many=True, read_only=True)
class ManagedUserSerializer(serializers.ModelSerializer):
"""Короткий ответ мутаций административного управления пользователями."""
role = serializers.SerializerMethodField()
role_label = serializers.SerializerMethodField()
class Meta:
model = User
fields = (
"id",
"username",
"email",
"phone",
"role",
"role_label",
"is_active",
)
read_only_fields = fields
@staticmethod
def get_role(obj: User) -> str:
return UserService.get_user_role(obj)
def get_role_label(self, obj: User) -> str:
return UserService.get_role_label(self.get_role(obj))
class AdminUserCreateSerializer(serializers.ModelSerializer):
"""Входные данные для создания пользователя администратором."""
password = serializers.CharField(
write_only=True,
min_length=8,
help_text="Пароль (минимум 8 символов)",
)
role = serializers.ChoiceField(
choices=UserService.ROLE_CHOICES,
default=UserService.ROLE_USER,
help_text="Прикладная роль пользователя",
)
first_name = serializers.CharField(max_length=50, allow_blank=False)
middle_name = serializers.CharField(
max_length=50,
required=False,
allow_blank=True,
)
last_name = serializers.CharField(max_length=50, allow_blank=False)
class Meta:
model = User
fields = (
"email",
"username",
"phone",
"password",
"role",
"is_active",
"is_verified",
"first_name",
"middle_name",
"last_name",
)
extra_kwargs = {
"email": {
"required": True,
"allow_null": False,
"allow_blank": False,
"validators": [UniqueValidator(queryset=User.objects.all())],
},
"username": {
"validators": [UniqueValidator(queryset=User.objects.all())],
},
}
class AdminUserUpdateSerializer(serializers.ModelSerializer):
"""Входные данные частичного обновления пользователя администратором."""
password = serializers.CharField(
write_only=True,
required=False,
min_length=8,
help_text="Новый пароль (опционально)",
)
role = serializers.ChoiceField(
choices=UserService.ROLE_CHOICES,
required=False,
help_text="Прикладная роль пользователя",
)
first_name = serializers.CharField(
max_length=50,
required=False,
allow_blank=True,
)
middle_name = serializers.CharField(
max_length=50,
required=False,
allow_blank=True,
)
last_name = serializers.CharField(
max_length=50,
required=False,
allow_blank=True,
)
class Meta:
model = User
fields = (
"email",
"username",
"phone",
"password",
"role",
"is_active",
"is_verified",
"first_name",
"middle_name",
"last_name",
)
extra_kwargs = {
"email": {"required": True, "allow_null": False, "allow_blank": False},
}
def validate(self, attrs):
profile_fields = {"first_name", "middle_name", "last_name"}
if not any(field in attrs for field in profile_fields):
return attrs
profile = getattr(self.instance, "profile", None) if self.instance else None
first_name = attrs.get(
"first_name",
profile.first_name if profile is not None else None,
)
last_name = attrs.get(
"last_name",
profile.last_name if profile is not None else None,
)
errors = {}
if not str(first_name or "").strip():
errors["first_name"] = "Обязательное поле."
if not str(last_name or "").strip():
errors["last_name"] = "Обязательное поле."
if errors:
raise serializers.ValidationError(errors)
return attrs
class UserUpdateSerializer(serializers.ModelSerializer):
"""Сериализатор для обновления данных пользователя"""
class Meta:
model = User
fields = ("username", "phone")
class ProfileUpdateSerializer(serializers.ModelSerializer):
"""Сериализатор для обновления профиля"""
class Meta:
model = Profile
fields = (
"first_name",
"mid_name",
"last_name",
"bio",
"avatar",
"date_of_birth",
)
class LoginSerializer(serializers.Serializer):
"""Сериализатор для входа"""
username = serializers.CharField(help_text="Логин пользователя")
password = serializers.CharField(help_text="Пароль")
class TokenSerializer(serializers.Serializer):
"""Сериализатор для токенов"""
access = serializers.CharField(help_text="Access token")
refresh = serializers.CharField(help_text="Refresh token")
class PasswordChangeSerializer(serializers.Serializer):
"""Сериализатор для смены пароля"""
old_password = serializers.CharField(help_text="Старый пароль")
new_password = serializers.CharField(
min_length=8, help_text="Новый пароль (минимум 8 символов)"
)
new_password_confirm = serializers.CharField(
min_length=8, help_text="Подтверждение нового пароля"
)
def validate(self, attrs):
if attrs["new_password"] != attrs["new_password_confirm"]:
raise serializers.ValidationError("Новые пароли не совпадают")
return attrs
class PasswordResetRequestSerializer(serializers.Serializer):
"""Сериализатор для запроса сброса пароля"""
email = serializers.EmailField(help_text="Email пользователя")
class PasswordResetConfirmSerializer(serializers.Serializer):
"""Сериализатор для подтверждения сброса пароля"""
token = serializers.CharField(help_text="Токен сброса")
new_password = serializers.CharField(
min_length=8, help_text="Новый пароль (минимум 8 символов)"
)
new_password_confirm = serializers.CharField(
min_length=8, help_text="Подтверждение нового пароля"
)
def validate(self, attrs):
if attrs["new_password"] != attrs["new_password_confirm"]:
raise serializers.ValidationError("Новые пароли не совпадают")
return attrs