1444 lines
55 KiB
Python
1444 lines
55 KiB
Python
"""
|
|
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
|
|
import math
|
|
|
|
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_request_payload, 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"),
|
|
page: int = Query(1, ge=1),
|
|
per_page: int = Query(25, ge=1, le=200),
|
|
all_records: bool = Query(False, alias="all"),
|
|
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
|
|
):
|
|
"""Lista usuarios del sistema con filtros de búsqueda, rol y paginación server-side."""
|
|
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)
|
|
|
|
total = query.count()
|
|
roles = Role.query.order_by(Role.name.asc()).all()
|
|
roles_data = [{'id': r.id, 'name': r.name} for r in roles]
|
|
|
|
if all_records:
|
|
users = query.order_by(User.id.asc()).limit(1000).all()
|
|
pages = 1
|
|
page = 1
|
|
per_page = total or 1
|
|
else:
|
|
pages = math.ceil(total / per_page) if total > 0 else 1
|
|
users = query.order_by(User.id.asc()).offset((page - 1) * per_page).limit(per_page).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)
|
|
|
|
return {
|
|
'status': 'success',
|
|
'total': total,
|
|
'page': page,
|
|
'per_page': per_page,
|
|
'pages': pages,
|
|
'has_prev': page > 1,
|
|
'has_next': page < pages,
|
|
'users': users_data,
|
|
'roles': roles_data,
|
|
'document_types': DOCUMENT_TYPES
|
|
}
|
|
|
|
|
|
@admin_router.get("/users/teachers")
|
|
@admin_router.get("/admin/users/teachers")
|
|
def get_teachers(
|
|
search: Optional[str] = Query(None),
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""Retorna una lista ligera de docentes activos para selectores y comisiones."""
|
|
query = User.query.filter(User.is_active == True)
|
|
query = query.filter(
|
|
or_(
|
|
User.role.ilike('%docent%'),
|
|
User.role.ilike('%prof%'),
|
|
User.role.ilike('%bedel%'),
|
|
User.role.ilike('%admin%')
|
|
)
|
|
)
|
|
if search:
|
|
s_clean = search.strip().lower()
|
|
query = query.filter(
|
|
or_(
|
|
User.name.ilike(f'%{s_clean}%'),
|
|
User.email.ilike(f'%{s_clean}%'),
|
|
User.document_number.ilike(f'%{s_clean}%')
|
|
)
|
|
)
|
|
teachers = query.order_by(User.name.asc()).all()
|
|
teachers_data = [
|
|
{
|
|
'id': t.id,
|
|
'name': t.name,
|
|
'email': t.email,
|
|
'document_number': t.document_number,
|
|
'role': t.role
|
|
}
|
|
for t in teachers
|
|
]
|
|
return {
|
|
'status': 'success',
|
|
'total': len(teachers_data),
|
|
'teachers': teachers_data
|
|
}
|
|
|
|
|
|
@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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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),
|
|
search: Optional[str] = Query(None),
|
|
page: int = Query(1, ge=1),
|
|
per_page: int = Query(25, ge=1, le=100),
|
|
limit: Optional[int] = Query(None),
|
|
current_user: User = Depends(require_roles(["ADMIN"]))
|
|
):
|
|
"""Consulta la bitácora inmutable de auditoría del sistema con paginación server-side."""
|
|
actual_per_page = limit if (limit and not per_page) else per_page
|
|
logs, total = AuditService.get_paginated_logs(
|
|
module=module,
|
|
action=action,
|
|
user_id=user_id,
|
|
search=search,
|
|
page=page,
|
|
per_page=actual_per_page
|
|
)
|
|
pages = math.ceil(total / actual_per_page) if total > 0 else 1
|
|
|
|
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': total,
|
|
'logs': [log.to_dict() for log in logs],
|
|
'modules': all_modules,
|
|
'actions': all_actions,
|
|
'pagination': {
|
|
'page': page,
|
|
'per_page': actual_per_page,
|
|
'total': total,
|
|
'pages': pages,
|
|
'has_prev': page > 1,
|
|
'has_next': page < pages
|
|
}
|
|
}
|
|
|
|
|
|
# =========================================================
|
|
# 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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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"""
|
|
<div style="font-family: Arial, sans-serif; max-width: 550px; margin: auto; padding: 20px; border: 1px solid #e2e8f0; border-radius: 8px;">
|
|
<h2 style="color: #B43E8E; margin-bottom: 10px;">Edu-Space UniCABA</h2>
|
|
<h3 style="color: #1e293b; margin-top: 0;">Prueba de Conexión SMTP Exitosa</h3>
|
|
<p style="color: #475569;">Este es un mensaje de prueba para confirmar que los parámetros del servidor de correo han sido configurados correctamente.</p>
|
|
<div style="background-color: #f8fafc; padding: 12px; border-radius: 6px; font-size: 13px; color: #334155;">
|
|
<strong>Host:</strong> {host}:{port}<br>
|
|
<strong>Seguridad:</strong> {security}<br>
|
|
<strong>Usuario:</strong> {user or '(Sin autenticación)'}<br>
|
|
<strong>Remitente:</strong> {sender_email}
|
|
</div>
|
|
<p style="font-size: 11px; color: #94a3b8; margin-top: 20px;">Enviado desde el Panel de Administración de UniCABA.</p>
|
|
</div>
|
|
"""
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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 = await get_request_payload(request)
|
|
|
|
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
|
|
}
|