from typing import Dict, Any, List, Optional import urllib.request import csv import io import re import os from datetime import datetime, date, time, timedelta from app import db from app.models.classroom import Classroom from app.models.career import Career from app.models.subject import Subject, Commission from app.models.reservation import Reservation, ReservationStatus from app.models.user import User BASE_CSV_URL = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vSc_T_BQjbn3uPelioCgx52UM5Py-qNhJN0TYPd1kmsN5jdb3Q8rAaIvNMF_2ZTzQt6bH--yIWQKrKR/pub?output=csv' # Mapeo canónico de carreras de UniCABA para desglosar y normalizar registros compuestos CANONICAL_CAREERS = { 'DATOS': 'DATOS (CCC)', 'DATOS (CCC)': 'DATOS (CCC)', 'DATOS(CCC)': 'DATOS (CCC)', 'TEC.DIG': 'TEC. DIG. (CCC)', 'TEC. DIG (CCC)': 'TEC. DIG. (CCC)', 'TEC. DIG. (CCC)': 'TEC. DIG. (CCC)', 'TEC DIG': 'TEC. DIG. (CCC)', 'VIDEOJUEGOS': 'VIDEOJUEGOS (CCC)', 'VIDEOJUEGOS (CCC)': 'VIDEOJUEGOS (CCC)', 'PROF PROF': 'PROF PROF (CCC)', 'PROF PROF (CCC)': 'PROF PROF (CCC)', 'CIENCIAS': 'CIENCIAS', 'EF. SALUD': 'EF. SALUD', 'EF. GESTIÓN': 'EF. GESTIÓN', 'EF. GESTION': 'EF. GESTIÓN', 'ETD': 'ETD (CCC)', 'ETD (CCC)': 'ETD (CCC)', 'MONO': 'MONODISCIPLINARES', 'MONODISCIPLINARES': 'MONODISCIPLINARES', 'PUEP': 'PUEP', 'PUEP CCC': 'PUEP CCC', 'INGLÉS': 'INGLÉS', 'INGLES': 'INGLÉS', 'GESTIÓN (CCC)': 'Gestión (CCC)', 'GESTION (CCC)': 'Gestión (CCC)', 'DIPLO. ALFABETIZACIÓN': 'DIPLO. ALFABETIZACIÓN', 'DIPLO. ALFABETIZACION': 'DIPLO. ALFABETIZACIÓN', 'DIPLO. BILINGUE': 'DIPLO. BILINGUE', 'POSG. PRIMARIA': 'POSG. PRIMARIA', 'POSG. INICIAL': 'POSG. INICIAL', 'POSG. INCLUSIVAS': 'POSG. INCLUSIVAS', } def normalize_day_name(day_str): """Normaliza cualquier variante de día a su nombre canónico en español (Lunes..Sábado)""" if not day_str: return '' d = day_str.strip().lower() d = d.replace('á', 'a').replace('é', 'e').replace('í', 'i').replace('ó', 'o').replace('ú', 'u') if 'lun' in d: return 'Lunes' if 'mar' in d: return 'Martes' if 'mie' in d: return 'Miércoles' if 'jue' in d: return 'Jueves' if 'vie' in d: return 'Viernes' if 'sab' in d: return 'Sábado' if 'dom' in d: return 'Domingo' return day_str.strip() def map_day_to_idx(day_str): """Mapea el nombre del día (o prefijo) a su índice numérico 0..6 (Lunes=0)""" d = (day_str or '').lower() if 'lun' in d: return 0 if 'mar' in d: return 1 if 'mie' in d or 'mié' in d: return 2 if 'jue' in d: return 3 if 'vie' in d: return 4 if 'sab' in d or 'sáb' in d: return 5 if 'dom' in d: return 6 return 0 def parse_careers_list(c_str): """Parsea y normaliza cadenas de carreras compuestas separadas por guiones o comas""" if not c_str: return ['General'] parts = re.split(r'\s*-\s*|(?<=\))\s*-\s*|\s*,\s*', c_str) result = [] for p in parts: clean = p.strip() if not clean: continue upper_clean = clean.upper() matched = False for k, v in CANONICAL_CAREERS.items(): if upper_clean == k.upper(): if v not in result: result.append(v) matched = True break if not matched: if clean not in result: result.append(clean) return result if result else ['General'] def parse_subject_codes(code_str): """Parsea códigos de materias que pueden venir combinados con barras (ej: ASIG00113 / ASIG000082)""" if not code_str: return [] parts = re.split(r'\s*/\s*|\s*,\s*', code_str) return [p.strip() for p in parts if p.strip()] def normalize_sheets_url(url): """ Normaliza enlaces de Google Sheets (compartidos, de edición, con /u/1/, #gid=... o /pubhtml) para obtener la URL base que acepta parámetro gid=&output=csv o format=csv. """ if not url: return BASE_CSV_URL url = url.strip() # 1. Enlace publicado web (/d/e/2PACX-... con o sin /u/X/ y con pub o pubhtml) pub_match = re.search(r'/spreadsheets/(?:u/\d+/)?d/e/([a-zA-Z0-9-_]+)', url) if pub_match: doc_id = pub_match.group(1) return f"https://docs.google.com/spreadsheets/d/e/{doc_id}/pub?output=csv" # 2. Enlace de edición o exportación (/d//...) sheet_id_match = re.search(r'/spreadsheets/(?:u/\d+/)?d/([a-zA-Z0-9-_]+)', url) if sheet_id_match: sheet_id = sheet_id_match.group(1) return f"https://docs.google.com/spreadsheets/d/{sheet_id}/export?format=csv" return url SHEETS_CONFIG = [ { 'name': 'Lunes', 'gid': '1915752353', 'day_idx': 0 }, { 'name': 'Martes', 'gid': '466778263', 'day_idx': 1 }, { 'name': 'Miércoles', 'gid': '615483345', 'day_idx': 2 }, { 'name': 'Jueves', 'gid': '682416571', 'day_idx': 3 }, { 'name': 'Viernes', 'gid': '1162906711', 'day_idx': 4 }, { 'name': 'Sábado', 'gid': '752305601', 'day_idx': 5 }, ] TIME_REGEX = re.compile(r'(\d{1,2})(?::(\d{2}))?\s*(?:a|-|to)\s*(\d{1,2})(?::(\d{2}))?', re.IGNORECASE) class GoogleSheetsImporter: """ Servicio para descargar, parsear y sincronizar cursadas académicas, aulas, carreras y asignaturas compartidas desde el Google Sheet oficial de UniCABA. """ def __init__(self, base_url=None): if base_url: self.base_url = normalize_sheets_url(base_url) else: configured_url = None try: from app.models.setting import SystemSetting configured_url = SystemSetting.get_value('google_sheets_url') except Exception: pass if not configured_url: configured_url = os.getenv('GOOGLE_SHEETS_URL') self.base_url = normalize_sheets_url(configured_url) if configured_url else BASE_CSV_URL def get_sheets_config(self): """ Descubre las pestañas y GIDs dinámicamente desde /pubhtml si está disponible, o utiliza el fallback SHEETS_CONFIG preconfigurado para los 6 días de cursada. """ pub_match = re.search(r'/spreadsheets/d/e/([a-zA-Z0-9-_]+)', self.base_url) if pub_match: doc_id = pub_match.group(1) pubhtml_url = f"https://docs.google.com/spreadsheets/d/e/{doc_id}/pubhtml" try: req = urllib.request.Request( pubhtml_url, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) EduSpace/3.4'} ) with urllib.request.urlopen(req, timeout=12) as resp: html_content = resp.read().decode('utf-8', errors='replace') # Extraer pares name y gid de Google Sheets pubhtml found = re.findall(r'name:\s*["\']([^"\']+)["\'][^}]*?gid:\s*["\'](\d+)["\']', html_content) if found: discovered = [] for name, gid in found: clean_name = re.sub(r'[^a-zA-ZáéíóúÁÉÍÓÚñÑ]', '', name).capitalize() d_idx = map_day_to_idx(clean_name) discovered.append({ 'name': clean_name if clean_name else name, 'gid': gid, 'day_idx': d_idx }) if discovered: return discovered except Exception: pass return SHEETS_CONFIG def fetch_sheet_csv(self, gid): """Fetch CSV string for a specific sheet gid""" separator = '&' if '?' in self.base_url else '?' url = f"{self.base_url}{separator}gid={gid}" if not (url.startswith('https://') or url.startswith('http://')): raise ValueError(f"URL scheme not permitted: {url}") req = urllib.request.Request( url, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) EduSpace/3.4'} ) with urllib.request.urlopen(req, timeout=25) as resp: # nosec B310 return resp.read().decode('utf-8', errors='replace') def parse_sheet_rows(self, csv_content, sheet_name): """Parse raw CSV text into a structured list of class records""" reader = csv.reader(io.StringIO(csv_content)) rows = list(reader) header_idx = -1 col_offset = 0 for r_idx, row in enumerate(rows): for c_idx, cell in enumerate(row): cell_clean = cell.lower().strip() if 'codigo' in cell_clean or 'código' in cell_clean: header_idx = r_idx col_offset = c_idx break if header_idx != -1: break if header_idx == -1: return [] records = [] current_shift = 'Mañana' for row in rows[header_idx + 1:]: if len(row) >= col_offset + 5: def _clean(val): return val.replace('\ufb01', 'fi').replace('\ufb02', 'fl').strip() raw_cell = _clean(row[col_offset]).replace('\n', ' - ') row_full_text = ' '.join(row).upper() # Detect shift delimiters if 'TURNO MAÑANA' in row_full_text or 'TURNO MANANA' in row_full_text: current_shift = 'Mañana' continue elif 'TURNO VESPERTINO' in row_full_text or 'TURNO TARDE' in row_full_text or 'TURNO NOCHE' in row_full_text: current_shift = 'Tarde' continue elif raw_cell.lower().startswith('turno'): if 'mañ' in raw_cell.lower() or 'man' in raw_cell.lower(): current_shift = 'Mañana' else: current_shift = 'Tarde' continue codigo = raw_cell asignatura = _clean(row[col_offset + 1]).replace('\n', ' ') aula = _clean(row[col_offset + 2]).replace('\n', ' ') carrera = _clean(row[col_offset + 3]).replace('\n', ' ') horario = _clean(row[col_offset + 4]).replace('\n', ' ') # Check valid data row if codigo and asignatura and not 'codigo' in codigo.lower(): # Double-check shift from start hour if possible record_shift = current_shift time_match = re.search(r'(\d{1,2}):(\d{2})', horario) if time_match: h = int(time_match.group(1)) if h >= 14: record_shift = 'Tarde' elif h < 13: record_shift = 'Mañana' v_link_row = None if len(row) > col_offset + 5: for extra_c in row[col_offset + 5:]: extra_clean = _clean(extra_c) if any(x in extra_clean.lower() for x in ['http://', 'https://', 'zoom.us', 'meet.google.com', 'teams.microsoft.com']): v_link_row = extra_clean break records.append({ 'dia': sheet_name, 'codigo': codigo, 'asignatura': asignatura, 'aula': aula, 'carrera': carrera, 'horario': horario, 'turno': record_shift, 'virtual_link': v_link_row }) return records def normalize_room(self, aula_raw): """ Normaliza cadena de aula en (building, room_number, floor, capacity) """ aula_upper = aula_raw.upper().strip() if not aula_upper or any(x in aula_upper for x in ['FERIADO', 'SIN ACTIVIDAD', 'CONSULTAR EN BEDELIA']): return None if 'VIRTUAL' in aula_upper: return { 'building': 'Campus Virtual', 'code': 'VIRTUAL', 'floor': 0, 'capacity': 0, 'description': 'Espacio áulico virtual UniCABA (Capacidad Ilimitada ∞)' } if 'AUDITORIO' in aula_upper: return { 'building': 'Edificio Central', 'code': 'Auditorio', 'floor': 0, 'capacity': 150, 'description': 'Auditorio principal UniCABA' } if 'SALA DE REUNI' in aula_upper: floor = 2 if ('2DO' in aula_upper or '2°' in aula_upper) else 4 return { 'building': 'Edificio Central', 'code': f'Sala Reunión {floor}°P', 'floor': floor, 'capacity': 15, 'description': f'Sala de reunión piso {floor}' } # Standard classrooms: "Aula 402", "AULA 203", "306 - 406" num_match = re.search(r'\d+', aula_raw) if num_match: num = num_match.group(0) floor = int(num[0]) if len(num) >= 3 else 1 return { 'building': 'Edificio Central', 'code': f'Aula {num}', 'floor': floor, 'capacity': 35, 'description': f'Aula física {num} - Piso {floor}' } # Generic fallback return { 'building': 'Edificio Central', 'code': aula_raw, 'floor': 1, 'capacity': 30, 'description': aula_raw } def parse_time_range(self, horario_str): """Parse '8:00 a 9:00hs' into (time(8, 0), time(9, 0))""" m = TIME_REGEX.search(horario_str) if not m: return None, None try: h1 = int(m.group(1)) m1 = int(m.group(2) or 0) h2 = int(m.group(3)) m2 = int(m.group(4) or 0) return time(h1, m1), time(h2, m2) except Exception: return None, None def inspect_sheet_content(self, filter_career=None, filter_subject=None, filter_day=None, filter_days=None, manual_date=None): """ Descarga e inspecciona las hojas del Sheet online para extraer: - Días disponibles con cantidad de filas - Carreras únicas - Materias únicas con sus códigos, nombres y carreras - Grilla de pre-visualización interactiva (preview_rows) según los filtros aplicados """ sheets_to_process = self.get_sheets_config() days_info = [] careers_set = set() subjects_map = {} total_rows = 0 preview_rows = [] # Normalizar días seleccionados allowed_days = None if filter_days: if isinstance(filter_days, str): allowed_days = [normalize_day_name(d) for d in filter_days.split(',') if d.strip()] elif isinstance(filter_days, (list, set)): allowed_days = [normalize_day_name(d) for d in filter_days if d] elif filter_day: nd = normalize_day_name(filter_day) if nd and nd.upper() not in ['ALL', 'TODOS', 'TODOS LOS DÍAS', 'TODOS LOS DIAS', '']: allowed_days = [nd] # Normalizar fecha manual para fecha inferida base manual_dt = None if manual_date: try: if isinstance(manual_date, (datetime, date)): manual_dt = manual_date if isinstance(manual_date, date) else manual_date.date() elif isinstance(manual_date, str) and manual_date.strip(): manual_dt = datetime.strptime(manual_date.strip(), '%Y-%m-%d').date() except Exception: pass # Referencia de semana base: lunes 5 de octubre de 2026 (semana activa del 2° cuatrimestre) ref_monday = date(2026, 10, 5) if manual_dt: ref_monday = manual_dt - timedelta(days=manual_dt.weekday()) row_counter = 0 for sheet_cfg in sheets_to_process: day_name = sheet_cfg['name'] norm_day = normalize_day_name(day_name) day_idx = sheet_cfg.get('day_idx', 0) try: csv_data = self.fetch_sheet_csv(sheet_cfg['gid']) rows = self.parse_sheet_rows(csv_data, day_name) total_rows += len(rows) days_info.append({ 'name': day_name, 'gid': sheet_cfg['gid'], 'day_idx': day_idx, 'rows_count': len(rows), 'status': 'OK' }) # Si este día no está entre los permitidos, no lo agregamos a preview_rows if allowed_days and norm_day not in allowed_days: continue for r in rows: carreras = parse_careers_list(r.get('carrera', '')) for c in carreras: if c and c != 'General': careers_set.add(c) code = r.get('codigo', '').strip() name = r.get('asignatura', '').strip() if code and name: if code not in subjects_map: subjects_map[code] = { 'code': code, 'name': name, 'careers': carreras, 'day': day_name } # Evaluar coincidencia de filtros de Carrera y Materia para la pre-visualización if filter_career: fc = filter_career.strip().upper() match_c = any(fc in c.upper() or c.upper() in fc for c in carreras) or (fc in r.get('carrera', '').upper()) if not match_c: continue if filter_subject: fs = filter_subject.strip().upper() sub_codes = parse_subject_codes(code) match_s = (fs in code.upper()) or (fs in name.upper()) or any(fs in sc.upper() for sc in sub_codes) if not match_s: continue row_counter += 1 aula_raw = r.get('aula', '').strip() room_info = self.normalize_room(aula_raw) is_virtual = bool(room_info and ('VIRTUAL' in str(room_info.get('code', '')).upper() or room_info.get('building') == 'Campus Virtual')) # Calcular fecha tentativa target_date = ref_monday + timedelta(days=int(day_idx)) if manual_dt and norm_day == normalize_day_name(['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'][manual_dt.weekday()]): target_date = manual_dt # Validaciones is_valid = True has_warning = False warning_msg = None if not code or not name: is_valid = False warning_msg = "Falta código o nombre de asignatura" elif not room_info or not aula_raw or any(x in aula_raw.upper() for x in ['FERIADO', 'SIN ACTIVIDAD', 'CONSULTAR']): has_warning = True warning_msg = f"Aula pendiente o sin asignar ({aula_raw or 'Vacía'})" preview_rows.append({ 'id': row_counter, 'dia': norm_day, 'day_idx': day_idx, 'codigo': code, 'asignatura': name, 'aula': aula_raw or (room_info['code'] if room_info else 'Sin Aula'), 'aula_normalizada': room_info['code'] if room_info else 'Sin Aula', 'is_virtual': is_virtual, 'carrera': r.get('carrera', 'General'), 'carreras_list': carreras, 'horario': r.get('horario', ''), 'turno': r.get('turno', 'Mañana'), 'inferred_date': target_date.strftime('%Y-%m-%d'), 'is_valid': is_valid, 'has_warning': has_warning, 'warning_msg': warning_msg }) except Exception as e: days_info.append({ 'name': day_name, 'gid': sheet_cfg['gid'], 'day_idx': day_idx, 'rows_count': 0, 'status': 'Error', 'error': str(e) }) return { 'total_rows': total_rows, 'matching_rows': len(preview_rows), 'days': days_info, 'careers': sorted(list(careers_set)), 'subjects': sorted(list(subjects_map.values()), key=lambda x: x['code']), 'preview_rows': preview_rows } def sync( self, filter_career=None, filter_subject=None, filter_day=None, filter_days=None, manual_date=None, single_date_only=False, weeks_to_generate=16, date_from=None, date_to=None, import_careers=True, import_subjects=True, import_commissions=True, import_classrooms=True, import_reservations=True, selected_rows=None ): """ Proceso principal de sincronización con soporte de filtros, entidades granulares y alcance temporal: :param filter_career: Filtrar por carrera específica (ej. 'DATOS (CCC)') :param filter_subject: Filtrar por código o nombre de materia (ej. 'ASIG00113') :param filter_day: Filtrar por día específico ('Lunes'..'Sábado' o 'ALL') :param filter_days: Lista o cadena de días específicos (ej. ['Lunes', 'Martes']) :param manual_date: Fecha manual específica (YYYY-MM-DD o objeto date) :param single_date_only: Si es True y hay manual_date, crea reserva solo para esa fecha puntual :param weeks_to_generate: Número de semanas consecutivas a generar (1..30, defecto 16) :param date_from: Fecha de inicio de rango (YYYY-MM-DD) :param date_to: Fecha de fin de rango (YYYY-MM-DD) :param import_careers: Booleano para importar/crear carreras :param import_subjects: Booleano para importar/crear asignaturas :param import_commissions: Booleano para importar/crear comisiones :param import_classrooms: Booleano para importar/crear aulas :param import_reservations: Booleano para importar/crear reservas :param selected_rows: Lista de filas específicas pre-seleccionadas desde la grilla interactiva """ dias_esp = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo'] # Normalizar fecha manual si fue provista manual_dt = None if manual_date: try: if isinstance(manual_date, (datetime, date)): manual_dt = manual_date if isinstance(manual_date, date) else manual_date.date() elif isinstance(manual_date, str) and manual_date.strip(): manual_dt = datetime.strptime(manual_date.strip(), '%Y-%m-%d').date() except Exception: pass # Normalizar rango de fechas (date_from y date_to) date_from_dt = None if date_from: try: if isinstance(date_from, (datetime, date)): date_from_dt = date_from if isinstance(date_from, date) else date_from.date() elif isinstance(date_from, str) and date_from.strip(): date_from_dt = datetime.strptime(date_from.strip(), '%Y-%m-%d').date() except Exception: pass date_to_dt = None if date_to: try: if isinstance(date_to, (datetime, date)): date_to_dt = date_to if isinstance(date_to, date) else date_to.date() elif isinstance(date_to, str) and date_to.strip(): date_to_dt = datetime.strptime(date_to.strip(), '%Y-%m-%d').date() except Exception: pass if date_from_dt and date_to_dt and date_from_dt > date_to_dt: date_from_dt, date_to_dt = date_to_dt, date_from_dt # Normalizar número de semanas a generar num_weeks = 16 if weeks_to_generate is not None: try: num_weeks = max(1, min(30, int(weeks_to_generate))) except (ValueError, TypeError): num_weeks = 16 # Normalizar días permitidos allowed_days = None if filter_days: if isinstance(filter_days, str): allowed_days = [normalize_day_name(d) for d in filter_days.split(',') if d.strip()] elif isinstance(filter_days, (list, set)): allowed_days = [normalize_day_name(d) for d in filter_days if d] elif filter_day: nd = normalize_day_name(filter_day) if nd and nd.upper() not in ['ALL', 'TODOS', 'TODOS LOS DÍAS', 'TODOS LOS DIAS', '']: allowed_days = [nd] # Si el usuario no especificó días pero ingresó fecha manual puntual, inferir día if not allowed_days and manual_dt and single_date_only: manual_w = manual_dt.weekday() if manual_w < 6: allowed_days = [dias_esp[manual_w]] stats: Dict[str, Any] = { 'total_rows_processed': 0, 'matching_rows': 0, 'careers_created': 0, 'careers_updated': 0, 'classrooms_created': 0, 'classrooms_updated': 0, 'subjects_created': 0, 'subjects_updated': 0, 'commissions_created': 0, 'reservations_created': 0, 'by_day': {}, 'errors': [], 'sample_records': [], 'filters_applied': { 'career': filter_career.strip() if filter_career else None, 'subject': filter_subject.strip() if filter_subject else None, 'days': allowed_days or ['Todos los Días'], 'manual_date': manual_dt.strftime('%Y-%m-%d') if manual_dt else None, 'single_date_only': bool(single_date_only and manual_dt), 'weeks_to_generate': num_weeks, 'date_from': date_from_dt.strftime('%Y-%m-%d') if date_from_dt else None, 'date_to': date_to_dt.strftime('%Y-%m-%d') if date_to_dt else None, 'temporal_scope': 'single_date' if (single_date_only and manual_dt) else ('date_range' if (date_from_dt and date_to_dt) else 'weeks'), 'entities': { 'careers': bool(import_careers), 'subjects': bool(import_subjects), 'commissions': bool(import_commissions), 'classrooms': bool(import_classrooms), 'reservations': bool(import_reservations) } } } all_raw_records = [] if selected_rows and isinstance(selected_rows, list) and len(selected_rows) > 0: # Modo grilla interactiva: se procesan las filas explícitamente seleccionadas por el usuario for r in selected_rows: d_name = r.get('dia') or 'Lunes' d_idx = map_day_to_idx(d_name) all_raw_records.append((r, d_idx)) if d_name not in stats['by_day']: stats['by_day'][d_name] = {'rows_count': 0, 'status': 'OK'} stats['by_day'][d_name]['rows_count'] += 1 else: # Modo descarga general desde Google Sheets sheets_to_process = self.get_sheets_config() if allowed_days: sheets_to_process = [s for s in sheets_to_process if normalize_day_name(s['name']) in allowed_days] for sheet_cfg in sheets_to_process: day_name = sheet_cfg['name'] try: csv_data = self.fetch_sheet_csv(sheet_cfg['gid']) rows = self.parse_sheet_rows(csv_data, day_name) all_raw_records.extend([(r, sheet_cfg['day_idx']) for r in rows]) stats['by_day'][day_name] = { 'gid': sheet_cfg['gid'], 'rows_count': len(rows), 'status': 'OK' } except Exception as e: err_msg = f"Error al descargar o procesar la hoja de {day_name}: {str(e)}" stats['errors'].append(err_msg) stats['by_day'][day_name] = { 'gid': sheet_cfg['gid'], 'rows_count': 0, 'status': 'Error', 'error': str(e) } stats['total_rows_processed'] = len(all_raw_records) if not all_raw_records: return stats # Default admin user for reservations default_user = User.query.filter_by(role='ADMIN').first() or User.query.first() default_user_id = default_user.id if default_user else 1 # Ensure institutional buildings exist with official address from app.models.building import Building b_central = Building.query.filter_by(name='Edificio Central').first() if not b_central: b_central = Building( name='Edificio Central', code='CENTRAL', address='Tte. Gral. Juan Domingo Perón 802, CABA', floors=4, description='Sede central institucional de UniCABA. Aulas de grado, auditorio y laboratorios.' ) db.session.add(b_central) db.session.flush() else: b_central.address = 'Tte. Gral. Juan Domingo Perón 802, CABA' b_virtual = Building.query.filter_by(name='Campus Virtual').first() if not b_virtual: b_virtual = Building( name='Campus Virtual', code='VIRTUAL', address='Entorno Digital / Microsoft Teams - Moodle', floors=0, description='Entorno de aulas virtuales y clases a distancia' ) db.session.add(b_virtual) db.session.flush() buildings_cache = {b.name.strip().upper(): b for b in Building.query.all()} careers_cache = {c.name.strip().upper(): c for c in Career.query.all()} classrooms_cache = {(c.building.strip().upper(), c.code.strip().upper()): c for c in Classroom.query.all()} subjects_cache = {s.code.strip().upper(): s for s in Subject.query.all()} # Calculate semester dates (anchored on academic year 2026, manual date, or date_from) base_monday = date(2026, 8, 31) if manual_dt and not single_date_only: base_monday = manual_dt - timedelta(days=manual_dt.weekday()) elif date_from_dt: base_monday = date_from_dt - timedelta(days=date_from_dt.weekday()) weeks_to_generate = num_weeks for rec, day_idx in all_raw_records: try: codigo = rec['codigo'] asignatura = rec['asignatura'] aula_raw = rec['aula'] carrera_raw = rec['carrera'].strip() horario_raw = rec['horario'] dia = rec['dia'] or (dias_esp[manual_dt.weekday()] if manual_dt else 'Lunes') turno = rec.get('turno', 'Mañana') # Si el registro no traía día pero hay fecha manual, asignar día de la fecha if day_idx is None and manual_dt: day_idx = manual_dt.weekday() # --- FILTRO 1: Filtrar por Carrera si fue especificada --- carreras_list = parse_careers_list(carrera_raw) if filter_career: fc = filter_career.strip().upper() match_c = any(fc in c.upper() or c.upper() in fc for c in carreras_list) or (fc in carrera_raw.upper()) if not match_c: continue # --- FILTRO 2: Filtrar por Materia si fue especificada --- sub_codes = parse_subject_codes(codigo) if filter_subject: fs = filter_subject.strip().upper() match_s = (fs in codigo.upper()) or (fs in asignatura.upper()) or any(fs in sc.upper() for sc in sub_codes) if not match_s: continue stats['matching_rows'] += 1 # 1. Upsert Careers (Desglosar carreras múltiples normalizadas) career_objs = [] for c_name in carreras_list: c_key = c_name.upper() career = careers_cache.get(c_key) if not career: career = Career.query.filter(Career.name.ilike(c_name)).first() if not career and import_careers: career = Career(name=c_name) db.session.add(career) db.session.flush() stats['careers_created'] += 1 if career: careers_cache[c_key] = career if career: career_objs.append(career) primary_career = career_objs[0] if career_objs else None # 2. Upsert Classroom room_info = self.normalize_room(aula_raw) classroom = None if room_info: b_str = str(room_info.get('building', '')).upper() c_str = str(room_info.get('code', '')).upper() room_key = (b_str, c_str) classroom = classrooms_cache.get(room_key) b_entity = buildings_cache.get(b_str) if not classroom: if import_classrooms: classroom = Classroom( building=room_info['building'], building_id=b_entity.id if b_entity else None, floor=room_info['floor'], capacity=room_info['capacity'], description=room_info['description'], is_active=True ) setattr(classroom, 'code', str(room_info['code'])) db.session.add(classroom) db.session.flush() classrooms_cache[room_key] = classroom stats['classrooms_created'] += 1 else: classroom = Classroom.query.filter_by(code=room_info['code']).first() else: if import_classrooms: classroom.capacity = max(classroom.capacity, room_info['capacity']) if not classroom.building_id and b_entity: classroom.building_id = b_entity.id # 3. Upsert Subject (Soporte Many-to-Many con múltiples carreras y subcódigos) subject_key = codigo.upper() subject = subjects_cache.get(subject_key) if not subject: for sc in sub_codes: if sc.upper() in subjects_cache: subject = subjects_cache[sc.upper()] break if not subject: subject = Subject.query.filter_by(code=codigo).first() if not subject: for sc in sub_codes: subj_by_sc = Subject.query.filter_by(code=sc).first() if subj_by_sc: subject = subj_by_sc break department_str = ", ".join([c.name for c in career_objs]) if career_objs else (primary_career.name if primary_career else 'General') if not subject: if import_subjects: subject = Subject( code=codigo, name=asignatura, career_id=primary_career.id if primary_career else None, department=department_str, credits=4, is_active=True ) if career_objs: subject.careers = career_objs db.session.add(subject) db.session.flush() stats['subjects_created'] += 1 else: if import_subjects: if subject.name != asignatura: subject.name = asignatura stats['subjects_updated'] += 1 # Vincular todas las carreras a la asignatura sin duplicados for c_obj in career_objs: if c_obj not in subject.careers: subject.careers.append(c_obj) if not subject.career_id and primary_career: subject.career_id = primary_career.id subject.department = ", ".join([c.name for c in subject.careers]) if subject.careers else department_str # Registrar en caché con código completo y con subcódigos individuales si existe if subject: subjects_cache[subject_key] = subject for sc in sub_codes: subjects_cache[sc.upper()] = subject # 4. Upsert Commission commission = None if subject: comm_code = 'C1' if '-E' in codigo: comm_code = codigo.split('-')[-1] elif '-0' in codigo: comm_code = 'C' + codigo.split('-')[-1] commission = Commission.query.filter_by( subject_id=subject.id, code=comm_code, semester='2026-2', year=2026 ).first() if not commission: if import_commissions: commission = Commission( subject_id=subject.id, code=comm_code, semester='2026-2', year=2026, teacher_id=default_user_id, max_students=classroom.capacity if classroom else 35, current_students=0, schedule=f"{dia} {horario_raw}", shift=turno, active=True ) db.session.add(commission) db.session.flush() stats['commissions_created'] += 1 else: if import_commissions: commission.schedule = f"{dia} {horario_raw}" commission.shift = turno if classroom: commission.max_students = max(commission.max_students or 0, classroom.capacity) # 5. Generar Reservas de Calendario t_start, t_end = self.parse_time_range(horario_raw) effective_day_idx = day_idx if day_idx is not None else (manual_dt.weekday() if manual_dt else 0) if import_reservations and classroom and subject and commission and t_start and t_end: is_room_virtual = bool(classroom.is_virtual or 'VIRTUAL' in (classroom.code or '').upper()) # Respetar estrictamente los datos del Sheet: si no hay enlace explícito en el documento, NO autogenerar ninguno v_link = rec.get('virtual_link') or None if v_link and not commission.virtual_link: commission.virtual_link = v_link # Determinar fechas a generar: específica de la fila (datepicker), puntual o 16 semanas dates_to_generate = [] row_specific_date = None raw_row_date = rec.get('date') or rec.get('inferred_date') if raw_row_date: try: if isinstance(raw_row_date, (datetime, date)): row_specific_date = raw_row_date if isinstance(raw_row_date, date) else raw_row_date.date() elif isinstance(raw_row_date, str) and raw_row_date.strip(): row_specific_date = datetime.strptime(raw_row_date.strip(), '%Y-%m-%d').date() except Exception: pass if row_specific_date: dates_to_generate = [row_specific_date] elif single_date_only and manual_dt: dates_to_generate = [manual_dt] elif date_from_dt and date_to_dt: # Rango de fechas: calcular todos los días correspondientes a effective_day_idx entre date_from_dt y date_to_dt days_ahead = (effective_day_idx - date_from_dt.weekday()) % 7 first_date = date_from_dt + timedelta(days=days_ahead) dates_to_generate = [] cur = first_date while cur <= date_to_dt: dates_to_generate.append(cur) cur += timedelta(days=7) else: dates_to_generate = [base_monday + timedelta(days=effective_day_idx, weeks=w) for w in range(num_weeks)] for class_date in dates_to_generate: dt_start = datetime.combine(class_date, t_start) dt_end = datetime.combine(class_date, t_end) if is_room_virtual: existing_res = Reservation.query.filter_by( classroom_id=classroom.id, commission_id=commission.id, start_time=dt_start, end_time=dt_end ).first() else: existing_res = Reservation.query.filter_by( classroom_id=classroom.id, start_time=dt_start, end_time=dt_end ).first() c_desc = ", ".join([c.name for c in career_objs]) if career_objs else 'General' note_suffix = f" [Fecha asignada: {class_date.strftime('%d/%m/%Y')}]" if (manual_dt and single_date_only) else "" note_text = f"Clase {'puntual ' if (single_date_only and manual_dt) else 'semanal '}{dia} ({turno}) - Carreras: {c_desc}{note_suffix}" if not existing_res: res = Reservation( classroom_id=classroom.id, commission_id=commission.id, user_id=default_user_id, start_time=dt_start, end_time=dt_end, purpose=f"{subject.code} - {subject.name}", status='CONFIRMED', expected_attendees=min(classroom.capacity, 30) if not is_room_virtual else 35, shift=turno, virtual_link=v_link, notes=note_text ) db.session.add(res) stats['reservations_created'] += 1 else: existing_res.shift = turno existing_res.notes = note_text if v_link: existing_res.virtual_link = v_link if len(stats['sample_records']) < 15: stats['sample_records'].append({ 'dia': dia, 'codigo': codigo, 'asignatura': asignatura, 'carreras': [c.name for c in career_objs], 'aula': classroom.code_display if classroom else aula_raw, 'horario': horario_raw }) except Exception as row_err: import traceback traceback.print_exc() stats['errors'].append(f"Error en fila '{rec.get('codigo', '?')}': {str(row_err)}") db.session.commit() return stats