Files
admin-edu-space/backend/app/services/moodle_client.py
T

381 lines
16 KiB
Python

import requests
import logging
from typing import Dict, Any, List, Optional
from app.models.setting import SystemSetting
logger = logging.getLogger(__name__)
class MoodleClient:
"""
Cliente REST para la API de Web Services de Moodle 4.1.
Soporta operaciones sobre usuarios, cursos, matriculaciones y roles,
leyendo dinámicamente la URL y el Token encriptado desde SystemSetting.
"""
@classmethod
def get_config(cls) -> Dict[str, Any]:
server_url = SystemSetting.get_value('moodle_server_url', 'http://10.0.0.207/moodle').rstrip('/')
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 = '810428346d3601c68a37a315fcba8d4391629f46'
timeout = int(SystemSetting.get_value('moodle_timeout', 10))
return {
'server_url': server_url,
'token': token,
'timeout': timeout,
'endpoint': f"{server_url}/webservice/rest/server.php"
}
@classmethod
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 = override_endpoint or cfg['endpoint']
token = override_token or cfg['token']
timeout = cfg['timeout']
req_params = {
'wstoken': token,
'wsfunction': ws_function,
'moodlewsrestformat': 'json'
}
if params:
req_params.update(params)
try:
if method.upper() == 'POST':
response = requests.post(endpoint, data=req_params, timeout=timeout)
else:
response = requests.get(endpoint, params=req_params, timeout=timeout)
response.raise_for_status()
data = response.json()
# Moodle retorna HTTP 200 con un campo 'exception' en caso de error lógico
if isinstance(data, dict) and 'exception' in data:
error_msg = f"Moodle Exception [{data.get('errorcode')}]: {data.get('message')}"
logger.error(error_msg)
raise RuntimeError(error_msg)
return data
except requests.exceptions.RequestException as e:
logger.error("Error de comunicación con Moodle (%s): %s", ws_function, str(e))
raise RuntimeError(f"Fallo de conexión con Moodle ({ws_function}): {str(e)}")
# --------------------------------------------------------------------------
# Diagnóstico y Estado
# --------------------------------------------------------------------------
@classmethod
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:
# 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': 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': target_server,
'error': str(e),
'message': f'Fallo en la prueba de conexión: {str(e)}'
}
# --------------------------------------------------------------------------
# Usuarios (core_user_*)
# --------------------------------------------------------------------------
@classmethod
def get_users_by_criteria(cls, field: str, value: str) -> List[Dict[str, Any]]:
"""Obtiene usuarios por criterio (email, username, idnumber, etc.)."""
params = {
'criteria[0][key]': field,
'criteria[0][value]': value
}
res = cls.call('core_user_get_users', params)
return res.get('users', []) if isinstance(res, dict) else []
@classmethod
def get_user_by_email(cls, email: str) -> Optional[Dict[str, Any]]:
users = cls.get_users_by_criteria('email', email.strip().lower())
return users[0] if users else None
@classmethod
def create_user(cls, username: str, email: str, firstname: str, lastname: str, password: Optional[str] = None) -> Dict[str, Any]:
"""Crea un nuevo usuario en Moodle (core_user_create_users)."""
params = {
'users[0][username]': username.strip().lower(),
'users[0][email]': email.strip().lower(),
'users[0][firstname]': firstname.strip(),
'users[0][lastname]': lastname.strip(),
'users[0][auth]': 'manual'
}
if password:
params['users[0][password]'] = password
else:
params['users[0][createpassword]'] = 1 # Notifica al usuario para generar password
res = cls.call('core_user_create_users', params, method='POST')
# Retorna lista de diccionarios [{'id': 123, 'username': '...'}]
if isinstance(res, list) and len(res) > 0:
return res[0]
return res
@classmethod
def update_user(cls, moodle_user_id: int, firstname: Optional[str] = None, lastname: Optional[str] = None, email: Optional[str] = None) -> Any:
"""Actualiza datos de un usuario en Moodle (core_user_update_users)."""
params = {'users[0][id]': moodle_user_id}
if firstname:
params['users[0][firstname]'] = firstname
if lastname:
params['users[0][lastname]'] = lastname
if email:
params['users[0][email]'] = email
return cls.call('core_user_update_users', params, method='POST')
# --------------------------------------------------------------------------
# Matriculación y Cursos (enrol_manual_*, core_enrol_*)
# --------------------------------------------------------------------------
@classmethod
def enrol_user(cls, course_id: int, user_id: int, role_id: int = 5) -> Any:
"""
Matricula a un usuario en un curso Moodle (enrol_manual_enrol_users).
Role ID 5 = Estudiante, 3 = Docente con permiso de edición, 4 = Docente sin permiso.
"""
params = {
'enrolments[0][roleid]': role_id,
'enrolments[0][userid]': user_id,
'enrolments[0][courseid]': course_id
}
return cls.call('enrol_manual_enrol_users', params, method='POST')
@classmethod
def unenrol_user(cls, course_id: int, user_id: int, role_id: int = 5) -> Any:
"""Desmatricula a un usuario de un curso Moodle (enrol_manual_unenrol_users)."""
params = {
'enrolments[0][roleid]': role_id,
'enrolments[0][userid]': user_id,
'enrolments[0][courseid]': course_id
}
return cls.call('enrol_manual_unenrol_users', params, method='POST')
@classmethod
def get_enrolled_users(cls, course_id: int) -> List[Dict[str, Any]]:
"""Obtiene todos los usuarios matriculados en un curso (core_enrol_get_enrolled_users)."""
params = {'courseid': course_id}
return cls.call('core_enrol_get_enrolled_users', params)
# --------------------------------------------------------------------------
# Asignación de Roles (core_role_*)
# --------------------------------------------------------------------------
@classmethod
def assign_role(cls, role_id: int, user_id: int, context_id: int = 1) -> Any:
"""Asigna un rol en Moodle a un usuario en un contexto específico (core_role_assign_roles)."""
params = {
'assignments[0][roleid]': role_id,
'assignments[0][userid]': user_id,
'assignments[0][contextid]': context_id
}
return cls.call('core_role_assign_roles', params, method='POST')
@classmethod
def unassign_role(cls, role_id: int, user_id: int, context_id: int = 1) -> Any:
"""Remueve un rol en Moodle (core_role_unassign_roles)."""
params = {
'unassignments[0][roleid]': role_id,
'unassignments[0][userid]': user_id,
'unassignments[0][contextid]': context_id
}
return cls.call('core_role_unassign_roles', params, method='POST')
@classmethod
def create_users(cls, users: List[Dict[str, Any]]) -> Any:
params = {}
for idx, u in enumerate(users):
for k, v in u.items():
params[f'users[{idx}][{k}]'] = v
return cls.call('core_user_create_users', params, method='POST')
@classmethod
def update_users(cls, users: List[Dict[str, Any]]) -> Any:
params = {}
for idx, u in enumerate(users):
for k, v in u.items():
params[f'users[{idx}][{k}]'] = v
return cls.call('core_user_update_users', params, method='POST')
@classmethod
def enrol_users(cls, enrolments: List[Dict[str, Any]]) -> Any:
params = {}
for idx, e in enumerate(enrolments):
params[f'enrolments[{idx}][roleid]'] = e.get('roleid', e.get('role_id', 5))
params[f'enrolments[{idx}][userid]'] = e.get('userid', e.get('user_id'))
params[f'enrolments[{idx}][courseid]'] = e.get('courseid', e.get('course_id'))
return cls.call('enrol_manual_enrol_users', params, method='POST')
@classmethod
def unenrol_users(cls, enrolments: List[Dict[str, Any]]) -> Any:
params = {}
for idx, e in enumerate(enrolments):
params[f'enrolments[{idx}][roleid]'] = e.get('roleid', e.get('role_id', 5))
params[f'enrolments[{idx}][userid]'] = e.get('userid', e.get('user_id'))
params[f'enrolments[{idx}][courseid]'] = e.get('courseid', e.get('course_id'))
return cls.call('enrol_manual_unenrol_users', params, method='POST')
@classmethod
def get_users(cls, criteria: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
params = {}
for idx, c in enumerate(criteria):
params[f'criteria[{idx}][key]'] = c.get('key')
params[f'criteria[{idx}][value]'] = c.get('value')
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 []
# Cargar todos los usuarios existentes en memoria indexados por email y DNI (O(1) lookup)
all_existing_users = User.query.all()
user_by_email = {u.email.lower(): u for u in all_existing_users if u.email}
user_by_dni = {str(u.document_number): u for u in all_existing_users if u.document_number}
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 en memoria por email o DNI
user = user_by_email.get(email) or (user_by_dni.get(dni) if dni else None)
if user:
changed = False
if dni and not user.document_number:
user.document_number = dni
user_by_dni[dni] = user
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)
user_by_email[email] = new_user
if dni:
user_by_dni[dni] = 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()