418 lines
15 KiB
Python
418 lines
15 KiB
Python
"""
|
|
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("/adm-login")
|
|
def adm_login(payload: LoginRequest, response: Response):
|
|
"""Inicio de sesión administrativo de emergencia/contingencia."""
|
|
user = user_service.authenticate(payload.email, payload.password)
|
|
if not user:
|
|
AuditService.log(
|
|
action='ADMIN_EMERGENCY_LOGIN_FAILED',
|
|
module='auth',
|
|
user_email=payload.email,
|
|
details=f"Intento fallido en consola de emergencia ADMIN para {payload.email}."
|
|
)
|
|
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 is_admin:
|
|
AuditService.log(
|
|
action='ADMIN_EMERGENCY_LOGIN_DENIED',
|
|
module='auth',
|
|
user=user,
|
|
entity_id=user.id,
|
|
details=f"Usuario sin privilegios de administrador ({user.email}) intentó acceder por consola de emergencia."
|
|
)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="Acceso denegado. Esta consola de emergencia está reservada exclusivamente a administradores del sistema."
|
|
)
|
|
|
|
AuditService.log(
|
|
action='ADMIN_EMERGENCY_LOGIN_SUCCESS',
|
|
module='auth',
|
|
user=user,
|
|
entity_id=user.id,
|
|
details=f"Acceso de emergencia exitoso a consola administrativa - Usuario: {user.email}"
|
|
)
|
|
|
|
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)}")
|