""" FastAPI Admin Router (/api/v1) Provides modular endpoints for User Administration, RBAC Roles, Security Impersonation, System Reset, Audit Logs, Settings (SMTP/Moodle/Google) and Moodle Queue operations. """ from typing import Optional, List, Dict, Any from fastapi import APIRouter, Depends, HTTPException, Query, status, Request from sqlalchemy import func, or_ from datetime import datetime, timezone from app import db from app.models.user import User from app.models.role import Role, Permission, SYSTEM_MODULES from app.models.audit_log import AuditLog from app.models.setting import SystemSetting from app.models.sync_task import MoodleSyncTask from app.services.audit_service import AuditService from app.services.jwt_service import JWTService from app.services.moodle_queue_service import moodle_queue_service from app.constants.document_types import DOCUMENT_TYPES, validate_document from dependencies import get_current_user, require_roles, get_token_from_request admin_router = APIRouter(prefix="/api/v1", tags=["Administration & Settings"]) # ========================================================= # USERS CRUD ENDPOINTS # ========================================================= @admin_router.get("/users") @admin_router.get("/admin/users") def get_users( search: Optional[str] = Query(None), role_id: Optional[int] = Query(None, alias="role"), status_filter: Optional[str] = Query(None, alias="status"), current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Lista usuarios del sistema con filtros de búsqueda y rol.""" query = User.query if search: s_clean = search.strip().lower() query = query.filter( or_( User.name.ilike(f'%{s_clean}%'), User.email.ilike(f'%{s_clean}%'), User.personal_email.ilike(f'%{s_clean}%'), User.document_number.ilike(f'%{s_clean}%'), User.first_name.ilike(f'%{s_clean}%'), User.last_name.ilike(f'%{s_clean}%') ) ) if role_id: query = query.filter(User.role_id == role_id) if status_filter == 'active': query = query.filter(User.is_active == True) elif status_filter == 'inactive': query = query.filter(User.is_active == False) users = query.order_by(User.id.asc()).all() roles = Role.query.order_by(Role.name.asc()).all() users_data = [] for u in users: d = u.to_dict() d['role_obj'] = { 'id': u.role_obj.id, 'name': u.role_obj.name } if u.role_obj else {'id': 1, 'name': u.role or 'Admin'} users_data.append(d) roles_data = [{'id': r.id, 'name': r.name} for r in roles] return { 'status': 'success', 'total': len(users_data), 'users': users_data, 'roles': roles_data, 'document_types': DOCUMENT_TYPES } @admin_router.post("/users", status_code=status.HTTP_201_CREATED) @admin_router.post("/admin/users", status_code=status.HTTP_201_CREATED) async def create_user( request: Request, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Crea un nuevo usuario en la plataforma con soporte para sincronización hacia Moodle.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) email = (data.get('email') or '').strip().lower() first_name = (data.get('first_name') or '').strip() last_name = (data.get('last_name') or '').strip() name = (data.get('name') or f"{first_name} {last_name}").strip() role_name = (data.get('role') or 'docente').strip().upper() role_id = data.get('role_id') phone = (data.get('phone') or '').strip() personal_email = (data.get('personal_email') or '').strip().lower() address = (data.get('address') or '').strip() document_type = (data.get('document_type') or 'DNI').strip().upper() document_number = (data.get('document_number') or '').strip() password = data.get('password') is_active = data.get('is_active', True) if isinstance(is_active, str): is_active = is_active.lower() in ['true', '1', 'on'] if not email or not name: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El email y nombre completo son requeridos.") if User.query.filter(User.email.ilike(email)).first(): raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"Ya existe un usuario con el email {email}.") if document_number: is_valid, clean_doc, err_msg = validate_document(document_type, document_number) if not is_valid: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=err_msg) document_number = clean_doc if User.query.filter_by(document_type=document_type, document_number=document_number).first(): raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"El documento {document_type} {document_number} ya está registrado.") user = User( email=email, name=name, first_name=first_name or (name.split()[0] if name else ''), last_name=last_name or (' '.join(name.split()[1:]) if len(name.split()) > 1 else ''), phone=phone or None, personal_email=personal_email or None, address=address or None, document_type=document_type, document_number=document_number, role=role_name, role_id=int(role_id) if (role_id and str(role_id).strip().isdigit()) else None, is_active=bool(is_active) ) user.set_password(password or 'edu-space2026') db.session.add(user) db.session.commit() # Encolar creación en Moodle si aplica try: username = user.email.split('@')[0].lower() moodle_queue_service.enqueue_task( action='CREATE_USER', entity_type='user', entity_id=str(user.id), payload={ 'username': username, 'email': user.email, 'firstname': user.first_name or 'Docente', 'lastname': user.last_name or 'EduSpace', 'password': password or 'EduSpace2026*' } ) except Exception: pass return { 'status': 'success', 'message': 'Usuario creado exitosamente.', 'user': user.to_dict() } @admin_router.get("/users/{id}") def get_user_detail( id: int, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Obtiene el detalle de un usuario por su identificador.""" user = User.query.get(id) if not user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario con ID {id} no encontrado.") d = user.to_dict() d['role_obj'] = { 'id': user.role_obj.id, 'name': user.role_obj.name } if user.role_obj else {'id': 1, 'name': user.role or 'Admin'} return { 'status': 'success', 'user': d } @admin_router.put("/users/{id}") async def update_user( id: int, request: Request, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Actualiza los datos de un usuario.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) user = User.query.get(id) if not user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario con ID {id} no encontrado.") first_name = (data.get('first_name', user.first_name or '')).strip() last_name = (data.get('last_name', user.last_name or '')).strip() name = (data.get('name') or '').strip() if 'first_name' in data or 'last_name' in data: user.first_name = first_name user.last_name = last_name user.name = f"{first_name} {last_name}".strip() elif name: user.name = name parts = name.split() user.first_name = parts[0] if parts else '' user.last_name = ' '.join(parts[1:]) if len(parts) > 1 else '' if 'phone' in data: user.phone = (data['phone'] or '').strip() if 'personal_email' in data: user.personal_email = (data['personal_email'] or '').strip().lower() if 'address' in data: user.address = (data['address'] or '').strip() if 'document_type' in data or 'document_number' in data: doc_type = (data.get('document_type') or user.document_type or 'DNI').strip().upper() doc_num = (data.get('document_number') or user.document_number or '').strip() if doc_num: is_valid, clean_doc, err_msg = validate_document(doc_type, doc_num) if not is_valid: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=err_msg) doc_num = clean_doc existing_doc = User.query.filter( User.document_type == doc_type, User.document_number == doc_num, User.id != id ).first() if existing_doc: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'El documento {doc_type} {doc_num} ya está asignado a otro usuario.') user.document_type = doc_type user.document_number = doc_num if 'email' in data and data['email']: email = data['email'].strip().lower() existing = User.query.filter(User.email.ilike(email), User.id != id).first() if existing: raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f'El email {email} ya está registrado por otro usuario.') user.email = email if 'role_id' in data: r_id = data['role_id'] user.role_id = int(r_id) if (r_id and str(r_id).strip().isdigit()) else None if user.role_id: r_obj = Role.query.get(user.role_id) if r_obj: user.role = r_obj.name.upper() if 'is_active' in data: val = data['is_active'] user.is_active = val in [True, 'true', '1', 'on'] db.session.commit() return { 'status': 'success', 'message': 'Usuario actualizado exitosamente.', 'user': user.to_dict() } @admin_router.post("/users/{id}/toggle") def toggle_user( id: int, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Conmuta el estado activo/inactivo de un usuario.""" user = User.query.get(id) if not user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario con ID {id} no encontrado.") user.is_active = not user.is_active db.session.commit() return { 'status': 'success', 'id': user.id, 'is_active': user.is_active, 'message': f'Usuario {"activado" if user.is_active else "desactivado"} correctamente.' } @admin_router.delete("/users/{id}") def delete_user( id: int, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Elimina permanentemente un usuario o lo desactiva si tiene reservas.""" user = User.query.get(id) if not user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario con ID {id} no encontrado.") has_reservations = len(user.reservations) if user.reservations else 0 if has_reservations > 0: user.is_active = False db.session.commit() return { 'status': 'success', 'message': 'El usuario tiene reservas asociadas. Se ha desactivado en su lugar.' } db.session.delete(user) db.session.commit() return { 'status': 'success', 'message': 'Usuario eliminado permanentemente.' } # ========================================================= # ROLES & RBAC ENDPOINTS # ========================================================= @admin_router.get("/roles") @admin_router.get("/admin/roles") def get_roles( current_user: User = Depends(get_current_user) ): """Lista todos los roles institucionales y sus matrices de permisos por módulo.""" roles = Role.query.order_by(Role.id.asc()).all() modules = [ {'id': 'dashboard', 'name': 'Dashboard', 'icon': 'bi-speedometer2'}, {'id': 'classrooms', 'name': 'Aulas y Espacios', 'icon': 'bi-door-open'}, {'id': 'schedule', 'name': 'Cronograma', 'icon': 'bi-calendar3'}, {'id': 'subjects', 'name': 'Asignaturas', 'icon': 'bi-book'}, {'id': 'careers', 'name': 'Carreras', 'icon': 'bi-mortarboard'}, {'id': 'commissions', 'name': 'Comisiones', 'icon': 'bi-diagram-3'}, {'id': 'users', 'name': 'Usuarios', 'icon': 'bi-people'}, {'id': 'roles', 'name': 'Roles (RBAC)', 'icon': 'bi-shield-check'}, {'id': 'optimizer', 'name': 'Optimizador IA', 'icon': 'bi-cpu'}, {'id': 'audit', 'name': 'Auditoría', 'icon': 'bi-clipboard-data'} ] roles_data = [] for r in roles: perms_map = {} for p in r.permissions: perms_map[p.module] = p.access_level roles_data.append({ 'id': r.id, 'name': r.name, 'description': r.description or f'Rol institucional de {r.name}', 'is_system': getattr(r, 'is_system', True), 'users_count': len(r.users) if r.users else 0, 'users': [{'id': u.id, 'name': u.name} for u in (r.users or [])], 'permissions': perms_map }) return { 'status': 'success', 'roles': roles_data, 'modules': modules } @admin_router.post("/roles", status_code=status.HTTP_201_CREATED) async def create_role( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Crea un nuevo rol y configura sus permisos iniciales.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) name = (data.get('name') or '').strip() description = (data.get('description') or '').strip() raw_perms = data.get('permissions', {}) if isinstance(raw_perms, str): try: import json permissions = json.loads(raw_perms) except Exception: permissions = {} elif isinstance(raw_perms, dict): permissions = raw_perms else: permissions = {} if not name: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="El nombre del rol es obligatorio.") if Role.query.filter(Role.name.ilike(name)).first(): raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"Ya existe un rol llamado {name}.") role = Role(name=name, description=description, is_system=False) db.session.add(role) db.session.flush() for mod, level in permissions.items(): role.set_permission(mod, level) db.session.commit() return { 'status': 'success', 'message': 'Rol creado exitosamente.', 'role': role.to_dict() } @admin_router.delete("/roles/{id}") def delete_role( id: int, current_user: User = Depends(require_roles(["ADMIN"])) ): """Elimina un rol del sistema.""" role = Role.query.get(id) if not role: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Rol con ID {id} no encontrado.") if getattr(role, 'is_system', False): raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No se pueden eliminar roles protegidos del sistema.") db.session.delete(role) db.session.commit() return { 'status': 'success', 'message': 'Rol eliminado permanentemente.' } # ========================================================= # IMPERSONATION ENDPOINTS # ========================================================= @admin_router.post("/impersonate") @admin_router.post("/admin/impersonate") async def impersonate_user( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Permite a un administrador auditar el sistema bajo la perspectiva de otro usuario.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) user_id = data.get('user_id') or data.get('target_user_id') if not user_id: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Se requiere el user_id para impersonar.") target_user = User.query.get(int(user_id)) if not target_user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario destino #{user_id} no encontrado.") AuditService.log( action='IMPERSONATE_START', module='admin', entity_id=target_user.id, user=current_user, details=f"Administrador {current_user.email} inició sesión temporal como {target_user.email} ({target_user.role})" ) target_dict = { 'id': target_user.id, 'name': target_user.name, 'email': target_user.email, 'role': target_user.role } return { 'status': 'success', 'message': f"Iniciando impersonación de {target_user.name} ({target_user.email})", 'user': target_dict, 'target_user': target_dict } @admin_router.post("/stop-impersonating") @admin_router.post("/admin/stop-impersonating") def stop_impersonating( request: Request, current_user: User = Depends(get_current_user) ): """Restaura la sesión administrativa original.""" real_admin_id = current_user.id token = get_token_from_request(request) if token: try: payload = JWTService.decode_token(token, expected_type='access') if payload.get('sub'): real_admin_id = int(payload['sub']) except Exception: pass AuditService.log( action='IMPERSONATE_END', module='admin', entity_id=current_user.id, user_id=real_admin_id, user_email=current_user.email, details=f"Finalizó la sesión de impersonación." ) return { 'status': 'success', 'message': 'Sesión de impersonación finalizada exitosamente.' } # ========================================================= # SYSTEM RESET ENDPOINT # ========================================================= @admin_router.post("/system/reset") @admin_router.post("/admin/system/reset") @admin_router.post("/admin/settings/reset_system") async def reset_system( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """ Reinicializa el sistema depurando historiales, reservas, espacios y datos académicos. Preserva intactas las cuentas de usuario, roles RBAC y configuraciones institucionales. """ data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) password = str(data.get('password') or '').strip() if not password: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Debe ingresar la contraseña de su usuario administrador para autorizar la reinicialización." ) # Validar contraseña del administrador admin = User.query.get(current_user.id) if not admin or not admin.check_password(password): try: AuditService.log( action='SYSTEM_RESET_FAILED', module='admin', entity_id=current_user.id, user=current_user, details="Intento de reinicialización del sistema cancelado: contraseña incorrecta." ) except Exception: pass raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Contraseña de administrador incorrecta. Operación cancelada por seguridad." ) from app.models.reservation import Reservation from app.models.grade import MilestoneGrade from app.models.enrollment import StudentEnrollment from app.models.classroom import Classroom, ClassroomResource from app.models.building import Building from app.models.subject import Subject, Commission, CommissionTeacher from app.models.career import Career from app.models.academic_term import AcademicTerm from app.models.milestone import AcademicMilestone reservations_deleted = Reservation.query.delete() grades_deleted = MilestoneGrade.query.delete() milestones_deleted = AcademicMilestone.query.delete() enrollments_deleted = StudentEnrollment.query.delete() teachers_deleted = CommissionTeacher.query.delete() commissions_deleted = Commission.query.delete() subjects_deleted = Subject.query.delete() careers_deleted = Career.query.delete() resources_deleted = ClassroomResource.query.delete() classrooms_deleted = Classroom.query.delete() buildings_deleted = Building.query.delete() terms_deleted = AcademicTerm.query.delete() moodle_deleted = MoodleSyncTask.query.delete() db.session.commit() AuditService.log( action='SYSTEM_RESET', module='admin', entity_id=current_user.id, user=current_user, details=f"Sistema reinicializado. Purgados: {reservations_deleted} reservas, {classrooms_deleted} aulas, {subjects_deleted} materias." ) return { 'status': 'success', 'message': 'El sistema ha sido reinicializado exitosamente. Todos los usuarios, roles y configuraciones fueron preservados.', 'purged': { 'reservations': reservations_deleted, 'grades': grades_deleted, 'milestones': milestones_deleted, 'enrollments': enrollments_deleted, 'teachers_assignments': teachers_deleted, 'commissions': commissions_deleted, 'subjects': subjects_deleted, 'careers': careers_deleted, 'classrooms': classrooms_deleted, 'buildings': buildings_deleted, 'academic_terms': terms_deleted, 'sync_tasks': moodle_deleted } } # ========================================================= # AUDIT LOGS ENDPOINTS # ========================================================= @admin_router.get("/audit-logs") @admin_router.get("/audit_logs", include_in_schema=False) @admin_router.get("/admin/audit-logs", include_in_schema=False) def get_audit_logs( module: Optional[str] = Query(None), action: Optional[str] = Query(None), user_id: Optional[int] = Query(None), limit: int = Query(50), current_user: User = Depends(require_roles(["ADMIN"])) ): """Consulta la bitácora inmutable de auditoría del sistema.""" logs = AuditService.get_logs(module=module, action=action, user_id=user_id, limit=limit) distinct_modules = [m[0] for m in db.session.query(AuditLog.module).distinct().all() if m[0]] distinct_actions = [a[0] for a in db.session.query(AuditLog.action).distinct().all() if a[0]] all_modules = sorted(list(set(distinct_modules + ['auth', 'admin', 'reservations', 'classrooms', 'buildings', 'academic', 'moodle']))) all_actions = sorted(list(set(distinct_actions + ['LOGIN', 'LOGIN_FAILED', 'LOGOUT', 'CREATE', 'UPDATE', 'DELETE', 'IMPERSONATE_START', 'IMPERSONATE_END']))) return { 'status': 'success', 'total': len(logs), 'logs': [log.to_dict() for log in logs], 'modules': all_modules, 'actions': all_actions, 'pagination': { 'page': 1, 'per_page': limit, 'total': len(logs) } } # ========================================================= # USER AUXILIARY ENDPOINTS # ========================================================= @admin_router.get("/users/document-types") @admin_router.get("/admin/users/document-types") def get_document_types(): """Retorna los tipos de documentos válidos.""" return { 'status': 'success', 'document_types': DOCUMENT_TYPES } @admin_router.post("/users/{id}/password") @admin_router.put("/users/{id}/password") @admin_router.post("/admin/users/{id}/password") @admin_router.put("/admin/users/{id}/password") async def reset_user_password( id: int, request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Permite a los administradores institucionales restablecer la contraseña de un usuario.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) new_password = str(data.get('password') or data.get('new_password') or '').strip() if not new_password or len(new_password) < 6: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="La nueva contraseña debe contener al menos 6 caracteres." ) user = User.query.get(id) if not user: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Usuario con ID {id} no encontrado.") user.set_password(new_password) db.session.commit() AuditService.log( action='RESET_PASSWORD', module='users', entity_id=user.id, user=current_user, details=f"Contraseña restablecida para el usuario {user.email}" ) return { 'status': 'success', 'message': f'Contraseña restablecida exitosamente para {user.name}.', 'user_id': user.id } # ========================================================= # GLOBAL SYSTEM SETTINGS (SMTP, AUTH, GOOGLE, MOODLE, UI) # ========================================================= @admin_router.get("/settings/all") @admin_router.get("/admin/settings/all") def get_all_settings(current_user: User = Depends(require_roles(["ADMIN"]))): """Retorna todas las configuraciones agrupadas por módulo, enmascarando contraseñas.""" smtp_config = { 'host': SystemSetting.get_value('smtp_host', 'smtp.gmail.com'), 'port': int(SystemSetting.get_value('smtp_port', 587) or 587), 'user': SystemSetting.get_value('smtp_user', ''), 'password': SystemSetting.get_masked_value('smtp_password', ''), 'security': SystemSetting.get_value('smtp_security', 'STARTTLS'), 'sender_email': SystemSetting.get_value('smtp_sender_email', 'notificaciones@unicaba.edu.ar'), 'sender_name': SystemSetting.get_value('smtp_sender_name', 'Edu-Space UniCABA'), 'enabled': SystemSetting.get_value('smtp_enabled', 'true') in ['true', 'True', '1', True] } auth_providers = { 'local': SystemSetting.get_value('auth_local_enabled', 'true') in ['true', 'True', '1', True], 'local_enabled': SystemSetting.get_value('auth_local_enabled', 'true') in ['true', 'True', '1', True], 'google': SystemSetting.get_value('auth_google_enabled', 'false') in ['true', 'True', '1', True], 'google_enabled': SystemSetting.get_value('auth_google_enabled', 'false') in ['true', 'True', '1', True], 'moodle': SystemSetting.get_value('auth_moodle_enabled', 'false') in ['true', 'True', '1', True], 'moodle_enabled': SystemSetting.get_value('auth_moodle_enabled', 'false') in ['true', 'True', '1', True] } google_oauth = { 'client_id': SystemSetting.get_value('google_client_id', ''), 'client_secret': SystemSetting.get_masked_value('google_client_secret', ''), 'callback_url': SystemSetting.get_value('google_callback_url', '/auth/google/callback'), 'allowed_domains': SystemSetting.get_value('google_allowed_domains', 'unicaba.edu.ar,lasalle.edu.ar') } moodle_config = { 'server_url': SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle'), 'ws_token': SystemSetting.get_masked_value('moodle_ws_token', ''), 'timeout': int(SystemSetting.get_value('moodle_timeout', 10) or 10), 'auto_sync_enabled': SystemSetting.get_value('moodle_auto_sync_enabled', 'true') in ['true', 'True', '1', True], 'sync_interval_minutes': int(SystemSetting.get_value('moodle_sync_interval_minutes', 15) or 15) } ui_config = { 'show_role_banner': SystemSetting.get_value('dashboard_role_banner_enabled', 'true') in ['true', 'True', '1', True] } return { 'status': 'success', 'settings': { 'smtp': smtp_config, 'auth_providers': auth_providers, 'google_oauth': google_oauth, 'moodle': moodle_config, 'ui': ui_config } } @admin_router.post("/settings/smtp") @admin_router.post("/admin/settings/smtp") async def update_smtp_settings( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Actualiza la configuración del servidor de correo SMTP.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) host = str(data.get('host', '')).strip() port = str(data.get('port', 587)).strip() user = str(data.get('user', '')).strip() password = str(data.get('password', '')).strip() security = str(data.get('security', 'STARTTLS')).strip().upper() sender_email = str(data.get('sender_email', '')).strip() sender_name = str(data.get('sender_name', 'Edu-Space UniCABA')).strip() enabled = 'true' if data.get('enabled') in [True, 'true', '1', 'on'] else 'false' SystemSetting.set_value('smtp_host', host, 'Host del servidor SMTP', category='smtp') SystemSetting.set_value('smtp_port', port, 'Puerto del servidor SMTP', category='smtp') SystemSetting.set_value('smtp_user', user, 'Usuario o email de autenticación SMTP', category='smtp') if password and password != '••••••••••••': SystemSetting.set_encrypted_value('smtp_password', password, 'Contraseña de autenticación SMTP cifrada', category='smtp') SystemSetting.set_value('smtp_security', security, 'Protocolo de seguridad SMTP (NONE, SSL, STARTTLS)', category='smtp') SystemSetting.set_value('smtp_sender_email', sender_email, 'Email remitente oficial', category='smtp') SystemSetting.set_value('smtp_sender_name', sender_name, 'Nombre remitente oficial', category='smtp') SystemSetting.set_value('smtp_enabled', enabled, 'Habilitación del servicio SMTP', category='smtp') AuditService.log( action='UPDATE_SMTP_SETTINGS', module='settings', user=current_user, details=f"Configuración SMTP actualizada (Host: {host}:{port}, Remitente: {sender_email})" ) return { 'status': 'success', 'message': 'Configuración de servidor SMTP guardada exitosamente.' } @admin_router.post("/settings/smtp/test") @admin_router.post("/admin/settings/smtp/test") async def test_smtp_connection( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Prueba en tiempo real la conexión al servidor SMTP.""" import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) test_recipient = str(data.get('test_email') or current_user.email).strip() host = data.get('host') or SystemSetting.get_value('smtp_host', 'smtp.gmail.com') port = int(data.get('port') or SystemSetting.get_value('smtp_port', 587) or 587) user = data.get('user') or SystemSetting.get_value('smtp_user', '') password = data.get('password') if not password or password == '••••••••••••': password = SystemSetting.get_decrypted_value('smtp_password', '') security_val = data.get('security') or SystemSetting.get_value('smtp_security', 'STARTTLS') or 'STARTTLS' security = str(security_val).upper() sender_email = str(data.get('sender_email') or SystemSetting.get_value('smtp_sender_email', user) or 'notificaciones@unicaba.edu.ar') sender_name = data.get('sender_name') or SystemSetting.get_value('smtp_sender_name', 'Edu-Space UniCABA') if not host or not port: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Host y puerto SMTP son requeridos.") try: if security == 'SSL': server = smtplib.SMTP_SSL(host, port, timeout=10) else: server = smtplib.SMTP(host, port, timeout=10) if security == 'STARTTLS': server.ehlo() server.starttls() server.ehlo() if user and password: server.login(user, password) if test_recipient: msg = MIMEMultipart('alternative') msg['Subject'] = '✔ Prueba de Conexión SMTP - Edu-Space UniCABA' msg['From'] = f"{sender_name} <{sender_email}>" msg['To'] = test_recipient html_content = f"""

