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()