#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Moodle Replicator: Exportación de Datos de Moodle Producción a Entorno Local. Replica usuarios, carreras, materias y matriculaciones desde Moodle UniCABA (Producción) hacia el Moodle Local (10.0.0.207) para pruebas con Admin Edu Space. """ import os import sys import re import json import argparse import unicodedata from typing import Dict, List, Any, Optional import requests # Mapa de correspondencia oficial entre Producción y Local COURSE_MAPPING = { 187: { 'name': 'Escuela de Tecnología e Industrias Digitales (Sala de estudiantes)', 'shortname': 'Sala de estudiantes', 'local_id': 3, 'type': 'faculty' }, 922: { 'name': 'Mi carrera - Lic. en Tecnologías Digitales (CCC)', 'shortname': 'Mi carrera - Lic. en Tecnologías Digitales (CCC)', 'local_id': 19, 'type': 'career' }, 5311: { 'name': 'ASIG00124 - Sistemas Digitales_2/2026', 'shortname': 'ASIG00124 - Sistemas Digitales_2/2026', 'local_id': 16, 'type': 'subject' }, 5313: { 'name': 'ASIG00126 - Seguridad de la Información_2/2026', 'shortname': 'ASIG00126 - Seguridad de la Información_2/2026', 'local_id': 17, 'type': 'subject' }, 5314: { 'name': 'ASIG00127 - Programación de Vanguardia - E1_2/2026', 'shortname': 'ASIG00127 - Programación de Vanguardia - E1_2/2026', 'local_id': 18, 'type': 'subject' } } def slugify(text: str) -> str: """Normaliza texto para generar nombres de usuario o correos legibles.""" if not text: return "" text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8') text = re.sub(r'[^\w\s-]', '', text.lower()).strip() return re.sub(r'[-\s]+', '.', text) def normalize_name(text: str) -> str: """Normaliza nombres eliminando acentos y espacios múltiples para matching robusto.""" if not text: return "" text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8') return re.sub(r'\s+', ' ', text).strip().upper() class CredentialsLoader: """Carga credenciales desde el archivo .credenciales.""" @staticmethod def load(file_path: str = ".credenciales") -> Dict[str, str]: creds = { 'prod_url': 'https://campus.udelaciudad.edu.ar', 'prod_user': '', 'prod_pass': '', 'local_url': 'http://10.0.0.207/moodle', 'local_token': '810428346d3601c68a37a315fcba8d4391629f46' } if not os.path.exists(file_path): return creds with open(file_path, 'r', encoding='utf-8', errors='ignore') as f: lines = f.readlines() is_prod = False is_token = False for line in lines: line_str = line.strip() if "Login Moodle del Campus UniCABA en producción" in line_str: is_prod = True continue if is_prod: if line_str.startswith("user:"): creds['prod_user'] = line_str.split(":", 1)[1].strip() elif line_str.startswith("pass:"): creds['prod_pass'] = line_str.split(":", 1)[1].strip() if line_str.startswith("token:"): creds['local_token'] = line_str.split(":", 1)[1].strip() return creds class MoodleProdExtractor: """Extrae participantes de Moodle Producción mediante sesión web y scraping híbrido.""" def __init__(self, base_url: str, user: str, password: str): self.base_url = base_url.rstrip('/') self.user = user self.password = password self.session = requests.Session() self.session.headers.update({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'es-AR,es;q=0.9', }) self.authenticated = False self.email_cache: Dict[int, str] = {} def fetch_real_emails(self, users: List[Dict[str, Any]], course_id: int) -> None: """Descarga de forma concurrente los correos electrónicos REALES desde los perfiles de Moodle Producción.""" to_fetch = [u for u in users if u.get('moodle_id') and u['moodle_id'] not in self.email_cache] if to_fetch: print(f"[*] Obteniendo correos electrónicos reales para {len(to_fetch)} participantes desde sus perfiles...") def _get_single_email(uid: int): url = f"{self.base_url}/user/view.php?id={uid}&course={course_id}" try: res = self.session.get(url, timeout=15) if res.status_code == 200: mailtos = [m for m in re.findall(r'mailto:([^"\'>\s]+)', res.text) if m not in ['info@udelaciudad.edu.ar', '.']] if mailtos: return uid, mailtos[0] except Exception: pass return uid, None from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor(max_workers=10) as executor: future_results = list(executor.map(_get_single_email, [u['moodle_id'] for u in to_fetch])) for uid, email in future_results: if email: self.email_cache[uid] = email found_count = sum(1 for _, em in future_results if em) print(f"[+] Correos reales obtenidos: {found_count}/{len(to_fetch)} perfiles consultados.") # Asignar correos reales a la lista de usuarios for u in users: uid = u.get('moodle_id') if uid and uid in self.email_cache: u['real_email'] = self.email_cache[uid] def login(self) -> bool: login_url = f"{self.base_url}/login/index.php" print(f"[*] Obteniendo token de login de producción en {login_url}...") res = self.session.get(login_url, timeout=25) if res.status_code != 200: print(f"[!] Error al acceder a la página de login: HTTP {res.status_code}") return False # Extraer logintoken m = re.search(r'name=["\']logintoken["\']\s+value=["\']([^"\']+)["\']', res.text) if not m: m = re.search(r'value=["\']([^"\']+)["\']\s+name=["\']logintoken["\']', res.text) if not m: print("[!] No se encontró el 'logintoken' en la respuesta.") return False token = m.group(1) payload = { 'username': self.user, 'password': self.password, 'logintoken': token } print(f"[*] Autenticando usuario '{self.user}' en Producción...") post_res = self.session.post(login_url, data=payload, timeout=25, allow_redirects=True) if "loginerrormessage" in post_res.text or ("Inicie sesión en su cuenta" in post_res.text and "my/" not in post_res.url): print("[!] Falla de autenticación en Moodle de Producción. Verifique usuario/contraseña.") return False print("[+] Autenticación exitosa en Moodle Producción.") self.authenticated = True return True def extract_course_participants(self, course_id: int) -> List[Dict[str, Any]]: """Extrae la lista completa de participantes para un curso de producción.""" if not self.authenticated: raise RuntimeError("Debe autenticarse antes de extraer datos.") # Paso 1: Acceder con perpage=5000 para cargar todos los participantes en una sola vista url_all = f"{self.base_url}/user/index.php?page=0&perpage=5000&contextid=0&id={course_id}&newcourse" print(f"[*] Descargando vista de participantes para curso Prod ID {course_id}...") res = self.session.get(url_all, timeout=30) if res.status_code != 200: print(f"[!] Error al cargar curso {course_id}: HTTP {res.status_code}") return [] # Extraer sesskey m_sk = re.search(r'name=["\']sesskey["\']\s+value=["\']([^"\']+)["\']', res.text) sesskey = m_sk.group(1) if m_sk else "" # Extraer checkboxes de usuarios: id="user12345" name="user12345" user_checkboxes = re.findall(r']+id=["\'](user\d+)["\'][^>]*>', res.text) print(f"[+] Detectados {len(user_checkboxes)} participantes en la página del curso.") # Paso 2: Intentar descarga estructurada directa JSON mediante /user/action_redir.php json_participants = [] if sesskey and user_checkboxes: redir_url = f"{self.base_url}/user/action_redir.php" post_data = { 'id': str(course_id), 'sesskey': sesskey, 'formaction': 'bulkchange.php?operation=download_participants&dataformat=json' } for ucb in user_checkboxes: post_data[ucb] = '1' try: r_json = self.session.post(redir_url, data=post_data, timeout=30, allow_redirects=True) if r_json.status_code == 200 and 'application/json' in r_json.headers.get('Content-Type', ''): data = r_json.json() # Moodle a veces retorna [[{user1}, {user2}]] if isinstance(data, list) and len(data) > 0 and isinstance(data[0], list): json_participants = data[0] elif isinstance(data, list): json_participants = data print(f"[+] Descarga nativa JSON exitosa: {len(json_participants)} registros estructurados.") except Exception as e: print(f"[!] Aviso: No se pudo completar la descarga JSON directa ({e}). Usando scraping HTML.") # Paso 3: Parsear la tabla HTML de manera lineal y rápida por fragmentos html_participants_by_name = {} html_participants_by_id = {} # Dividir por filas para evitar backtracking catastrófico en cadenas HTML de 3+ MB chunks = res.text.split(']*user/view\.php[^>]*>(?:]*>)?\s*(.*?)\s*', chunk, re.DOTALL) raw_name = re.sub(r'<[^>]+>', '', m_name.group(1)).strip() if m_name else '' m_role = re.search(r']*class=["\'][^"\']*c2[^"\']*["\'][^>]*>(.*?)', chunk, re.DOTALL) raw_role = re.sub(r'<[^>]+>', '', m_role.group(1)).strip() if m_role else 'Estudiante' is_teacher = any(k in raw_role.lower() for k in ['profesor', 'docente', 'teacher']) entry = { 'moodle_id': uid, 'fullname': raw_name, 'role_text': raw_role, 'is_teacher': is_teacher } if raw_name: html_participants_by_name[normalize_name(raw_name)] = entry html_participants_by_id[uid] = entry # Paso 4: Fusionar datos estructurados (JSON + HTML) final_list = [] if json_participants: for item in json_participants: fn = item.get('nombre', '').strip() ln = item.get('apellidos', '').strip() combined = f"{fn} {ln}" matched = html_participants_by_name.get(normalize_name(combined)) moodle_id = matched['moodle_id'] if matched else None is_teacher = matched['is_teacher'] if matched else False role_text = matched['role_text'] if matched else 'Estudiante' final_list.append({ 'moodle_id': moodle_id, 'firstname': fn, 'lastname': ln, 'fullname': f"{fn} {ln}".strip(), 'role_text': role_text, 'is_teacher': is_teacher, 'group': item.get('grupos', ''), 'course_id': course_id }) else: # Respaldo exclusivo HTML for entry in html_participants_by_id.values(): name_parts = entry['fullname'].split() if len(name_parts) >= 2: fn = " ".join(name_parts[:-1]) ln = name_parts[-1] else: fn = entry['fullname'] ln = entry['fullname'] final_list.append({ 'moodle_id': entry['moodle_id'], 'firstname': fn, 'lastname': ln, 'fullname': entry['fullname'], 'role_text': entry['role_text'], 'is_teacher': entry['is_teacher'], 'group': '', 'course_id': course_id }) # Paso 5: Obtener los correos electrónicos reales desde los perfiles en Moodle Producción self.fetch_real_emails(final_list, course_id) print(f"[+] Total procesado para curso {course_id}: {len(final_list)} participantes.") return final_list class MoodleUserTransformer: """Aplica las reglas de negocio y mocking para el entorno local.""" @staticmethod def transform_user(user: Dict[str, Any]) -> Dict[str, Any]: """Genera credenciales con DNI determinístico y asigna el email REAL de producción.""" fn = user.get('firstname', '').strip() ln = user.get('lastname', '').strip() moodle_id = user.get('moodle_id') full_upper = f"{fn} {ln}".upper() # Regla RF4: Preservar credenciales reales conocidas (Carlos Tello: 34247025) if "CARLOS" in full_upper and "TELLO" in full_upper: dni = "34247025" else: # Regla RF3: DNI de 8 dígitos determinístico: prefijo 90 + ID Moodle a 6 dígitos if moodle_id: dni = f"90{moodle_id:06d}" else: import hashlib h = int(hashlib.md5(full_upper.encode('utf-8')).hexdigest()[:6], 16) % 1000000 dni = f"90{h:06d}" # Correo electrónico REAL extraído del perfil de producción real_email = user.get('real_email') if real_email: email = real_email elif "CARLOS" in full_upper and "TELLO" in full_upper: email = "carlostellocba@gmail.com" else: slug_fn = slugify(fn) slug_ln = slugify(ln) email = f"{slug_fn}.{slug_ln}@unicaba.edu.ar" # Rol: editingteacher = 3, student = 5 role_id = 3 if user.get('is_teacher') else 5 return { 'username': dni, 'password': dni, # RF3: Documento tanto como username como password 'firstname': fn if fn else 'Usuario', 'lastname': ln if ln else 'UniCABA', 'fullname': f"{fn} {ln}".strip(), 'email': email, 'auth': 'manual', 'dni': dni, 'role_id': role_id, 'is_teacher': user.get('is_teacher', False), 'course_id': user.get('course_id') } class MoodleLocalLoader: """Interactúa con la API REST de Moodle Local (10.0.0.207) para altas y matriculaciones.""" def __init__(self, local_url: str, token: str): self.endpoint = f"{local_url.rstrip('/')}/webservice/rest/server.php" self.token = token self.session = requests.Session() self.user_cache: Dict[str, int] = {} def call(self, wsfunction: str, params: Dict[str, Any]) -> Any: full_params = { 'wstoken': self.token, 'wsfunction': wsfunction, 'moodlewsrestformat': 'json', **params } res = self.session.post(self.endpoint, data=full_params, timeout=25) try: return res.json() except Exception: return {'error': res.text, 'status_code': res.status_code} def get_or_create_user(self, user_data: Dict[str, Any]) -> Optional[int]: """Obtiene el ID local de un usuario por username o lo crea si no existe (con caché en memoria).""" username = user_data['username'] if username in self.user_cache: return self.user_cache[username] # Buscar si ya existe query_res = self.call('core_user_get_users', { 'criteria[0][key]': 'username', 'criteria[0][value]': username }) if isinstance(query_res, dict) and 'users' in query_res and len(query_res['users']) > 0: uid = query_res['users'][0]['id'] self.user_cache[username] = uid # Actualizar con el correo real de producción si difiere del actual current_email = query_res['users'][0].get('email', '') target_email = user_data.get('email', '') if target_email and current_email != target_email: self.call('core_user_update_users', { 'users[0][id]': uid, 'users[0][email]': target_email }) return uid # Crear usuario si no existe create_payload = { 'users[0][username]': username, 'users[0][password]': user_data['password'], 'users[0][firstname]': user_data['firstname'], 'users[0][lastname]': user_data['lastname'], 'users[0][email]': user_data['email'], 'users[0][auth]': 'manual' } create_res = self.call('core_user_create_users', create_payload) if isinstance(create_res, list) and len(create_res) > 0 and 'id' in create_res[0]: uid = create_res[0]['id'] self.user_cache[username] = uid return uid print(f"[!] Error al crear usuario {username}: {create_res}") return None def enrol_user(self, local_user_id: int, local_course_id: int, role_id: int) -> bool: """Matricula a un usuario en un curso con el rol especificado.""" payload = { 'enrolments[0][roleid]': role_id, 'enrolments[0][userid]': local_user_id, 'enrolments[0][courseid]': local_course_id } res = self.call('enrol_manual_enrol_users', payload) # Retorna None o vacio en caso de éxito if res is None or res == {} or res == []: return True if isinstance(res, dict) and 'exception' in res: print(f"[!] Error al matricular user {local_user_id} en curso {local_course_id}: {res.get('message')}") return False return True def run_replication( course_ids: Optional[List[int]] = None, dry_run: bool = False, export_json_path: Optional[str] = None ): print("=" * 75) print(" MOODLE REPLICATOR: UniCABA Producción -> Entorno Local (10.0.0.207)") print("=" * 75) creds = CredentialsLoader.load() if not creds['prod_user'] or not creds['prod_pass']: print("[!] No se encontraron credenciales de Moodle Producción en .credenciales.") sys.exit(1) extractor = MoodleProdExtractor(creds['prod_url'], creds['prod_user'], creds['prod_pass']) if not extractor.login(): sys.exit(1) loader = None if not dry_run: loader = MoodleLocalLoader(creds['local_url'], creds['local_token']) target_courses = course_ids if course_ids else list(COURSE_MAPPING.keys()) all_exported_data = {} total_created = 0 total_enrolled = 0 for cid in target_courses: course_meta = COURSE_MAPPING.get(cid, { 'name': f'Curso Prod {cid}', 'local_id': cid }) local_course_id = course_meta['local_id'] print("\n" + "-" * 70) print(f"[*] Procesando: '{course_meta['name']}'") print(f" Prod ID: {cid} -> Local ID: {local_course_id}") print("-" * 70) raw_participants = extractor.extract_course_participants(cid) transformed_users = [MoodleUserTransformer.transform_user(u) for u in raw_participants] all_exported_data[cid] = transformed_users if dry_run: print(f"[DRY-RUN] Se habrían procesado {len(transformed_users)} usuarios para curso local {local_course_id}.") continue print(f"[*] Replicando {len(transformed_users)} usuarios en Moodle Local (10.0.0.207)...") course_enrolled = 0 for u in transformed_users: local_uid = loader.get_or_create_user(u) if local_uid: total_created += 1 if loader.enrol_user(local_uid, local_course_id, u['role_id']): course_enrolled += 1 total_enrolled += 1 print(f"[+] Curso local {local_course_id}: {course_enrolled}/{len(transformed_users)} usuarios matriculados con éxito.") # Guardar exportación JSON si fue solicitada if export_json_path: with open(export_json_path, 'w', encoding='utf-8') as f: json.dump(all_exported_data, f, indent=2, ensure_ascii=False) print(f"\n[+] Datos exportados guardados exitosamente en: {export_json_path}") print("\n" + "=" * 75) print(" RESUMEN DE EJECUCIÓN") print("=" * 75) print(f" Cursos procesados: {len(target_courses)}") if not dry_run: print(f" Usuarios en local: {total_created} procesados") print(f" Matriculaciones OK: {total_enrolled}") else: print(" Modo: DRY-RUN (Sin escrituras)") print("\n" + "=" * 75) print(" PROFESORES Y EQUIPO DOCENTE IDENTIFICADOS POR MATERIA") print("=" * 75) for cid in target_courses: c_name = COURSE_MAPPING.get(cid, {}).get('name', f'Curso {cid}') c_users = all_exported_data.get(cid, []) c_teachers = [u for u in c_users if u.get('is_teacher') or u.get('role_id') == 3] print(f"\n[+] {c_name} (Prod ID: {cid}) - Docentes: {len(c_teachers)}") if c_teachers: for t in c_teachers: print(f" - {t['fullname']:<28} | Email: {t['email']:<36} | DNI: {t['dni']}") else: print(" (Sin docentes asignados directamente en la vista del curso)") print("=" * 75) def main(): parser = argparse.ArgumentParser(description="Replicador de Moodle Producción a Local para UniCABA.") parser.add_argument('--course', type=int, choices=[187, 922, 5311, 5313, 5314], help="ID del curso específico a procesar.") parser.add_argument('--dry-run', action='store_true', help="Ejecutar en modo simulación sin modificar el Moodle local.") parser.add_argument('--export-json', type=str, help="Ruta de archivo JSON donde guardar el volcado de datos.") args = parser.parse_args() course_ids = [args.course] if args.course else None run_replication(course_ids=course_ids, dry_run=args.dry_run, export_json_path=args.export_json) if __name__ == '__main__': main()