feat(moodle): conectar moodle_api bidireccional, habilitar login delegado y sincronizacion hacia la app

This commit is contained in:
2026-10-16 16:01:11 -03:00
parent 06306c372a
commit fe5acb6119
14 changed files with 242 additions and 34 deletions
+1 -1
View File
@@ -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()
+22
View File
@@ -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():
+24 -3
View File
@@ -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
+1 -1
View File
@@ -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": [
{
+145 -15
View File
@@ -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()