538 lines
20 KiB
Python
538 lines
20 KiB
Python
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
|
||
)
|