Administrator/dashboard-leads
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Actualizar frontend/src/lib/api.js

Browse Source
This commit is contained in:
Administrator
2026-09-04 16:07:16 -05:00
parent 286d4aff1e
commit 0d09be8e4e
1 changed files with 60 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
frontend/src/lib/api.js
View File

@@ -3,7 +3,6 @@
// 2) Si no, se decide por el host desde el que se abrió la página:
// localhost -> backend local http://localhost:8001
// cualquier otro -> API publicada del servidor
// Así funciona en desarrollo y en el servidor sin necesitar ningún .env.
const API_LOCAL = "http://localhost:8001";
const API_SERVIDOR = "https://api-leads.escueladerefrigeracion.lat";
@@ -20,14 +19,34 @@ const BASE_URL = (
).replace(/\/+$/, "");
// ── Cache en memoria (frontend) con TTL 15 min y "stale-while-revalidate" ──
// Guarda la respuesta de cada GET (por path+params). Al volver a pedir:
// - si hay dato vigente (< 15 min) -> lo devuelve al instante, SIN fetch.
// - si venció -> devuelve el viejo al instante Y refresca en 2º plano.
// Así, al cambiar de apartado y volver, NO se recarga; y a los 15 min se
// actualiza solo sin mostrar loader. Los POST invalidan el cache.
const TTL = 15 * 60 * 1000; // 15 minutos
const _cache = new Map(); // key -> { ts, data }
const _enVuelo = new Map(); // key -> Promise (evita fetch duplicado)
const _gen = new Map(); // key -> nº de generación (para invalidar en vuelo)
function _genDe(k) { return _gen.get(k) || 0; }
// ── Persistencia en sessionStorage para que el cache SOBREVIVA al F5 ──
const _SS_KEY = "leads_api_cache_v1";
function _persistir() {
try {
const obj = {};
for (const [k, v] of _cache.entries()) obj[k] = v;
sessionStorage.setItem(_SS_KEY, JSON.stringify(obj));
} catch (e) { /* cuota llena o no disponible: ignorar */ }
}
(function _rehidratar() {
try {
const raw = sessionStorage.getItem(_SS_KEY);
if (!raw) return;
const obj = JSON.parse(raw);
for (const k in obj) _cache.set(k, obj[k]);
} catch (e) { /* ignorar */ }
})();
function _guardar(key, data) {
_cache.set(key, { ts: Date.now(), data });
_persistir();
}
function _key(path, params) {
return path + "?" + new URLSearchParams(params).toString();
@@ -40,42 +59,39 @@ async function _fetch(path, params) {
return r.json();
}
// GET con cache. Devuelve SIEMPRE una promesa que resuelve rápido si hay cache.
function get(path, params = {}) {
const key = _key(path, params);
const hit = _cache.get(key);
const now = Date.now();
if (hit) {
// Hay algo cacheado -> devolverlo YA.
if (now - hit.ts >= TTL && !_enVuelo.has(key)) {
// Venció: refrescar en 2º plano (no bloquea, no muestra loader).
const g = _genDe(key);
const p = _fetch(path, params)
.then((data) => { _cache.set(key, { ts: Date.now(), data }); return data; })
.finally(() => _enVuelo.delete(key));
.then((data) => { if (_genDe(key) === g) _guardar(key, data); return data; })
.finally(() => { if (_enVuelo.get(key) === p) _enVuelo.delete(key); });
_enVuelo.set(key, p);
}
return Promise.resolve(hit.data);
}
// No hay cache: si ya hay una petición en vuelo para esta key, reusarla.
if (_enVuelo.has(key)) return _enVuelo.get(key);
const g = _genDe(key);
const p = _fetch(path, params)
.then((data) => { _cache.set(key, { ts: Date.now(), data }); return data; })
.finally(() => _enVuelo.delete(key));
.then((data) => { if (_genDe(key) === g) _guardar(key, data); return data; })
.finally(() => { if (_enVuelo.get(key) === p) _enVuelo.delete(key); });
_enVuelo.set(key, p);
return p;
}
// Invalida entradas del cache cuyo path empiece con alguno de los prefijos dados.
function invalidar(...prefijos) {
for (const k of _cache.keys()) {
if (prefijos.some((p) => k.startsWith(p))) _cache.delete(k);
}
const afecta = (k) => prefijos.some((p) => k.startsWith(p));
for (const k of _cache.keys()) { if (afecta(k)) _cache.delete(k); }
for (const k of _enVuelo.keys()) { if (afecta(k)) { _gen.set(k, _genDe(k) + 1); _enVuelo.delete(k); } }
_persistir();
}
// POST helper: hace el POST y luego invalida los caches afectados.
async function post(path, body, invalidarPrefijos = []) {
const r = await fetch(`${BASE_URL}${path}`, {
method: "POST", headers: { "Content-Type": "application/json" },
@@ -87,6 +103,8 @@ async function post(path, body, invalidarPrefijos = []) {
return data;
}
const _TODOS = ["/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general", "/api/programa", "/api/alertas"];
export const api = {
leadsFiltros: () => get("/api/leads/filtros"),
leads: (ano = "TODOS", mes = "TODOS", dia = "TODOS", programa = "TODOS", sede = "TODOS") =>
@@ -95,29 +113,30 @@ export const api = {
get("/api/otros-general", { ano, mes, dia }),
vendedores: (ano = "TODOS", mes = "TODOS", dia = "TODOS") =>
get("/api/vendedores", { ano, mes, dia }),
tiempoRespuestaDetalle: (dia, modo = "asignacion", vendedor = "TODOS", ano = "TODOS", mes = "TODOS") =>
get("/api/tiempo-respuesta/detalle", { dia, modo, vendedor, ano, mes }),
roas: (ano = "TODOS", mes = "TODOS", dia = "TODOS") =>
get("/api/roas", { ano, mes, dia }),
programaOpciones: (ano = "TODOS", mes = "TODOS") =>
get("/api/programa/opciones", { ano, mes }),
programa: (ano = "TODOS", mes = "TODOS", programa = "TODOS") =>
get("/api/programa", { ano, mes, programa }),
alertas: () => _fetch("/api/alertas", {}),
conjuntosSinSede: () => get("/api/conjuntos-sin-sede"),
guardarConjuntoSede: (cambios) =>
post("/api/conjuntos-sin-sede/guardar", { cambios }, ["/api/conjuntos-sin-sede", "/api/roas"]),
post("/api/conjuntos-sin-sede/guardar", { cambios }, ["/api/conjuntos-sin-sede", ..._TODOS]),
borrarConjuntoSede: (conjunto) =>
post("/api/conjuntos-sin-sede/borrar", { conjunto }, ["/api/conjuntos-sin-sede", "/api/roas"]),
post("/api/conjuntos-sin-sede/borrar", { conjunto }, ["/api/conjuntos-sin-sede", ..._TODOS]),
ultimaActualizacion: () => get("/api/ultima-actualizacion"),
// Actualiza TODO manualmente (como si pasaran los 15 min), pero EN SEGUNDO
// PLANO: NO se toca el cache del cliente mientras el backend trabaja, así el
// usuario sigue viendo los datos viejos sin pantallas de carga durante los
// ~29s. Recien cuando el backend responde OK se limpia el cache del cliente,
// para que a partir de ahi todo muestre los datos nuevos de inmediato.
refrescarTodo: async () => {
const r = await fetch(`${BASE_URL}/api/cache/refresh`, { method: "POST" });
if (!r.ok) throw new Error("Error al actualizar");
await r.json(); // espera a que el backend TERMINE de rehacer todo
_cache.clear(); // solo AHORA se invalida el cache del cliente
// Trae la hora de actualizacion FRESCA (sin cache) y la deja cacheada, para
// que el sidebar muestre la hora del refresco manual recien hecho.
await r.json();
_cache.clear();
_persistir();
const hr = await _fetch("/api/ultima-actualizacion", {});
_cache.set(_key("/api/ultima-actualizacion", {}), { ts: Date.now(), data: hr });
return hr; // { hora: "..." }
_guardar(_key("/api/ultima-actualizacion", {}), hr);
return hr;
},
conjuntosSinPauta: () => get("/api/conjuntos-sin-pauta"),
usoPauta: (pauta, excluir) => get("/api/pauta/uso", { pauta, excluir: excluir || "" }),
@@ -126,23 +145,22 @@ export const api = {
programasOcultos: () => get("/api/programas-ocultos"),
encenderProgramas: (num_indices) =>
post("/api/programas-ocultos/encender", { num_indices },
["/api/programas-ocultos", "/api/programas-disponibles", "/api/leads"]),
["/api/programas-ocultos", "/api/programas-disponibles", ..._TODOS]),
guardarLeyenda: (cambios) =>
post("/api/leyenda-anuncios/guardar", { cambios }, ["/api/leyenda-anuncios", "/api/roas"]),
post("/api/leyenda-anuncios/guardar", { cambios },
["/api/leyenda-anuncios", ..._TODOS]),
guardarPauta: (num_indice, pauta, conjunto, contar) =>
post("/api/curso/guardar-pauta", { num_indice, pauta, conjunto, contar },
["/api/leads", "/api/conjuntos-sin-pauta", "/api/roas"]),
alertas: () => get("/api/leads/alertas"),
// Leyenda (campanias de Supabase). Al agregar/borrar, invalida TODOS los
// apartados que dependen de las leyendas para que el cambio se vea al instante.
["/api/conjuntos-sin-pauta", ..._TODOS]),
alertasClasif: () => get("/api/leads/alertas"),
campanias: () => get("/api/campanias"),
agregarCampania: (datos) =>
post("/api/campanias/agregar", datos,
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general"]),
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general", "/api/programa"]),
editarCampania: (id, datos) =>
post("/api/campanias/editar", { id, ...datos },
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general"]),
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general", "/api/programa"]),
borrarCampania: (id) =>
post("/api/campanias/borrar", { id },
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general"]),
};
["/api/campanias", "/api/leads", "/api/vendedores", "/api/roas", "/api/otros-general", "/api/programa"]),
};