# backend/services.py """ Capa de servicios: envuelve la lógica existente (modules/) con caché. NO modifica la lógica de negocio — solo la llama y serializa el resultado. """ from core.data_manager import DataManager from modules.ocupabilidad.logic import AnalizadorCursos from modules.ventas.logic import VentasLogic from modules.cobranza.logic import CobranzaLogic from modules.rentabilidad.logic import RentabilidadLogic from modules.saldo_pendiente.logic import SaldoLogic from cache_manager import cache_get_or_set # Instancia única del DataManager (como @st.cache_resource) _DM = None def get_dm() -> DataManager: global _DM if _DM is None: _DM = DataManager() return _DM def _serializar_dicts(datos): out = [] for d in (datos or []): fila = {} for k, v in d.items(): fila[k] = v if isinstance(v, (str, int, float, bool)) or v is None else str(v) out.append(fila) return out def _serializar_filas(filas, limite=None): out = [] for f in (filas or []): vals = f[:limite] if limite else f out.append([str(v) if v is not None else "" for v in vals]) return out # ── OCUPABILIDAD ─────────────────────────────────────────────────────────── def ocupabilidad(ano, mes, sede="TODOS", programa="TODOS"): def _load(): dm = get_dm() analizador = AnalizadorCursos(dm) datos = analizador.obtener_datos_procesados(str(ano), str(mes), sede, programa) filas = analizador.formatear_datos_para_tabla(datos) return { "datos": _serializar_dicts(datos), "filas": _serializar_filas(filas), } return cache_get_or_set("ocupabilidad", (ano, mes, sede, programa), _load) # ── VENTAS ───────────────────────────────────────────────────────────────── def ventas(ano, mes, sede="TODOS", programa="TODOS"): def _load(): dm = get_dm() dm._tc_override_mes = comisiones_tc_del_mes(ano, mes) # TC de Supabase o None dm._fecha_canc_overrides = comisiones_overrides_fecha() # {mat: fecha_canc override} dm._inv_neta_overrides = comisiones_overrides_inv_neta() # {mat: inversion_neta override} logic = VentasLogic(dm) datos = logic.obtener_datos_brutos_filtrado(str(ano), str(mes), sede, programa) \ if hasattr(logic, "obtener_datos_brutos_filtrado") else logic.obtener_datos_brutos(str(ano), str(mes)) datos = [d for d in datos if d.get('VENDEDOR', 'SIN VENDEDOR') != 'SIN VENDEDOR'] filas = logic.formatear_datos_para_tabla(datos) return { "filas": _serializar_filas(filas), "datos": _serializar_dicts(datos), } return cache_get_or_set("ventas", (ano, mes, sede, programa), _load) def _clasif_filtro_programa(dm, dscp): """Misma clasificación de programa que ejecutar_consulta_ventas (SEMINARIOS/TEAC/TERC/OTROS).""" up = str(dscp or "").upper() fdata = dm.meta_data.get("clasificacion_filtro_programa", {}) for cat in ["OTROS", "SEMINARIOS", "TEAC", "TERC"]: for pat in fdata.get(cat, {}).get("patrones", []): if pat.upper() in up: return cat return fdata.get("DEFAULT", "OTROS") if isinstance(fdata.get("DEFAULT"), str) else "OTROS" def ventas_detalle(vendedor, ano, mes, tipo_lista, sede="TODOS", programa="TODOS"): def _load(): dm = get_dm() dm._tc_override_mes = comisiones_tc_del_mes(ano, mes) dm._fecha_canc_overrides = comisiones_overrides_fecha() logic = VentasLogic(dm) resultado = logic.obtener_detalle_vendedor(vendedor, str(ano), str(mes)) filas = resultado.get(tipo_lista, []) if isinstance(resultado, dict) else [] filas = _aplicar_overrides_comisiones(filas) # Filtro por SEDE [14] y PROGRAMA (clasificado desde el nombre [16]), # mismas reglas que la tabla principal. Omite la fila TOTAL GENERAL. _sede = str(sede or "TODOS").upper() _prog = str(programa or "TODOS").upper() if _sede != "TODOS" or _prog != "TODOS": out = [] for f in filas: if str(f[0]).strip().upper() == "TOTAL GENERAL": continue # el TOTAL se recalcula en el frontend if len(f) < 15: out.append(f); continue if _sede != "TODOS" and str(f[14]).strip().upper() != _sede: continue # Clasificar programa por el nombre de CLASIFICACIÓN [16] (prioriza dsc_programa); # si no existe, usar el mostrado [8]. _prog_nombre = f[16] if len(f) > 16 else f[8] if _prog != "TODOS" and _clasif_filtro_programa(dm, _prog_nombre) != _prog: continue out.append(f) filas = out return {"filas": _serializar_filas(filas)} return cache_get_or_set("ventas_det", (vendedor, ano, mes, tipo_lista, sede, programa), _load) def comisiones_detalle_todos(ano, mes): """Devuelve TODOS los matriculados (todos los años/meses) para el buscador. Aplica overrides de Supabase. Cacheado globalmente (no depende del mes).""" def _load(): dm = get_dm() logic = VentasLogic(dm) filas = logic.buscar_todos_matriculados() filas = _aplicar_overrides_comisiones(filas) return {"filas": _serializar_filas(filas)} return cache_get_or_set("comisiones_det_todos", ("GLOBAL",), _load) def comisiones_overrides_fecha(): """Devuelve dict {num_matricula: fecha_cancelacion1_override} para clasificación.""" try: sb = _sb() res = sb.table("comisiones_overrides").select("num_matricula,fecha_cancelacion1").execute() out = {} for r in (res.data or []): mat = str(r["num_matricula"]) v = r.get("fecha_cancelacion1") sv = "" if v is None else str(v).strip() # Solo "__VACIO__" = fecha borrada a propósito → anula la del SQL. # None/"" = la fila tiene override de OTROS campos pero no toco la fecha -> usar SQL. if sv == "__VACIO__": out[mat] = "__VACIO__" elif sv != "": out[mat] = sv return out except Exception: return {} def comisiones_overrides_inv_neta(): """Devuelve dict {num_matricula: inversion_neta(float)} para la tabla principal. El valor es el monto final en soles (no se re-convierte por TC).""" try: sb = _sb() res = sb.table("comisiones_overrides").select("num_matricula,inversion_neta").execute() out = {} for r in (res.data or []): v = r.get("inversion_neta") if v is None: continue s = str(v).replace("S/", "").replace(",", "").strip() if s == "": continue try: out[str(r["num_matricula"])] = float(s) except Exception: pass return out except Exception: return {} def _aplicar_overrides_comisiones(filas): """Sobreescribe valores de cada fila con los guardados en Supabase (por num_matricula). Índices de fila: [2]F.MAT [7]INV.NETA [9]F.INI [10]SALDO MAT [11]SALDO C1 [12]DÍAS [13]VALOR ADIC [14]TIPO PROG [15]num_matricula. (5=PROMEDIO CUOTA)""" try: dm = get_dm() if not getattr(dm, "supabase_client", None): return filas res = dm.supabase_client.table("comisiones_overrides").select("*").execute() ov = {str(r["num_matricula"]): r for r in (res.data or [])} if not ov: return filas # columna override -> índice en la fila mapa = { "fch_matricula": 2, "promedio_cuota": 5, "inversion_neta": 7, "fecha_inicio": 9, "saldo_matricula": 10, "saldo_cuota1": 11, "dias_anticipacion": 12, "valor_cuota_adicional": 13, "tipo_programa": 14, "fecha_cancelacion1": 3, } for f in filas: if len(f) < 16: continue mat = str(f[15]) # [16] = nombre para clasificar (si no vino, usar el mostrado [8]) # [17] = flag "tiene override" (0 por defecto) if len(f) == 16: f.append(f[8]) # buscador: no trae [16] → reutiliza el nombre mostrado if len(f) == 17: f.append("0") if mat in ov: r = ov[mat] for col, idx in mapa.items(): val = r.get(col) if val is None: continue if str(val) == "__VACIO__": f[idx] = "" # forzar vacío explícito (override "borrar") elif str(val) != "": f[idx] = val f[17] = "1" # marcar fila como editada return filas except Exception as e: print(f"[overrides comisiones] {e}") return filas # ── COBRANZA ─────────────────────────────────────────────────────────────── def cobranza(ano, mes, sectorista="TODOS", agrupacion="SEDE"): def _load(): dm = get_dm() logic = CobranzaLogic(dm) filas = logic.obtener_datos_tabla(str(ano), str(mes), sectorista, agrupacion) sectoristas = logic.obtener_lista_sectoristas(str(ano), str(mes)) return { "filas": _serializar_filas(filas), "sectoristas": sectoristas or ["TODOS"], } return cache_get_or_set("cobranza", (ano, mes, sectorista, agrupacion), _load) def cobranza_detalle(grupo, ano, mes, sectorista, agrupacion="PROGRAMA"): def _load(): dm = get_dm() logic = CobranzaLogic(dm) if agrupacion == "ASESOR": datos = logic.obtener_detalle_programa_formateado(str(ano), str(mes), grupo, "TODOS") elif agrupacion == "SEDE": # Filtrar por sede usando el MISMO clasificador del processor (sede.json) crudos = logic.processor.obtener_detalle_programa(str(ano), str(mes), sectorista, "TODOS") grupo_up = str(grupo).upper() mats_sede = set() for d in (crudos or []): prog = d.get("PROGRAMA", "") or d.get("dsc_programa", "") sede_det = str(logic.processor.clasificar_sede(prog)).upper() if sede_det == grupo_up: mats_sede.add(str(d.get("MATRICULA", ""))) todas = logic.obtener_detalle_programa_formateado(str(ano), str(mes), sectorista, "TODOS") # Solo alumnos de la sede (sin la fila TOTAL global; el frontend recalcula el total) datos = [f for f in (todas or []) if str(f[0]) in mats_sede] else: # PROGRAMA datos = logic.obtener_detalle_programa_formateado(str(ano), str(mes), sectorista, grupo) return {"filas": _serializar_filas(datos)} return cache_get_or_set("cobranza_det", (grupo, ano, mes, sectorista, agrupacion), _load) # ── RENTABILIDAD ─────────────────────────────────────────────────────────── def rentabilidad(ano, mes, sede="TODOS", filtro_prog="TODOS"): def _load(): dm = get_dm() logic = RentabilidadLogic(dm) datos = logic.obtener_datos_procesados(str(ano), str(mes), sede, filtro_prog) filas = logic.formatear_datos_para_tabla(datos) filas_s = _serializar_filas(filas, 13) nombres = [str(f[0]) for f in filas_s if "TOTAL" not in str(f[0]).upper()] return {"filas": filas_s, "programas": nombres} return cache_get_or_set("rentabilidad", (ano, mes, sede, filtro_prog), _load) def rentabilidad_detalle(programa, ano, mes): def _load(): dm = get_dm() logic = RentabilidadLogic(dm) resultado = logic.obtener_detalle_programa(programa, str(ano), str(mes)) return {"filas": _serializar_filas(resultado)} return cache_get_or_set("rentabilidad_det", (programa, ano, mes), _load) def rentabilidad_costos(programa, ano, mes): def _load(): dm = get_dm() logic = RentabilidadLogic(dm) return {"costos": logic.obtener_datos_costos_programa(programa, str(ano), str(mes))} return cache_get_or_set("rentabilidad_costos", (programa, ano, mes), _load) # ── SALDO PENDIENTE ──────────────────────────────────────────────────────── def saldo_pendiente(tipo_cuota): def _load(): dm = get_dm() logic = SaldoLogic(dm) datos = logic.obtener_saldos_consolidados(tipo_cuota) return {"datos": _serializar_dicts(datos)} return cache_get_or_set("saldo", (tipo_cuota,), _load) # ── PRECARGA GLOBAL (calienta todo el caché) ─────────────────────────────── def precargar_todo(): from datetime import datetime ahora = datetime.now() ano, mes = ahora.year, ahora.month tareas = [ lambda: ocupabilidad(ano, mes), lambda: ventas(ano, mes), lambda: cobranza(ano, mes, "TODOS", "SEDE"), lambda: cobranza(ano, mes, "TODOS", "PROGRAMA"), lambda: cobranza(ano, mes, "TODOS", "ASESOR"), lambda: rentabilidad(ano, mes), lambda: saldo_pendiente("1° Cuota"), ] for t in tareas: try: t() except Exception as e: print(f"[precarga] error: {e}") _refresh_count = 0 def _recalcular_clave(key): """Dada una clave 'prefijo:arg1|arg2|...', recalcula su valor sin usar el caché viejo.""" from cache_manager import cache_invalidate try: prefijo, _, resto = key.partition(":") args = resto.split("|") if resto else [] # Invalidar SOLO esta entrada para forzar su recálculo cache_invalidate(prefijo + ":" + resto if resto else prefijo) if prefijo == "ocupabilidad" and len(args) == 4: return ocupabilidad(args[0], args[1], args[2], args[3]) if prefijo == "ventas" and len(args) == 2: return ventas(args[0], args[1]) if prefijo == "cobranza" and len(args) == 4: return cobranza(args[0], args[1], args[2], args[3]) if prefijo == "rentabilidad" and len(args) == 4: return rentabilidad(args[0], args[1], args[2], args[3]) if prefijo == "saldo" and len(args) == 1: return saldo_pendiente(args[0]) if prefijo == "cobranza_det_todos" and len(args) == 3: return cobranza_detalle_todos(args[0], args[1], args[2]) except Exception as e: print(f"[recalcular] {key}: {e}") return None # los detalles puntuales se recalculan al pedirse def refrescar_todo(): """Refresca SOLO las entradas ya cacheadas (no vacía el caché), para que los meses ya visitados se mantengan rápidos. Cada ~1h recarga config de GitHub.""" global _refresh_count from cache_manager import cache_refresh_existing, cache_keys _refresh_count += 1 # El hilo corre cada 900s (15 min); 4 ciclos ≈ 60 min → recargar config GitHub if _refresh_count % 4 == 0: try: get_dm().cargar_toda_configuracion() print("[config] Recarga de queries/JSON de GitHub completada") except Exception as e: print(f"[config] error al recargar GitHub: {e}") # Si el caché está vacío (primer arranque), hacer precarga normal if not cache_keys(): precargar_todo() else: cache_refresh_existing(_recalcular_clave) # ── GUARDAR COSTOS (override Supabase) ───────────────────────────────────── def guardar_costos(num_indice, costos_inicial, costos_actual): dm = get_dm() ok1 = dm.guardar_override_costo(num_indice, "inicial", costos_inicial) ok2 = dm.guardar_override_costo(num_indice, "actual", costos_actual) from cache_manager import cache_invalidate cache_invalidate("rentabilidad") cache_invalidate("rentabilidad_costos") return bool(ok1 and ok2) # ── CLASIFICACIÓN DE SEDE (sede.json) ────────────────────────────────────── def clasificar_programas(nombres): """Devuelve {programa: sede} usando el clasificador del processor (sede.json).""" dm = get_dm() logic = CobranzaLogic(dm) return {n: str(logic.processor.clasificar_sede(n)) for n in nombres} def cobranza_detalle_todos(ano, mes, sectorista="TODOS"): """Trae TODOS los alumnos en UNA sola consulta (para export y buscador).""" def _load(): dm = get_dm() logic = CobranzaLogic(dm) brutos = logic.processor.obtener_detalle_programa(str(ano), str(mes), sectorista, "TODOS") alumnos = [] for d in (brutos or []): prog = d.get("Programa", d.get("PROGRAMA", "-")) or "-" cta_ant = float(d.get("CTA_COB_ANT", 0.0)); cob_ant = float(d.get("COB_ANT", 0.0)) cta_cur = float(d.get("CTA_COB_MES_CURSO", 0.0)); cob_cur = float(d.get("COB_MES_CURSO", 0.0)) cta_tot = float(d.get("TOTAL_CTA_COB", 0.0)); cob_tot = float(d.get("TOTAL_COBRADO", 0.0)) saldo = float(d.get("SALDO", 0.0)) alumnos.append({ "matricula": str(d.get("MATRICULA", "")), "alumno": d.get("ALUMNO", d.get("Alumno", "")), "programa": prog, "sede": str(logic.processor.clasificar_sede(prog)), "frecuencia": d.get("FRECUENCIA", d.get("Frecuencia", "-")), "num_cuota": d.get("NUM_CUOTA", "-"), "fch_venc": d.get("FCH_VENC", "-"), "cta_ant": cta_ant, "cob_ant": cob_ant, "cta_cur": cta_cur, "cob_cur": cob_cur, "cta_tot": cta_tot, "cob_tot": cob_tot, "saldo": saldo, }) return {"alumnos": alumnos} return cache_get_or_set("cobranza_det_todos", (ano, mes, sectorista), _load) # ── GESTIÓN DE USUARIOS (Supabase Auth + tabla perfiles) ─────────────────── def _sb(): dm = get_dm() if not dm.supabase_client: raise RuntimeError("Supabase no está conectado") return dm.supabase_client def usuarios_listar(): sb = _sb() perfiles = sb.table("perfiles").select("id, nombre, rol, activo").execute().data or [] try: users = sb.auth.admin.list_users() lista = users if isinstance(users, list) else getattr(users, "users", []) correo_por_id = {str(u.id): u.email for u in lista} except Exception: correo_por_id = {} out = [] for p in perfiles: out.append({ "id": p["id"], "email": correo_por_id.get(str(p["id"]), "-"), "nombre": p.get("nombre"), "rol": p.get("rol"), "activo": p.get("activo", True), }) return {"usuarios": out} def usuarios_crear(email, password, nombre, rol): sb = _sb() res = sb.auth.admin.create_user({ "email": email, "password": password, "email_confirm": True, }) user = getattr(res, "user", None) or res uid = str(user.id) sb.table("perfiles").upsert({"id": uid, "nombre": nombre or email, "rol": rol, "activo": True}).execute() return {"status": "ok", "id": uid} def usuarios_actualizar_rol(user_id, rol): sb = _sb() sb.table("perfiles").update({"rol": rol}).eq("id", user_id).execute() return {"status": "ok"} def usuarios_eliminar(user_id): sb = _sb() sb.auth.admin.delete_user(user_id) return {"status": "ok"} # ── VENDEDORES MANUALES (Comisiones, en Supabase) ────────────────────────── # ── CONFIG MENSUAL COMISIONES (IMP_TC, META, COMISIÓN por tipo de programa) ── def comisiones_config_listar(ano, mes): """Lista la config de un mes (todas las filas por tipo_programa).""" sb = _sb() res = sb.table("comisiones_config_mensual").select("*").eq("ano", int(ano)).eq("mes", int(mes)).execute() return {"config": res.data or []} def comisiones_config_guardar(ano, mes, filas): """Reemplaza la config del mes. filas = [{tipo_programa, imp_tc, meta, comision}].""" sb = _sb() sb.table("comisiones_config_mensual").delete().eq("ano", int(ano)).eq("mes", int(mes)).execute() payload = [] for f in filas: payload.append({ "ano": int(ano), "mes": int(mes), "tipo_programa": f.get("tipo_programa", ""), "imp_tc": float(f.get("imp_tc", 0) or 0), "meta": float(f.get("meta", 0) or 0), "comision": float(f.get("comision", 0) or 0), }) if payload: sb.table("comisiones_config_mensual").insert(payload).execute() from cache_manager import cache_invalidate cache_invalidate("ventas") cache_invalidate("ventas_det") return {"status": "ok"} def comisiones_tc_del_mes(ano, mes): """Devuelve el IMP_TC configurado para el mes (toma el primero que tenga TC > 0), o None.""" try: sb = _sb() res = sb.table("comisiones_config_mensual").select("imp_tc").eq("ano", int(ano)).eq("mes", int(mes)).execute() for r in (res.data or []): tc = float(r.get("imp_tc", 0) or 0) if tc > 0: return tc except Exception: pass return None def vendedores_manuales_listar(ano, mes): sb = _sb() query = sb.table("vendedores_manuales").select("*").eq("ano", int(ano)) if int(mes) != 0: # mes=0 → traer todo el año (para cache en frontend) query = query.eq("mes", int(mes)) res = query.execute() return {"vendedores": res.data or []} def vendedores_manuales_crear(nombre, descripcion, fch_emision, monto, ano, mes): sb = _sb() payload = { "nombre": nombre, "descripcion": descripcion or "", "fch_emision": fch_emision or "", "monto": float(monto or 0), "ano": int(ano), "mes": int(mes), } res = sb.table("vendedores_manuales").insert(payload).execute() return {"status": "ok", "data": res.data} def vendedores_manuales_eliminar(id): sb = _sb() sb.table("vendedores_manuales").delete().eq("id", id).execute() return {"status": "ok"} def vendedores_manuales_actualizar(id, descripcion, fch_emision, monto): sb = _sb() sb.table("vendedores_manuales").update({ "descripcion": descripcion or "", "fch_emision": fch_emision or "", "monto": float(monto or 0), }).eq("id", id).execute() return {"status": "ok"} def vendedores_manuales_guardar_lote(nombre, ano, mes, filas): """Reemplaza TODAS las filas de un vendedor manual en una sola operación. filas = lista de dicts {descripcion, fch_emision, monto}. Si filas vacía → elimina el vendedor.""" sb = _sb() # Borrar las existentes de ese vendedor/mes sb.table("vendedores_manuales").delete().eq("nombre", nombre).eq("ano", int(ano)).eq("mes", int(mes)).execute() # Insertar las nuevas en un solo batch payload = [] for f in filas: payload.append({ "nombre": nombre, "descripcion": f.get("descripcion","") or "", "fch_emision": f.get("fch_emision","") or "", "monto": float(f.get("monto",0) or 0), "ano": int(ano), "mes": int(mes), }) if payload: sb.table("vendedores_manuales").insert(payload).execute() return {"status": "ok"} # ── OVERRIDES DE COMISIONES (editar valores por num_matricula) ───────────── def comisiones_override_guardar(registros): """Guarda/actualiza overrides en UNA sola operación (batch upsert).""" sb = _sb() from cache_manager import cache_invalidate validos = [r for r in registros if r.get("num_matricula")] if validos: sb.table("comisiones_overrides").upsert(validos).execute() cache_invalidate("ventas_det") cache_invalidate("ventas") cache_invalidate("comisiones_det_todos") return {"status": "ok"} def comisiones_override_restaurar(num_matricula): """Borra el override de un alumno (vuelve a los valores de SQL).""" sb = _sb() from cache_manager import cache_invalidate sb.table("comisiones_overrides").delete().eq("num_matricula", str(num_matricula)).execute() cache_invalidate("ventas_det") cache_invalidate("ventas") cache_invalidate("comisiones_det_todos") return {"status": "ok"}