""" FastAPI Authentication Router (/api/v1/auth) Implements Hybrid Authentication: - Local Authentication with Admin fallback - Google OAuth 2.0 institutional login - Moodle Delegated Authentication - Dual Token JWT management with HttpOnly cookies """ from typing import Optional import requests from fastapi import APIRouter, Depends, HTTPException, Request, Response, status from app import db from app.models.user import User from app.models.role import Role from app.models.setting import SystemSetting from app.services.user_service import UserService from app.services.jwt_service import JWTService from app.services.audit_service import AuditService from dependencies import get_current_user, get_token_from_request from schemas.auth import ( LoginRequest, GoogleAuthRequest, MoodleAuthRequest, RefreshTokenRequest, ProfileUpdateRequest, ThemeUpdateRequest ) auth_router = APIRouter(prefix="/api/v1/auth", tags=["Authentication"]) user_service = UserService() @auth_router.get("/providers") def get_auth_providers(): """Retorna los métodos de autenticación habilitados y configuración de cliente Google.""" local_val = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1') google_val = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1') moodle_val = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1') google_client_id = str(SystemSetting.get_value('google_client_id', '') or '') demo_access_enabled = str(SystemSetting.get_value('demo_access_enabled', 'true') or 'true').lower() in ('true', '1') return { 'status': 'success', 'providers': { 'local': local_val, 'google': google_val, 'moodle': moodle_val }, 'google_client_id': google_client_id, 'demo_access_enabled': demo_access_enabled } @auth_router.post("/login") def login(payload: LoginRequest, response: Response): """Inicio de sesión local nativo (Access + Refresh tokens).""" local_enabled = str(SystemSetting.get_value('auth_local_enabled', 'true') or 'true').lower() in ('true', '1') user = user_service.authenticate(payload.email, payload.password) if not user: AuditService.log( action='LOGIN_FAILED', module='auth', user_email=payload.email, details=f"Intento de inicio de sesión fallido para {payload.email}. Credenciales incorrectas o cuenta inactiva." ) raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenciales de acceso incorrectas o cuenta inactiva." ) is_admin = user.is_admin() or getattr(user, 'role', '').upper() == 'ADMIN' if not local_enabled and not is_admin: AuditService.log( action='LOGIN_BLOCKED', module='auth', user=user, entity_id=user.id, details=f"Acceso local con contraseña bloqueado para {user.email}. Método deshabilitado por administración." ) raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="El acceso local con contraseña está deshabilitado por el administrador. Inicie sesión mediante Google OAuth o Moodle." ) AuditService.log( action='LOGIN', module='auth', user=user, entity_id=user.id, details=f"Inicio de sesión exitoso (Autenticación Local) - Rol: {user.role}" ) tokens = JWTService.generate_tokens(user) profile = user_service.get_profile_data(user) response.set_cookie( key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/" ) response.set_cookie( key="refresh_token", value=tokens["refresh_token"], httponly=True, samesite="lax", max_age=7 * 24 * 3600, path="/api/v1/auth/refresh" ) return { 'status': 'success', 'access_token': tokens['access_token'], 'refresh_token': tokens['refresh_token'], 'token_type': tokens['token_type'], 'expires_in': tokens['expires_in'], 'user': profile } @auth_router.post("/google") def google_auth(payload: GoogleAuthRequest, response: Response): """Inicio de sesión delegado institucional Google OAuth 2.0.""" google_enabled = str(SystemSetting.get_value('auth_google_enabled', 'false') or 'false').lower() in ('true', '1') if not google_enabled: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Google no está habilitado.") email = payload.email.strip().lower() allowed_domains_str = str(SystemSetting.get_value('google_allowed_domains', 'unicaba.edu.ar') or 'unicaba.edu.ar') allowed_domains = [d.strip().lower() for d in allowed_domains_str.split(',') if d.strip()] email_domain = email.split('@')[1] if '@' in email else '' if allowed_domains and email_domain not in allowed_domains: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail=f"El dominio @{email_domain} no está autorizado. Sólo se permiten cuentas institucionales: {allowed_domains_str}." ) user = User.query.filter(User.email.ilike(email)).first() if not user: parts = (payload.name or email.split('@')[0]).split() first_name = parts[0] if parts else 'Usuario' last_name = ' '.join(parts[1:]) if len(parts) > 1 else 'Google' docente_role = Role.query.filter(Role.name.ilike('Docente')).first() user = User( email=email, name=payload.name or f"{first_name} {last_name}", first_name=first_name, last_name=last_name, role='Docente' if not docente_role else docente_role.name, role_id=docente_role.id if docente_role else None, is_active=True ) user.set_password(f"GoogleSSO_{email}") db.session.add(user) db.session.commit() if not user.is_active: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta institucional está inactiva.") tokens = JWTService.generate_tokens(user) profile = user_service.get_profile_data(user) response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/") return { 'status': 'success', 'access_token': tokens['access_token'], 'refresh_token': tokens['refresh_token'], 'token_type': tokens['token_type'], 'expires_in': tokens['expires_in'], 'user': profile } @auth_router.post("/moodle") def moodle_auth(payload: MoodleAuthRequest, response: Response): """Inicio de sesión delegado con Moodle (verificando DNI o credenciales de campus).""" moodle_enabled = str(SystemSetting.get_value('auth_moodle_enabled', 'false') or 'false').lower() in ('true', '1') if not moodle_enabled: raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="El inicio de sesión con Moodle no está habilitado.") server_url = str(SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle') or 'http://10.0.0.207/moodle').rstrip('/') service_name = str(SystemSetting.get_value('moodle_service_name', 'moodle_api') or 'moodle_api') try: resp = requests.post(f"{server_url}/login/token.php", data={ 'username': payload.username, 'password': payload.password, 'service': service_name }, timeout=10) res_data = resp.json() except Exception as e: raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=f"No se pudo conectar a Moodle: {str(e)}") if 'token' not in res_data: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenciales de Moodle inválidas.") username = payload.username.strip() user = User.query.filter( (User.email.ilike(f"{username}@%")) | (User.document_number == username) ).first() if not user: role_obj = Role.query.filter(Role.name.ilike('Docente')).first() user = User( email=f"{username}@unicaba.edu.ar", name=username, document_number=username if username.isdigit() else None, role=role_obj.name if role_obj else 'Docente', role_id=role_obj.id if role_obj else None, is_active=True ) user.set_password(f"MoodleLinked_{username}") db.session.add(user) db.session.commit() if not user.is_active: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Su cuenta en Edu-Space está desactivada.") tokens = JWTService.generate_tokens(user) profile = user_service.get_profile_data(user) response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/") return { 'status': 'success', 'access_token': tokens['access_token'], 'refresh_token': tokens['refresh_token'], 'token_type': tokens['token_type'], 'expires_in': tokens['expires_in'], 'user': profile } @auth_router.get("/profile") @auth_router.get("/me") def get_current_user_profile(user: User = Depends(get_current_user)): """Retorna la ficha del perfil del usuario actualmente autenticado.""" u = User.query.get(user.id) or user profile = user_service.get_profile_data(u) res = { 'status': 'success', 'user': profile } if isinstance(profile, dict): res.update(profile) return res @auth_router.post("/profile") def update_profile( payload: ProfileUpdateRequest, user: User = Depends(get_current_user) ): """Actualiza las preferencias de idioma y tema visual del usuario autenticado.""" u = User.query.get(user.id) if not u: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.") if payload.preferred_language in ['es', 'en']: u.preferred_language = payload.preferred_language else: u.preferred_language = None if payload.theme_preference in ['auto', 'light', 'dark']: u.theme_preference = payload.theme_preference db.session.commit() profile = user_service.get_profile_data(u) AuditService.log( action='UPDATE_PROFILE', module='auth', user=u, details={'preferred_language': u.preferred_language, 'theme_preference': u.theme_preference}, status='success' ) return { 'status': 'success', 'message': 'Preferencias de usuario actualizadas correctamente.', 'user': profile } @auth_router.post("/theme") def update_theme( payload: ThemeUpdateRequest, user: User = Depends(get_current_user) ): """Actualiza el tema visual del usuario desde la interfaz (AJAX).""" u = User.query.get(user.id) if not u: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuario no encontrado.") if payload.theme not in ['auto', 'light', 'dark']: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tema visual inválido.") u.theme_preference = payload.theme db.session.commit() return { 'status': 'success', 'theme': u.theme_preference } @auth_router.post("/logout") def logout(request: Request, response: Response): """Cierra la sesión y revoca los tokens activos.""" token = get_token_from_request(request) if token: try: JWTService.revoke_token(token) except Exception: pass response.delete_cookie(key="access_token", path="/") response.delete_cookie(key="refresh_token", path="/api/v1/auth/refresh") return {'status': 'success', 'message': 'Sesión cerrada exitosamente.'} @auth_router.post("/refresh") def refresh_token(request: Request, response: Response, payload: Optional[RefreshTokenRequest] = None): """Renueva el token de acceso a partir de un refresh token válido.""" token: Optional[str] = (payload.refresh_token if payload else None) or request.cookies.get('refresh_token') if not token: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="No se proporcionó refresh token.") try: decoded = JWTService.decode_token(token, expected_type='refresh') user_id = decoded.get('sub') if not user_id: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token no contiene sub válido.") user = User.query.get(int(str(user_id))) if not user or not user.is_active: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Usuario no encontrado o inactivo.") tokens = JWTService.generate_tokens(user) response.set_cookie(key="access_token", value=tokens["access_token"], httponly=True, samesite="lax", path="/") return { 'status': 'success', 'access_token': tokens['access_token'], 'refresh_token': tokens['refresh_token'], 'token_type': tokens['token_type'], 'expires_in': tokens['expires_in'] } except Exception as e: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"Refresh token inválido: {str(e)}")