Files
state-corp-backend/src/apps/user/views.py
2026-09-21 16:44:56 +02:00

538 lines
20 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 urllib.parse import urlencode
from apps.core.models import BackgroundJob
from apps.core.services import BackgroundJobService
from django.contrib.auth import authenticate, get_user_model, logout
from django.contrib.auth.hashers import check_password
from django.core.paginator import Paginator
from django.db.models import F
from django.db.models.functions import Coalesce
from django.shortcuts import get_object_or_404
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework import generics, status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.exceptions import ValidationError
from rest_framework.permissions import AllowAny, IsAdminUser, IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_simplejwt.exceptions import TokenError
from rest_framework_simplejwt.tokens import RefreshToken
from .serializers import (
AdminUserCreateSerializer,
AdminUserListResponseSerializer,
AdminUserUpdateSerializer,
CurrentUserSerializer,
LoginSerializer,
ManagedUserSerializer,
PasswordChangeSerializer,
ProfileUpdateSerializer,
TokenSerializer,
UserManagementSerializer,
UserRegistrationSerializer,
UserSerializer,
UserUpdateSerializer,
)
from .services import ProfileService, UserService
User = get_user_model()
# Swagger теги для группировки
AUTH_TAG = "Аутентификация"
USER_TAG = "Пользователь"
def _build_page_url(request, page_number: int) -> str:
query_params = request.query_params.copy()
query_params["page"] = page_number
encoded_query = urlencode(query_params, doseq=True)
return request.build_absolute_uri(f"{request.path}?{encoded_query}")
def _paginate_user_queryset(request, queryset):
"""Пагинирует только запросы с явными page/page_size для legacy-совместимости."""
if "page" not in request.query_params and "page_size" not in request.query_params:
return {
"count": queryset.count(),
"next": None,
"previous": None,
"results": list(queryset),
}
page_size_raw = request.query_params.get("page_size", "20")
page_raw = request.query_params.get("page", "1")
try:
page_size = max(1, min(int(page_size_raw), 100))
page_number = max(1, int(page_raw))
except (TypeError, ValueError) as exc:
raise ValidationError(
{
"detail": (
"Параметры page и page_size должны быть положительными "
"целыми числами."
)
}
) from exc
paginator = Paginator(queryset, page_size)
page_obj = paginator.get_page(page_number)
return {
"count": paginator.count,
"next": (
_build_page_url(request, page_obj.next_page_number())
if page_obj.has_next()
else None
),
"previous": (
_build_page_url(request, page_obj.previous_page_number())
if page_obj.has_previous()
else None
),
"results": list(page_obj.object_list),
}
class RegisterView(APIView):
"""
Регистрация нового пользователя.
Создаёт учётную запись и возвращает JWT токены.
"""
permission_classes = [AllowAny]
@swagger_auto_schema(
tags=[AUTH_TAG],
operation_summary="Регистрация",
operation_description="Создание новой учётной записи пользователя.",
request_body=UserRegistrationSerializer,
responses={201: UserSerializer},
)
def post(self, request):
serializer = UserRegistrationSerializer(data=request.data)
if serializer.is_valid():
# Убираем password_confirm из данных для создания пользователя
user_data = serializer.validated_data.copy()
user_data.pop("password_confirm", None)
user = UserService.create_user(**user_data)
user_serializer = UserSerializer(user)
tokens = UserService.get_tokens_for_user(user)
return Response(
{"user": user_serializer.data, "tokens": tokens},
status=status.HTTP_201_CREATED,
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class LoginView(APIView):
"""
Вход пользователя.
Возвращает access и refresh токены для авторизации.
"""
permission_classes = [AllowAny]
@swagger_auto_schema(
tags=[AUTH_TAG],
operation_summary="Вход",
operation_description="Аутентификация по логину и паролю. Возвращает JWT токены.",
request_body=LoginSerializer,
responses={200: TokenSerializer},
)
def post(self, request):
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
username = serializer.validated_data["username"]
password = serializer.validated_data["password"]
user = authenticate(username=username, password=password)
if user:
tokens = UserService.get_tokens_for_user(user)
return Response(tokens, status=status.HTTP_200_OK)
else:
return Response(
{"error": "Неверные учетные данные"},
status=status.HTTP_401_UNAUTHORIZED,
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class LogoutView(APIView):
"""
Выход пользователя.
Завершает Django-сессию. JWT по-прежнему удаляются на клиенте.
"""
permission_classes = [IsAuthenticated]
@swagger_auto_schema(
tags=[AUTH_TAG],
operation_summary="Выход",
operation_description=("Завершение Django-сессии; JWT удаляются на клиенте."),
responses={200: "Успешный выход"},
)
def post(self, request):
# Для JWT это сохраняет прежнее поведение: токены удаляются клиентом.
# Для SSO серверная сессия должна быть явно завершена.
logout(request)
return Response({"message": "Успешный выход"}, status=status.HTTP_200_OK)
class CurrentUserView(APIView):
"""Получение данных текущего пользователя."""
permission_classes = [IsAuthenticated]
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Текущий пользователь",
operation_description="Возвращает данные авторизованного пользователя.",
responses={200: CurrentUserSerializer},
)
def get(self, request):
serializer = CurrentUserSerializer(request.user)
return Response(serializer.data)
class UserUpdateView(APIView):
"""Обновление данных пользователя."""
permission_classes = [IsAuthenticated]
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Обновить данные",
operation_description="Частичное обновление данных пользователя.",
request_body=UserUpdateSerializer,
responses={200: UserSerializer},
)
def patch(self, request):
serializer = UserUpdateSerializer(request.user, data=request.data, partial=True)
if serializer.is_valid():
user = UserService.update_user(request.user.id, **serializer.validated_data)
user_serializer = UserSerializer(user)
return Response(user_serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProfileDetailView(generics.RetrieveUpdateAPIView):
"""Получение и обновление профиля пользователя."""
permission_classes = [IsAuthenticated]
serializer_class = ProfileUpdateSerializer
def get_object(self):
profile = ProfileService.get_profile_by_user_id_or_none(self.request.user.id)
if not profile:
# Если профиль не существует, создаем его
from .models import Profile
profile = Profile.objects.create(user=self.request.user)
return profile
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Получить профиль",
operation_description="Возвращает профиль текущего пользователя.",
)
def get(self, request, *args, **kwargs):
profile = self.get_object()
serializer = self.get_serializer(profile)
return Response(serializer.data)
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Обновить профиль",
operation_description="Частичное обновление профиля пользователя.",
request_body=ProfileUpdateSerializer,
)
def patch(self, request, *args, **kwargs):
profile = self.get_object()
serializer = self.get_serializer(profile, data=request.data, partial=True)
if serializer.is_valid():
updated_profile = ProfileService.update_profile(
request.user.id, **serializer.validated_data
)
return Response(ProfileUpdateSerializer(updated_profile).data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class PasswordChangeView(APIView):
"""Смена пароля пользователя."""
permission_classes = [IsAuthenticated]
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Сменить пароль",
operation_description="Смена пароля. Требуется текущий пароль для подтверждения.",
request_body=PasswordChangeSerializer,
responses={200: "Пароль успешно изменен"},
)
def post(self, request):
serializer = PasswordChangeSerializer(data=request.data)
if serializer.is_valid():
user = request.user
old_password = serializer.validated_data["old_password"]
if check_password(old_password, user.password):
new_password = serializer.validated_data["new_password"]
user.set_password(new_password)
user.save()
return Response(
{"message": "Пароль успешно изменен"}, status=status.HTTP_200_OK
)
else:
return Response(
{"error": "Неверный старый пароль"},
status=status.HTTP_400_BAD_REQUEST,
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class AdminUsersManagementView(APIView):
"""Список и создание пользователей в административной панели."""
permission_classes = [IsAdminUser]
@staticmethod
def _attach_latest_jobs(users: list[User]):
user_ids = [user.id for user in users]
if not user_ids:
return
latest_jobs: dict[int, BackgroundJob] = {}
jobs = (
BackgroundJobService.get_queryset()
.filter(user_id__in=user_ids)
.annotate(
_effective_job_ts=Coalesce(
F("completed_at"),
F("started_at"),
F("updated_at"),
F("created_at"),
)
)
.order_by("user_id", "-_effective_job_ts")
)
for job in jobs:
if job.user_id not in latest_jobs:
latest_jobs[job.user_id] = job
for user in users:
user.latest_job = latest_jobs.get(user.id)
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Список пользователей (admin)",
operation_description=(
"Возвращает пользователей для административной панели управления. "
"Включает роль, профиль и метрики последней фоновой задачи пользователя."
),
manual_parameters=[
openapi.Parameter(
"search",
openapi.IN_QUERY,
type=openapi.TYPE_STRING,
required=False,
),
openapi.Parameter(
"ordering",
openapi.IN_QUERY,
type=openapi.TYPE_STRING,
required=False,
),
openapi.Parameter(
"page",
openapi.IN_QUERY,
type=openapi.TYPE_INTEGER,
required=False,
),
openapi.Parameter(
"page_size",
openapi.IN_QUERY,
type=openapi.TYPE_INTEGER,
required=False,
),
],
responses={200: AdminUserListResponseSerializer},
)
def get(self, request):
queryset = UserService.get_filtered_users_queryset(
search=request.query_params.get("search", ""),
ordering=request.query_params.get("ordering", ""),
)
paginated = _paginate_user_queryset(request, queryset)
users = paginated["results"]
self._attach_latest_jobs(users)
serializer = UserManagementSerializer(users, many=True)
return Response(
{
"count": paginated["count"],
"next": paginated["next"],
"previous": paginated["previous"],
"results": serializer.data,
}
)
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Создать пользователя (admin)",
request_body=AdminUserCreateSerializer,
responses={201: ManagedUserSerializer},
)
def post(self, request):
serializer = AdminUserCreateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = UserService.create_managed_user(**serializer.validated_data)
return Response(
ManagedUserSerializer(user).data,
status=status.HTTP_201_CREATED,
)
class AdminUserDetailView(APIView):
"""Просмотр и частичное обновление пользователя администратором."""
permission_classes = [IsAdminUser]
@staticmethod
def _get_user(user_id: int):
return get_object_or_404(UserService.get_users_queryset(), id=user_id)
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Детали пользователя (admin)",
responses={200: UserManagementSerializer},
)
def get(self, request, user_id: int):
user = self._get_user(user_id)
AdminUsersManagementView._attach_latest_jobs([user])
return Response(UserManagementSerializer(user).data)
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Обновить пользователя (admin)",
request_body=AdminUserUpdateSerializer,
responses={200: ManagedUserSerializer},
)
def patch(self, request, user_id: int):
user = self._get_user(user_id)
serializer = AdminUserUpdateSerializer(user, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
if request.user.id == user.id:
if serializer.validated_data.get("is_active") is False:
return Response(
{"detail": "Нельзя деактивировать самого себя."},
status=status.HTTP_400_BAD_REQUEST,
)
if serializer.validated_data.get("role") == UserService.ROLE_USER:
return Response(
{"detail": "Нельзя снять у себя роль администратора."},
status=status.HTTP_400_BAD_REQUEST,
)
updated_user = UserService.update_managed_user(
user_id=user.id,
**serializer.validated_data,
)
return Response(ManagedUserSerializer(updated_user).data)
class AdminUserDeactivateView(APIView):
"""Деактивация пользователя администратором."""
permission_classes = [IsAdminUser]
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Деактивировать пользователя (admin)",
responses={200: ManagedUserSerializer},
)
def post(self, request, user_id: int):
if request.user.id == user_id:
return Response(
{"detail": "Нельзя деактивировать самого себя."},
status=status.HTTP_400_BAD_REQUEST,
)
user = UserService.deactivate_user(user_id)
return Response(ManagedUserSerializer(user).data)
class AdminUserActivateView(APIView):
"""Активация пользователя администратором."""
permission_classes = [IsAdminUser]
@swagger_auto_schema(
tags=[USER_TAG],
operation_summary="Активировать пользователя (admin)",
responses={200: ManagedUserSerializer},
)
def post(self, request, user_id: int):
user = UserService.activate_user(user_id)
return Response(ManagedUserSerializer(user).data)
@swagger_auto_schema(
method="get",
tags=[USER_TAG],
operation_summary="Полный профиль",
operation_description="Расширенная информация о пользователе и профиле.",
)
@api_view(["GET"])
@permission_classes([IsAuthenticated])
def user_profile_detail(request):
"""Получение полных данных профиля пользователя."""
profile_data = ProfileService.get_full_profile_data(request.user.id)
return Response(profile_data)
class TokenRefreshView(APIView):
"""Обновление access токена через refresh токен."""
permission_classes = [AllowAny]
@swagger_auto_schema(
tags=[AUTH_TAG],
operation_summary="Обновить токен",
operation_description="Получение нового access токена по refresh токену.",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"refresh": openapi.Schema(
type=openapi.TYPE_STRING, description="Refresh token"
)
},
required=["refresh"],
),
responses={200: TokenSerializer},
)
def post(self, request):
refresh_token = request.data.get("refresh")
if not refresh_token:
return Response(
{"error": "Refresh token обязателен"},
status=status.HTTP_400_BAD_REQUEST,
)
try:
refresh = RefreshToken(refresh_token)
return Response(
{"access": str(refresh.access_token), "refresh": str(refresh)}
)
except TokenError:
return Response(
{"error": "Неверный refresh token"}, status=status.HTTP_401_UNAUTHORIZED
)