Edu-Space UniCABA

Prueba de Conexión SMTP Exitosa

Este es un mensaje de prueba para confirmar que los parámetros del servidor de correo han sido configurados correctamente.

Host: {host}:{port}
Seguridad: {security}
Usuario: {user or '(Sin autenticación)'}
Remitente: {sender_email}

Enviado desde el Panel de Administración de UniCABA.

""" msg.attach(MIMEText(html_content, 'html')) server.sendmail(sender_email, [test_recipient], msg.as_string()) server.quit() return { 'status': 'success', 'message': f'Conexión SMTP exitosa. Correo de prueba enviado a {test_recipient}.' } except Exception as e: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f'Fallo en la prueba de conexión SMTP: {str(e)}') @admin_router.post("/settings/auth-providers") @admin_router.post("/admin/settings/auth-providers") async def update_auth_providers( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Habilita o deshabilita los proveedores de autenticación del sistema.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) local_input = data.get('local_enabled') if 'local_enabled' in data else data.get('local', True) google_input = data.get('google_enabled') if 'google_enabled' in data else data.get('google', False) moodle_input = data.get('moodle_enabled') if 'moodle_enabled' in data else data.get('moodle', False) local_val = 'true' if local_input in [True, 'true', '1', 'on'] else 'false' google_val = 'true' if google_input in [True, 'true', '1', 'on'] else 'false' moodle_val = 'true' if moodle_input in [True, 'true', '1', 'on'] else 'false' SystemSetting.set_value('auth_local_enabled', local_val, 'Habilitar login nativo con usuario/contraseña', category='sso') SystemSetting.set_value('auth_google_enabled', google_val, 'Habilitar login SSO con Google Workspace', category='sso') SystemSetting.set_value('auth_moodle_enabled', moodle_val, 'Habilitar login delegado con Moodle', category='sso') AuditService.log( action='UPDATE_AUTH_PROVIDERS', module='settings', user=current_user, details=f"Métodos de login actualizados: Local={local_val}, Google={google_val}, Moodle={moodle_val}" ) return { 'status': 'success', 'message': 'Métodos de autenticación actualizados correctamente.', 'auth_providers': { 'local': local_val == 'true', 'local_enabled': local_val == 'true', 'google': google_val == 'true', 'google_enabled': google_val == 'true', 'moodle': moodle_val == 'true', 'moodle_enabled': moodle_val == 'true' } } @admin_router.post("/settings/ui") @admin_router.post("/admin/settings/ui") async def update_ui_settings( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Actualiza preferencias de interfaz institucional.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) show_banner_input = data.get('show_role_banner') if show_banner_input is None: show_banner_input = data.get('dashboard_role_banner_enabled') show_val = 'true' if show_banner_input in [True, 'true', '1', 'on', 1] else 'false' SystemSetting.set_value('dashboard_role_banner_enabled', show_val, 'Mostrar banner de saludo y selector de rol en Dashboard', category='ui') AuditService.log( action='UPDATE_UI_SETTINGS', module='settings', user=current_user, details=f"Preferencia de interfaz actualizada: banner_saludo_rol={show_val}" ) return { 'status': 'success', 'message': 'Preferencia de interfaz guardada correctamente.', 'ui': { 'show_role_banner': show_val == 'true' } } @admin_router.get("/settings/demo-mode") @admin_router.get("/admin/settings/demo-mode") def get_demo_mode_status(current_user: User = Depends(require_roles(["ADMIN"]))): """Consulta el estado del modo demostración.""" demo_emails = ['bedelia@edu-space.com', 'docente@edu-space.com', 'alumno@edu-space.com'] demo_access_enabled = SystemSetting.get_value('demo_access_enabled', 'true') in ['true', 'True', '1', True] demo_users = User.query.filter(func.lower(User.email).in_(demo_emails)).all() demo_accounts_active = any(u.is_active for u in demo_users) return { 'status': 'success', 'demo_access_enabled': demo_access_enabled, 'demo_accounts_active': demo_accounts_active } @admin_router.post("/settings/demo-mode") @admin_router.post("/admin/settings/demo-mode") async def toggle_demo_mode( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Habilita o deshabilita el modo demo institucional.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) demo_emails = ['bedelia@edu-space.com', 'docente@edu-space.com', 'alumno@edu-space.com'] if 'enabled' in data: target_state = data['enabled'] in [True, 'true', '1', 'on'] else: current_state = SystemSetting.get_value('demo_access_enabled', 'true') in ['true', 'True', '1', True] target_state = not current_state SystemSetting.set_value( 'demo_access_enabled', 'true' if target_state else 'false', 'Acceso Rápido Demo en pantalla de Login', category='security' ) demo_users = User.query.filter(func.lower(User.email).in_(demo_emails)).all() for u in demo_users: u.is_active = target_state db.session.commit() msg_detail = ( 'Acceso Rápido Demo habilitado y cuentas Bedelía, Docente y Alumno activadas' if target_state else 'Acceso Rápido Demo deshabilitado y cuentas default (Bedelía, Docente, Alumno) desactivadas' ) AuditService.log( action='ENABLE_DEMO_ACCOUNTS' if target_state else 'DISABLE_DEMO_ACCOUNTS', module='settings', user=current_user, details=msg_detail ) return { 'status': 'success', 'message': msg_detail, 'demo_access_enabled': target_state, 'demo_accounts_active': target_state } @admin_router.post("/settings/google-oauth") @admin_router.post("/admin/settings/google-oauth") async def update_google_oauth_settings( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Actualiza las credenciales de Google OAuth2.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) client_id = str(data.get('client_id', '')).strip() client_secret = str(data.get('client_secret', '')).strip() allowed_domains = str(data.get('allowed_domains', 'unicaba.edu.ar')).strip() callback_url = str(data.get('callback_url', '/auth/google/callback')).strip() SystemSetting.set_value('google_client_id', client_id, 'Client ID de Google OAuth2', category='sso_google') if client_secret and client_secret != '••••••••••••': SystemSetting.set_encrypted_value('google_client_secret', client_secret, 'Client Secret de Google OAuth2 cifrado', category='sso_google') SystemSetting.set_value('google_allowed_domains', allowed_domains, 'Dominios permitidos separados por coma', category='sso_google') SystemSetting.set_value('google_callback_url', callback_url, 'Ruta de callback autorizada de Google OAuth2', category='sso_google') AuditService.log( action='UPDATE_GOOGLE_OAUTH_SETTINGS', module='settings', user=current_user, details="Credenciales de Google OAuth2 actualizadas" ) return { 'status': 'success', 'message': 'Credenciales de Google OAuth2 guardadas correctamente.' } @admin_router.post("/settings/moodle") @admin_router.post("/admin/settings/moodle") async def update_moodle_settings( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Actualiza los parámetros de conexión con Moodle 4.1.""" data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) server_url = str(data.get('server_url', 'http://10.0.0.207/moodle')).strip().rstrip('/') ws_token = str(data.get('ws_token', '')).strip() timeout = str(data.get('timeout', 10)).strip() auto_sync = 'true' if data.get('auto_sync_enabled', True) in [True, 'true', '1', 'on'] else 'false' sync_interval = str(data.get('sync_interval_minutes', 15)).strip() SystemSetting.set_value('moodle_server_url', server_url, 'URL base del servidor Moodle', category='sso_moodle') if ws_token and ws_token != '••••••••••••': SystemSetting.set_encrypted_value('moodle_ws_token', ws_token, 'Token de Web Services de Moodle cifrado', category='sso_moodle') SystemSetting.set_value('moodle_timeout', timeout, 'Timeout en segundos para llamadas REST a Moodle', category='sso_moodle') SystemSetting.set_value('moodle_auto_sync_enabled', auto_sync, 'Habilitación de sincronización periódica automática', category='sso_moodle') SystemSetting.set_value('moodle_sync_interval_minutes', sync_interval, 'Intervalo en minutos para sincronización periódica', category='sso_moodle') AuditService.log( action='UPDATE_MOODLE_SETTINGS', module='settings', user=current_user, details=f"Parámetros de Moodle actualizados (Servidor: {server_url})" ) return { 'status': 'success', 'message': 'Configuración de Moodle 4.1 guardada correctamente.' } @admin_router.post("/settings/moodle/test") @admin_router.post("/admin/settings/moodle/test") async def test_moodle_connection( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Prueba la conectividad y validez del WebService de Moodle 4.1.""" from app.services.moodle_client import moodle_client data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) server_url = data.get('server_url') token = data.get('ws_token') result = moodle_client.test_connection(server_url=server_url, token=token) if result.get('success'): return result else: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=result.get('message', 'Fallo de conexión a Moodle')) @admin_router.get("/settings/moodle/api-key") @admin_router.get("/admin/settings/moodle/api-key") def get_moodle_api_key(current_user: User = Depends(require_roles(["ADMIN"]))): """Retorna o genera la API Key institucional para Moodle.""" import secrets api_key = SystemSetting.get_decrypted_value('moodle_api_key', '') if not api_key: api_key = secrets.token_hex(32) SystemSetting.set_encrypted_value('moodle_api_key', api_key, 'Clave API secreta para integración bidireccional segura con Moodle', category='sso_moodle') return { 'status': 'success', 'api_key': api_key, 'header_name': 'X-API-Key', 'sync_endpoint': '/api/v1/admin/settings/moodle/sync' } @admin_router.post("/settings/moodle/api-key/regenerate") @admin_router.post("/admin/settings/moodle/api-key/regenerate") def regenerate_moodle_api_key(current_user: User = Depends(require_roles(["ADMIN"]))): """Regenera una nueva clave API de comunicación bidireccional con Moodle.""" import secrets new_key = secrets.token_hex(32) SystemSetting.set_encrypted_value('moodle_api_key', new_key, 'Clave API secreta para integración bidireccional segura con Moodle', category='sso_moodle') return { 'status': 'success', 'api_key': new_key, 'message': 'Clave API de Moodle regenerada exitosamente.' } @admin_router.post("/moodle/sync-from-moodle") @admin_router.post("/settings/moodle/sync") @admin_router.post("/admin/settings/moodle/sync") def sync_data_from_moodle(current_user: User = Depends(require_roles(["ADMIN"]))): """Ejecuta la sincronización bidireccional desde Moodle hacia la plataforma.""" from app.services.moodle_client import moodle_client try: res = moodle_client.sync_from_moodle_to_app() return res except Exception as e: raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error al sincronizar desde Moodle: {str(e)}") # ========================================================= # MOODLE ASYNC QUEUE ENDPOINTS # ========================================================= @admin_router.get("/moodle/queue/stats") @admin_router.get("/admin/moodle/queue/stats") def get_moodle_queue_stats(current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))): """Estadísticas en tiempo real de la cola asíncrona de Moodle.""" stats = moodle_queue_service.get_queue_summary() return { 'status': 'success', 'data': stats } @admin_router.get("/moodle/queue/tasks") @admin_router.get("/admin/moodle/queue/tasks") def get_moodle_queue_tasks( status_filter: Optional[str] = Query(None, alias="status"), page: int = Query(1), per_page: int = Query(20), current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Listado paginado de tareas en cola con filtro por estado.""" query = MoodleSyncTask.query if status_filter: query = query.filter_by(status=status_filter.strip().upper()) total = query.count() tasks = query.order_by(MoodleSyncTask.created_at.desc()).offset((page - 1) * per_page).limit(per_page).all() return { 'status': 'success', 'total': total, 'page': page, 'per_page': per_page, 'tasks': [t.to_dict() for t in tasks] } @admin_router.post("/moodle/queue/process-now") @admin_router.post("/admin/moodle/queue/process-now") async def process_moodle_queue_now( request: Request, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Procesamiento manual e inmediato del lote pendiente en la cola de Moodle.""" batch_size = 50 try: body = await request.json() batch_size = int(body.get('batch_size', 50)) except Exception: pass results = moodle_queue_service.process_pending_tasks(batch_size=batch_size) return { 'status': 'success', 'message': f"Sincronización procesada: {results['succeeded']} exitosas, {results['failed']} a DLQ, {results['retrying']} reintentando.", 'results': results } @admin_router.post("/moodle/queue/tasks/{task_id}/retry") @admin_router.post("/admin/moodle/queue/tasks/{task_id}/retry") def retry_moodle_queue_task( task_id: int, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Reintenta una tarea específica en Dead Letter Queue.""" success = moodle_queue_service.retry_task(task_id) if success: return { 'status': 'success', 'message': f'Tarea #{task_id} reiniciada a estado PENDIENTE para el próximo ciclo.' } else: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f'No se encontró la tarea #{task_id}.') @admin_router.post("/moodle/queue/retry-all") @admin_router.post("/admin/moodle/queue/retry-all") def retry_all_failed_moodle_tasks(current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))): """Reintenta todas las tareas fallidas en DLQ.""" count = moodle_queue_service.retry_all_failed() return { 'status': 'success', 'message': f'Se reiniciaron {count} tareas fallidas a estado PENDIENTE.' } # ========================================================= # GOOGLE SHEETS CONFIG & ACADEMIC RESET # ========================================================= @admin_router.get("/sheets-config") @admin_router.get("/admin/sheets-config") def get_sheets_config(current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))): """Obtiene la configuración actual del Google Sheet para sincronización.""" from app.services.sheets_importer import BASE_CSV_URL, normalize_sheets_url import os db_url = SystemSetting.get_value('google_sheets_url') env_url = os.getenv('GOOGLE_SHEETS_URL') active_url = db_url or env_url or BASE_CSV_URL source = 'database' if db_url else ('environment' if env_url else 'default') return { 'status': 'success', 'config': { 'active_url': active_url, 'source': source, 'db_url': db_url, 'default_url': BASE_CSV_URL, 'normalized_url': normalize_sheets_url(active_url) } } @admin_router.post("/sheets-config") @admin_router.post("/admin/sheets-config") async def update_sheets_config( request: Request, current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"])) ): """Actualiza la URL del Google Sheet institucional.""" from app.services.sheets_importer import normalize_sheets_url data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) url = (data.get('url') or data.get('google_sheets_url') or '').strip() if not url: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="La URL de Google Sheets no puede estar vacía.") normalized = normalize_sheets_url(url) SystemSetting.set_value('google_sheets_url', url, 'URL del Google Sheet académico configurada desde panel') return { 'status': 'success', 'message': 'Configuración de Google Sheets guardada correctamente.', 'config': { 'active_url': url, 'normalized_url': normalized, 'source': 'database' } } @admin_router.post("/reset-academic-data") @admin_router.post("/admin/reset-academic-data") async def reset_academic_data( request: Request, current_user: User = Depends(require_roles(["ADMIN"])) ): """Herramienta de limpieza/purga de datos académicos para pruebas del importador.""" from scripts.reset_academic_data import execute_academic_reset data = {} try: data = await request.json() except Exception: form = await request.form() data = dict(form) reset_all = data.get('all', False) in [True, 'true', '1', 'on'] reset_reservations = reset_all or data.get('reservations', True) in [True, 'true', '1', 'on'] reset_commissions = reset_all or data.get('commissions', False) in [True, 'true', '1', 'on'] reset_subjects = reset_all or data.get('subjects', False) in [True, 'true', '1', 'on'] reset_careers = reset_all or data.get('careers', False) in [True, 'true', '1', 'on'] reset_classrooms = reset_all or data.get('classrooms', False) in [True, 'true', '1', 'on'] if reset_all: reset_reservations = True reset_commissions = True reset_subjects = True reset_careers = True reset_classrooms = True result = execute_academic_reset( reset_reservations=reset_reservations, reset_commissions=reset_commissions, reset_subjects=reset_subjects, reset_careers=reset_careers, reset_classrooms=reset_classrooms ) if result.get('success'): AuditService.log( action='ACADEMIC_DATA_PURGE', module='admin', user=current_user, details=f"Purga académica ejecutada: {result.get('deleted')}" ) return { 'status': 'success', 'message': result.get('message', 'Datos reiniciados con éxito.'), 'deleted': result.get('deleted', {}) } else: raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=result.get('error', 'Error durante la purga de datos.')) # ========================================================= # CLIENT ERROR LOGGING ENDPOINT # ========================================================= @admin_router.post("/log-error") @admin_router.post("/admin/log-error") async def log_client_error(request: Request): """Registra incidentes no controlados provenientes del frontend BFF en AuditLog.""" data = {} try: data = await request.json() except Exception: pass incident_id = data.get('incident_id') error_title = data.get('error_title', 'Error de Sistema') error_message = data.get('error_message', 'Error desconocido') status_code_val = data.get('status_code', 500) path = data.get('path', '') user_email = data.get('user_email') or 'anonymous' ip_address = data.get('ip_address') or (request.client.host if request.client else '127.0.0.1') stack = data.get('stack', '') details = { 'incident_id': incident_id, 'title': error_title, 'message': error_message, 'status_code': status_code_val, 'path': path, 'stack_preview': stack[:500] if stack else '' } AuditService.log( action='SYSTEM_ERROR', module='system', user_email=user_email, ip_address=ip_address, details=details, status='failed' ) return { 'status': 'success', 'logged': True, 'incident_id': incident_id }