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 )