#!/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('