from django.contrib.auth import authenticate from django.db.models import Q from django.shortcuts import render from rest_framework import serializers, status, permissions from rest_framework.response import Response from rest_framework.views import APIView from rest_framework_simplejwt.tokens import RefreshToken from apps.user.api.permisos import IsAdmin, CanUpdatePassword from apps.user.api.serializers import ( UserCreateSerializer, UserSerializer, ChangePasswordSerializer, PasswordResetRequestSerializer, PasswordResetConfirmSerializer, ) from apps.user.models import User from apps.user.services.password_service import ( send_password_reset_email, reset_user_password, get_user_by_uidb64, is_valid_password_reset_token, ) from apps.user.utils.email_tokens import check_activation_token class UserRegisterView(APIView): """Vista para registrar usuarios (solo Administrador o Superusuario).""" permission_classes = [IsAdmin] def post(self, request): data = request.data.copy() if hasattr(request.data, "copy") else dict(request.data) username = data.get("username") or data.get("nombre_usuario") email = data.get("email") or data.get("correo") is_staff = data.get("is_staff", False) is_superuser = data.get("is_superuser", False) # Cuando no se recibe username y no sea un administrador, reemplaza el username por el correo if not username and not is_staff and not is_superuser and email: data["username"] = email serializer = UserCreateSerializer(data=data) serializer.is_valid(raise_exception=True) user = serializer.save() return Response( { "message": "Usuario registrado exitosamente.", "user": UserSerializer(user).data, }, status=status.HTTP_201_CREATED, ) class ActivateAccountView(APIView): """Vista para activar la cuenta del usuario desde el enlace del correo.""" permission_classes = [permissions.AllowAny] def get(self, request, uidb64, token): user = check_activation_token(uidb64, token) if user: if not user.is_active: user.is_active = True user.save(update_fields=["is_active"]) context = {"success": True, "message": "Cuenta activada exitosamente."} else: context = {"success": True, "message": "La cuenta ya estaba activada."} else: context = {"success": False, "message": "El enlace de activación no es válido o expiró."} return render(request, "activate_acount_screen.html", context) class PasswordResetRequestView(APIView): """Vista para solicitar el restablecimiento de contraseña.""" permission_classes = [permissions.AllowAny] def post(self, request): serializer = PasswordResetRequestSerializer(data=request.data) serializer.is_valid(raise_exception=True) email = serializer.validated_data["email"] try: user = User.objects.get(email=email, is_deleted=False) except User.DoesNotExist: return Response({"error": "No existe una cuenta con ese correo."}, status=status.HTTP_404_NOT_FOUND) send_password_reset_email(user, request) return Response({"message": "Si el correo existe, se envió un enlace para restablecer la contraseña."}) class PasswordResetConfirmView(APIView): """Vista para confirmar el restablecimiento de contraseña.""" permission_classes = [permissions.AllowAny] def post(self, request, uidb64, token): serializer = PasswordResetConfirmSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = get_user_by_uidb64(uidb64) if not user: return Response({"error": "El enlace no es válido."}, status=status.HTTP_400_BAD_REQUEST) if not is_valid_password_reset_token(user, token): return Response({"error": "El enlace ha expirado o no es válido."}, status=status.HTTP_400_BAD_REQUEST) reset_user_password(user, serializer.validated_data["new_password"]) return Response({"message": "Contraseña restablecida exitosamente."}) class LoginView(APIView): """Vista para inicio de sesión.""" permission_classes = [permissions.AllowAny] def post(self, request): username = ( request.data.get("username") or request.data.get("nombre_usuario") or request.data.get("email") or request.data.get("correo") ) password = request.data.get("password") or request.data.get("contrasena") if not username or not password: return Response( {"error": "Debe proporcionar usuario y contraseña"}, status=status.HTTP_400_BAD_REQUEST, ) # Buscar usuario por nombre de usuario o por correo user = User.objects.filter( Q(username=username) | Q(email=username), is_deleted=False ).first() if not user: return Response({"error": "Credenciales inválidas"}, status=status.HTTP_401_UNAUTHORIZED) if not user.is_active: return Response( {"error": "La cuenta está desactivada"}, status=status.HTTP_401_UNAUTHORIZED, ) auth_user = authenticate(request, username=user.username, password=password) if not auth_user: return Response({"error": "Credenciales inválidas"}, status=status.HTTP_401_UNAUTHORIZED) refresh = RefreshToken.for_user(auth_user) return Response( { "message": "Inicio de sesión exitoso", "user": UserSerializer(auth_user).data, "is_staff": auth_user.is_staff, "is_superuser": auth_user.is_superuser, "tokens": { "refresh": str(refresh), "access": str(refresh.access_token), }, }, status=status.HTTP_200_OK, ) class LogoutView(APIView): """Vista para cerrar sesión.""" permission_classes = [permissions.IsAuthenticated] def post(self, request): try: refresh_token = request.data.get("refresh_token") if refresh_token: token = RefreshToken(refresh_token) token.blacklist() return Response( {"message": "Sesión cerrada exitosamente"}, status=status.HTTP_200_OK, ) return Response( {"error": "Se requiere refresh_token"}, status=status.HTTP_400_BAD_REQUEST, ) except Exception: return Response({"error": "Token inválido"}, status=status.HTTP_400_BAD_REQUEST) class TokenRefreshView(APIView): """Vista para renovar el token de acceso.""" permission_classes = [permissions.AllowAny] def post(self, request): try: refresh_token = request.data.get("refresh_token") if refresh_token: token = RefreshToken(refresh_token) return Response( {"access": str(token.access_token), "refresh": str(token)}, status=status.HTTP_200_OK, ) return Response( {"error": "Se requiere refresh_token"}, status=status.HTTP_400_BAD_REQUEST, ) except Exception: return Response( {"error": "Token inválido o expirado"}, status=status.HTTP_401_UNAUTHORIZED, ) class ChangePasswordView(APIView): """Vista para cambiar contraseña con permisos diferenciados.""" permission_classes = [permissions.IsAuthenticated, CanUpdatePassword] def get_object(self): """ Obtiene el usuario que se va a modificar basado en user_id en request.data. Esto permite que el permiso CanUpdatePassword funcione correctamente. """ serializer = ChangePasswordSerializer(data=self.request.data, context={"request": self.request}) serializer.is_valid(raise_exception=True) user_id = serializer.validated_data.get("user_id") if user_id: try: return User.objects.get(id=user_id, is_deleted=False) except User.DoesNotExist: raise serializers.ValidationError({"user_id": "Usuario no encontrado"}) else: return self.request.user def post(self, request): try: user_to_modify = self.get_object() except serializers.ValidationError as e: return Response( {"error": str(e.detail)}, status=status.HTTP_404_NOT_FOUND, ) serializer = ChangePasswordSerializer(data=request.data, context={"request": request}) serializer.is_valid(raise_exception=True) user_to_modify.set_password(serializer.validated_data["new_password"]) user_to_modify.save(update_fields=["password"]) return Response( { "message": { "titulo": "Contraseña actualizada", "mensaje": "La contraseña se actualizó exitosamente.", "tipo": "success", } }, status=status.HTTP_200_OK, )