diff --git a/.vscode/settings.json b/.vscode/settings.json index 5a0431e..02dc195 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,7 @@ { - "python.defaultInterpreterPath": "${workspaceFolder}\\venv\\Scripts\\python.exe", + "python.defaultInterpreterPath": "${workspaceFolder}\\backend\\venv\\Scripts\\python.exe", "python.analysis.extraPaths": [ - "${workspaceFolder}\\venv\\Lib\\site-packages" + "${workspaceFolder}\\backend", + "${workspaceFolder}\\backend\\venv\\Lib\\site-packages" ] } diff --git a/CHANGELOG.md b/CHANGELOG.md index cf52540..81e9c66 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,18 @@ El formato está basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1 - **Sincronización Continua Moodle (Fase 6):** Automatización de workers persistentes en background para el procesamiento continuo de la cola de Web Services Moodle 4.1. - **Pruebas de Carga y Hardening (Fase 6):** Pruebas de estrés de concurrencia y validación final de producción. +## [3.5.4] - 2026-10-16 +### Added +- Integración completa bidireccional con el Web Service `moodle_api` de Moodle Local (`10.0.0.207`) usando token dedicado `810428346d3601c68a37a315fcba8d4391629f46`. +- Soporte para autenticación delegada Moodle (`/api/v1/auth/moodle`) con fallback dinámico entre `moodle_api` y `moodle_mobile_app`, y matching por número de documento (DNI) y prefijo de usuario. +- Endpoint administrativo `POST /api/v1/admin/moodle/sync-from-moodle` para sincronización directa de usuarios, roles y catálogo de cursos desde Moodle hacia la base de datos `classrooms_db`. +- Métodos `get_courses()`, `get_categories()` y `sync_from_moodle_to_app()` en `MoodleClient`. +- Otorgamiento de capability `moodle/webservice:createtoken` al rol autenticado de Moodle en `10.0.0.207` y habilitación de Web Services para login token. + +### Fixed +- Corrección de firma en `MoodleClient.test_connection(server_url, token)` que causaba TypeError al recibir argumentos opcionales desde el panel de ajustes. +- Solución al error de resolución de módulos de Pyright/Pylance en `scripts/import_moodle_to_app.py` mediante configuración de `.vscode/settings.json` y carga modular dinámica. + ## [3.5.3] - 2026-10-16 ### Agregado & Corregido (Sincronización de Roles Moodle-App, Limpieza Admin & Hardening) - **Importador y Sincronización de Roles con la App (`scripts/import_moodle_to_app.py` & flag `--sync-app`):** diff --git a/MEMORY.md b/MEMORY.md index 94b8d20..b951c66 100644 --- a/MEMORY.md +++ b/MEMORY.md @@ -233,8 +233,21 @@ Memoria del proyecto entre sesiones para la rama `dev`. - Importados **653 usuarios únicos** (15 Docentes y 640 Alumnos) a la base de datos de producción con contraseñas PBKDF2 coincidentes con el DNI, habilitando de inmediato la asignación de comisiones, reservas e inscripciones. - **Desmatriculación de Cuenta Admin en Moodle Local (`10.0.0.207`)**: - Removidas todas las matriculaciones de `admin` en cursos académicos y generales (quedando con 0 enrolments). - - Eliminado el curso dummy `Prueba matriculaciones masivas` (ID 22). + - **Sprint v3.5.4: Conexión Moodle API, Login Delegado y Sincronización Moodle -> Edu Space**: + - **Habilitación de Web Services para Tokens de Usuario en Moodle Local (`10.0.0.207`)**: + - Asignada la capability `moodle/webservice:createtoken` al rol 7 (`user` / usuario autenticado) en `mdl_role_capabilities`. + - Habilitado `enablemobilewebservice = 1` y servicio `moodle_mobile_app` (`enabled = 1`). + - Verificada la emisión de tokens exitosa para usuarios individuales (incluyendo `34247025`) tanto contra `moodle_api` como contra `moodle_mobile_app`. + - **Conexión de Admin Edu Space con Moodle Local**: + - Configurado el token `810428346d3601c68a37a315fcba8d4391629f46` de `moodle_api` en `system_settings` de `classrooms_db`. + - Habilitada `auth_moodle_enabled = 'true'` y `moodle_server_url = 'http://10.0.0.207/moodle'`. + - Adaptado el endpoint de autenticación `/api/v1/auth/moodle` para autenticar con `moodle_api` (con fallback a `moodle_mobile_app`) y hacer matching de cuenta local por número de documento (DNI). + - **Sincronización Bidireccional Moodle -> Edu Space**: + - Agregado el endpoint administrativo `POST /api/v1/admin/moodle/sync-from-moodle`. + - Incorporados los métodos `get_courses()`, `get_categories()` y `sync_from_moodle_to_app()` en `MoodleClient`. + - **Resolución de Lints de la IDE**: + - Ajustado `.vscode/settings.json` y carga modular dinámica en `scripts/import_moodle_to_app.py`. ## Próximos pasos -1. Validar la integración del frontend de Admin Edu Space con la API de Moodle local utilizando los usuarios y asignaturas replicadas. +1. Monitorear los inicios de sesión delegados en producción con cuentas docentes y estudiantiles. 2. Continuar con el roadmap hacia la Fase 6 de hardening y orquestación de servicios en Docker. \ No newline at end of file diff --git a/README.md b/README.md index bd39439..8bc1115 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Plataforma integral de gestión áulica, asignación de espacios, control de hor El proyecto se basa en una arquitectura **desacoplada (Frontend / Backend)** en formato monorepo. -**Versión Actual:** `3.5.3` (Sincronización de Roles Moodle-App, Limpieza Admin & Hardening) +**Versión Actual:** `3.5.4` (Integración Moodle API Bidireccional & Login Delegado) **Institución:** Universidad de la Ciudad de Buenos Aires (UniCABA) **Entorno de Producción:** `https://eduspace.oemspot.com.ar` (LXC `10.0.0.217`) diff --git a/ROADMAP.md b/ROADMAP.md index 0909468..894d5a6 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ ## Gestión de Espacios Áulicos, Asignación de Comisiones y Operatoria de Bedelía **Institución:** Universidad de la Ciudad de Buenos Aires (UniCABA) -**Versión:** 3.5.3 (Sincronización de Roles Moodle-App, Limpieza Admin & Hardening) +**Versión:** 3.5.4 (Integración Moodle API Bidireccional & Login Delegado) **Fecha de Actualización:** 16 de Octubre de 2026 **Rama Base:** `dev` diff --git a/backend/app/__init__.py b/backend/app/__init__.py index bed0383..6919849 100644 --- a/backend/app/__init__.py +++ b/backend/app/__init__.py @@ -6,7 +6,7 @@ from flask_babel import Babel, gettext as _ from config.config import Config # Initialize extensions -__version__ = "3.5.3" +__version__ = "3.5.4" db = SQLAlchemy() migrate = Migrate() cors = CORS() diff --git a/backend/app/routes/api/admin.py b/backend/app/routes/api/admin.py index 58703ba..af4066e 100644 --- a/backend/app/routes/api/admin.py +++ b/backend/app/routes/api/admin.py @@ -2344,6 +2344,12 @@ def update_moodle_settings(): 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') + if 'auth_moodle_enabled' in data: + auth_enabled = 'true' if data.get('auth_moodle_enabled') in [True, 'true', '1', 'on'] else 'false' + SystemSetting.set_value('auth_moodle_enabled', auth_enabled, 'Habilitar autenticación delegada con Moodle', category='sso_moodle') + if 'service_name' in data: + SystemSetting.set_value('moodle_service_name', str(data['service_name']).strip(), 'Nombre del servicio WebService Moodle', category='sso_moodle') + try: audit = AuditLog( user_id=acting_user.id, @@ -2379,6 +2385,22 @@ def test_moodle_connection(): return jsonify(result), 400 +@api_admin_bp.route('/moodle/sync-from-moodle', methods=['POST']) +@jwt_required +def sync_data_from_moodle(): + """Sincroniza usuarios, roles y catálogo desde Moodle hacia Admin Edu Space.""" + acting_user = getattr(g, 'jwt_user', None) + if not (acting_user and (acting_user.is_admin() or getattr(acting_user, 'role', '').upper() == 'ADMIN')): + return jsonify({'error': 'Forbidden', 'message': 'Acceso no autorizado.'}), 403 + + from app.services.moodle_client import moodle_client + try: + res = moodle_client.sync_from_moodle_to_app() + return jsonify(res), 200 + except Exception as e: + return jsonify({'success': False, 'error': str(e), 'message': f"Error al sincronizar desde Moodle: {str(e)}"}), 500 + + @api_admin_bp.route('/moodle/queue/stats', methods=['GET']) @jwt_required def get_moodle_queue_stats(): diff --git a/backend/app/routes/api/auth.py b/backend/app/routes/api/auth.py index 579c9d2..d968b90 100644 --- a/backend/app/routes/api/auth.py +++ b/backend/app/routes/api/auth.py @@ -247,6 +247,7 @@ def moodle_auth(): return jsonify({'error': 'BadRequest', 'message': 'Usuario y contraseña de Moodle son obligatorios.'}), 400 server_url = SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle').rstrip('/') + service_name = SystemSetting.get_value('moodle_service_name', 'moodle_api') # Authenticate against Moodle login/token.php token_url = f"{server_url}/login/token.php" @@ -254,9 +255,23 @@ def moodle_auth(): resp = requests.post(token_url, data={ 'username': username, 'password': password, - 'service': 'moodle_mobile_app' + 'service': service_name }, timeout=10) res_data = resp.json() + + # Si el servicio principal falla, probar con moodle_mobile_app como alternativa + if ('error' in res_data or 'token' not in res_data) and service_name != 'moodle_mobile_app': + try: + resp_alt = requests.post(token_url, data={ + 'username': username, + 'password': password, + 'service': 'moodle_mobile_app' + }, timeout=10) + alt_data = resp_alt.json() + if 'token' in alt_data: + res_data = alt_data + except Exception: + pass except Exception as e: logger.error(f"[MoodleAuth] Connection error to Moodle server: {e}") return jsonify({'error': 'ServiceUnavailable', 'message': 'No se pudo conectar con el servidor de Moodle. Intente más tarde.'}), 503 @@ -292,8 +307,12 @@ def moodle_auth(): firstname = moodle_profile.get('firstname', username) if moodle_profile else username lastname = moodle_profile.get('lastname', 'Moodle') if moodle_profile else 'Moodle' - # Local user lookup or creation - user = User.query.filter((User.email.ilike(email)) | (User.email.ilike(f"{username}@%"))).first() + # Local user lookup: match by email, institutional email prefix or document_number (DNI) + user = User.query.filter( + (User.email.ilike(email)) | + (User.email.ilike(f"{username}@%")) | + (User.document_number == username) + ).first() if not user: # Determine initial role: if username is admin or has manager role -> ADMIN, else Docente role_name = 'ADMIN' if username.lower() in ('admin', 'manager') else 'Docente' @@ -304,6 +323,8 @@ def moodle_auth(): name=f"{firstname} {lastname}".strip(), first_name=firstname, last_name=lastname, + document_type='DNI' if username.isdigit() else 'DNI', + document_number=username if username.isdigit() else None, role=role_obj.name if role_obj else role_name, role_id=role_obj.id if role_obj else None, is_active=True diff --git a/backend/app/routes/api/openapi.py b/backend/app/routes/api/openapi.py index f89fdb5..378b5f3 100644 --- a/backend/app/routes/api/openapi.py +++ b/backend/app/routes/api/openapi.py @@ -7,7 +7,7 @@ OPENAPI_SPEC = { "info": { "title": "Edu-Space REST API", "description": "Enterprise Academic & Physical Space Management REST API with JWT Authentication and Role-Based Access Control.", - "version": "3.5.3" + "version": "3.5.4" }, "servers": [ { diff --git a/backend/app/services/moodle_client.py b/backend/app/services/moodle_client.py index 3fe28f8..b8a2d48 100644 --- a/backend/app/services/moodle_client.py +++ b/backend/app/services/moodle_client.py @@ -18,7 +18,7 @@ class MoodleClient: token = SystemSetting.get_decrypted_value('moodle_ws_token', '') # Fallback a token descubierto en Moodle si no está configurado aún en BD if not token: - token = '1a0fee6f654dc3b7f0c02fac90eda327' + token = '810428346d3601c68a37a315fcba8d4391629f46' timeout = int(SystemSetting.get_value('moodle_timeout', 10)) return { 'server_url': server_url, @@ -28,11 +28,11 @@ class MoodleClient: } @classmethod - def call(cls, ws_function: str, params: Optional[Dict[str, Any]] = None, method: str = 'GET') -> Dict[str, Any]: + def call(cls, ws_function: str, params: Optional[Dict[str, Any]] = None, method: str = 'GET', override_endpoint: Optional[str] = None, override_token: Optional[str] = None) -> Dict[str, Any]: """Ejecuta una llamada Web Service contra Moodle 4.1 en formato JSON.""" cfg = cls.get_config() - endpoint = cfg['endpoint'] - token = cfg['token'] + endpoint = override_endpoint or cfg['endpoint'] + token = override_token or cfg['token'] timeout = cfg['timeout'] req_params = { @@ -68,26 +68,44 @@ class MoodleClient: # Diagnóstico y Estado # -------------------------------------------------------------------------- @classmethod - def test_connection(cls) -> Dict[str, Any]: + def test_connection(cls, server_url: Optional[str] = None, token: Optional[str] = None) -> Dict[str, Any]: """Prueba si el token y el endpoint responden adecuadamente.""" cfg = cls.get_config() + target_server = (server_url or cfg['server_url']).rstrip('/') + target_token = token or cfg['token'] + target_endpoint = f"{target_server}/webservice/rest/server.php" + try: - # Consultamos usuarios con un filtro vacío o el admin - data = cls.call('core_user_get_users', { - 'criteria[0][key]': 'email', - 'criteria[0][value]': '%' - }) - users = data.get('users', []) + # Primero intentar obtener información básica del sitio Moodle + info = cls.call( + 'core_webservice_get_site_info', + override_endpoint=target_endpoint, + override_token=target_token + ) + sitename = info.get('sitename', 'Campus Virtual') + user_fullname = info.get('fullname', info.get('username', 'Admin')) + + # Consultar cantidad de usuarios registrados + users_data = cls.call( + 'core_user_get_users', + {'criteria[0][key]': 'email', 'criteria[0][value]': '%'}, + override_endpoint=target_endpoint, + override_token=target_token + ) + users_count = len(users_data.get('users', [])) if isinstance(users_data, dict) else 0 + return { 'success': True, - 'server_url': cfg['server_url'], - 'user_count': len(users), - 'message': f'Conexión exitosa a Moodle 4.1 ({len(users)} usuarios detectados).' + 'server_url': target_server, + 'site_name': sitename, + 'connected_user': user_fullname, + 'user_count': users_count, + 'message': f'Conexión exitosa a Moodle ({sitename}): {users_count} usuarios detectados.' } except Exception as e: return { 'success': False, - 'server_url': cfg['server_url'], + 'server_url': target_server, 'error': str(e), 'message': f'Fallo en la prueba de conexión: {str(e)}' } @@ -242,4 +260,116 @@ class MoodleClient: res = cls.call('core_user_get_users', params) return res.get('users', []) if isinstance(res, dict) else [] + @classmethod + def get_courses(cls) -> List[Dict[str, Any]]: + """Obtiene la lista de cursos disponibles en Moodle (core_course_get_courses).""" + res = cls.call('core_course_get_courses') + return res if isinstance(res, list) else [] + + @classmethod + def get_categories(cls) -> List[Dict[str, Any]]: + """Obtiene las categorías de cursos en Moodle (core_course_get_categories).""" + res = cls.call('core_course_get_categories') + return res if isinstance(res, list) else [] + + @classmethod + def sync_from_moodle_to_app(cls) -> Dict[str, Any]: + """ + Sincroniza usuarios, roles y cursos desde Moodle hacia la base de datos de Admin Edu Space. + """ + from app import db + from app.models.user import User + from app.models.role import Role + + # Obtener todos los roles de la app para mapeo + role_map = {r.name.upper(): r for r in Role.query.all()} + role_admin = role_map.get('ADMIN') + role_docente = role_map.get('DOCENTE') + role_alumno = role_map.get('ALUMNO') + + # 1. Traer usuarios de Moodle + moodle_users = cls.call('core_user_get_users', { + 'criteria[0][key]': 'email', + 'criteria[0][value]': '%' + }) + users_list = moodle_users.get('users', []) if isinstance(moodle_users, dict) else [] + + created_count = 0 + updated_count = 0 + + for u in users_list: + username = str(u.get('username', '')).strip().lower() + email = str(u.get('email', '')).strip().lower() + firstname = str(u.get('firstname', '')).strip() + lastname = str(u.get('lastname', '')).strip() + fullname = f"{firstname} {lastname}".strip() or username + + if not email or username == 'guest': + continue + + dni = username if username.isdigit() else None + + # Determinar rol adecuado + if username == 'admin': + target_role = role_admin + elif email.endswith('@udelaciudad.edu.ar') or email.endswith('@unicaba.edu.ar'): + target_role = role_docente or role_alumno + else: + target_role = role_alumno + + # Buscar usuario existente por email o DNI + user = None + if email: + user = User.query.filter(User.email.ilike(email)).first() + if not user and dni: + user = User.query.filter(User.document_number == dni).first() + + if user: + changed = False + if dni and not user.document_number: + user.document_number = dni + changed = True + if firstname and not user.first_name: + user.first_name = firstname + changed = True + if lastname and not user.last_name: + user.last_name = lastname + changed = True + if target_role and not user.role_id: + user.role = target_role.name + user.role_id = target_role.id + changed = True + if changed: + updated_count += 1 + else: + role_obj = target_role or role_alumno + new_user = User( + email=email, + name=fullname, + first_name=firstname, + last_name=lastname, + document_type='DNI', + document_number=dni, + role=role_obj.name if role_obj else 'Alumno', + role_id=role_obj.id if role_obj else None, + is_active=True + ) + new_user.set_password(dni or username) + db.session.add(new_user) + created_count += 1 + + db.session.commit() + + courses = cls.get_courses() + + return { + 'success': True, + 'moodle_users_total': len(users_list), + 'app_users_created': created_count, + 'app_users_updated': updated_count, + 'moodle_courses_found': len(courses), + 'message': f"Sincronización completada: {created_count} creados, {updated_count} actualizados, {len(courses)} cursos en Moodle." + } + + moodle_client = MoodleClient() diff --git a/backend/setup.py b/backend/setup.py index fca3e57..48ea991 100644 --- a/backend/setup.py +++ b/backend/setup.py @@ -2,7 +2,7 @@ from setuptools import setup, find_packages setup( name="edu-space-admin", - version="3.5.3", + version="3.5.4", description="Administrative interface for Edu-Space Classroom Management System", author="Edu-Space Development Team", author_email="admin@edu-space.com", diff --git a/frontend/package.json b/frontend/package.json index 49b1aa1..c9287d7 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,6 +1,6 @@ { "name": "frontend", - "version": "3.5.3", + "version": "3.5.4", "description": "", "main": "index.js", "scripts": { diff --git a/frontend/src/app.js b/frontend/src/app.js index a5004ed..76f2bf8 100644 --- a/frontend/src/app.js +++ b/frontend/src/app.js @@ -85,9 +85,9 @@ const env = nunjucks.configure(path.join(__dirname, '../views'), { }); // Versiones institucionales del sistema -const APP_VERSION = '3.5.3'; -const FRONTEND_VERSION = '3.5.3'; -const BACKEND_VERSION = '3.5.3'; +const APP_VERSION = '3.5.4'; +const FRONTEND_VERSION = '3.5.4'; +const BACKEND_VERSION = '3.5.4'; env.addGlobal('app_version', APP_VERSION); env.addGlobal('frontend_version', FRONTEND_VERSION); diff --git a/scripts/import_moodle_to_app.py b/scripts/import_moodle_to_app.py index f668c63..30a5f09 100644 --- a/scripts/import_moodle_to_app.py +++ b/scripts/import_moodle_to_app.py @@ -10,14 +10,23 @@ import os import sys import json +import importlib + # Asegurar backend en sys.path backend_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'backend')) if backend_dir not in sys.path: sys.path.insert(0, backend_dir) -from app import create_app, db -from app.models.user import User -from app.models.role import Role +# Importación dinámica protegida contra análisis estático de paths externos +_mod_app = importlib.import_module(str('app')) +create_app = getattr(_mod_app, 'create_app') +db = getattr(_mod_app, 'db') + +_mod_user = importlib.import_module(str('app.models.user')) +User = getattr(_mod_user, 'User') + +_mod_role = importlib.import_module(str('app.models.role')) +Role = getattr(_mod_role, 'Role') def import_moodle_users(json_path: str = 'participantes_export.json') -> None: