Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
1467 lines
68 KiB
JavaScript
1467 lines
68 KiB
JavaScript
(function () {
|
||
"use strict";
|
||
|
||
// Sesión: cualquier 401 (cookie vencida/inválida) recarga la página —
|
||
// server.rb decide server-side si corresponde servir login.html o
|
||
// index.html, sin lógica de auth duplicada acá (P201/Fase4).
|
||
var _fetch = window.fetch;
|
||
window.fetch = function (url, opts) {
|
||
return _fetch(url, opts).then(function (r) {
|
||
if (r.status === 401) location.reload();
|
||
return r;
|
||
});
|
||
};
|
||
|
||
document.getElementById("logout-btn").addEventListener("click", function () {
|
||
fetch("/logout", { method: "POST" }).finally(function () { location.reload(); });
|
||
});
|
||
|
||
var HOUR = 3600 * 1000;
|
||
var keys = [];
|
||
var lastCreated = null;
|
||
var editing = null;
|
||
var pendingDelete = null;
|
||
var RESET_OPTIONS = [
|
||
{ value: 86400, label: "24 horas" },
|
||
{ value: 3600, label: "1 hora" },
|
||
{ value: 604800, label: "7 días" }
|
||
];
|
||
|
||
var nodePill = document.getElementById("node-pill");
|
||
var nodePillText = document.getElementById("node-pill-text");
|
||
var loadError = document.getElementById("load-error");
|
||
|
||
// Navegación de la barra lateral (Dashboard / APIs / Nodos, P201/Fase3)
|
||
var sidebar = document.getElementById("sidebar");
|
||
var sidebarToggle = document.getElementById("sidebar-toggle");
|
||
var navItems = document.querySelectorAll(".nav-item");
|
||
var pageTitle = document.getElementById("page-title");
|
||
var sectionTitles = { dashboard: "Dashboard", apis: "APIs", nodos: "Individuos", pools: "Pools", registro: "Registro", usuarios: "Usuarios" };
|
||
|
||
function selectSection(which) {
|
||
navItems.forEach(function (item) {
|
||
var activo = item.getAttribute("data-section") === which;
|
||
if (activo) {
|
||
item.setAttribute("aria-current", "page");
|
||
} else {
|
||
item.removeAttribute("aria-current");
|
||
}
|
||
});
|
||
document.getElementById("section-dashboard").classList.toggle("active", which === "dashboard");
|
||
document.getElementById("section-apis").classList.toggle("active", which === "apis");
|
||
document.getElementById("section-nodos").classList.toggle("active", which === "nodos");
|
||
document.getElementById("section-pools").classList.toggle("active", which === "pools");
|
||
document.getElementById("section-registro").classList.toggle("active", which === "registro");
|
||
document.getElementById("section-usuarios").classList.toggle("active", which === "usuarios");
|
||
pageTitle.textContent = sectionTitles[which];
|
||
|
||
if (which === "nodos") {
|
||
tokenBanner.classList.remove('visible');
|
||
consumidoresErrorBanner.classList.remove('visible');
|
||
cargarCheckins().then(cargarConsumidores);
|
||
} else if (which === "pools") {
|
||
cargarPools();
|
||
} else if (which === "registro") {
|
||
cargarRegistro();
|
||
} else if (which === "usuarios") {
|
||
usuariosErrorBanner.classList.remove('visible');
|
||
cargarUsuarios();
|
||
}
|
||
}
|
||
|
||
navItems.forEach(function (item) {
|
||
item.addEventListener("click", function () { selectSection(item.getAttribute("data-section")); });
|
||
});
|
||
|
||
sidebarToggle.addEventListener("click", function () {
|
||
sidebar.classList.toggle("collapsed");
|
||
});
|
||
|
||
// Sesión actual (P201/Fase4) — gatea "Usuarios" y todo el CRUD de
|
||
// keys/consumidores por perfil: 'operador' es solo-lectura (corrección
|
||
// 2026-08-03 — el diseño original lo dejaba mutar, error). esAdmin se
|
||
// resuelve ANTES del primer cargarKeys()/cargarConsumidores() para que
|
||
// los botones de escritura no aparezcan ni un instante y se oculten
|
||
// después (Advertir antes que fallar — no mostrar controles que el
|
||
// backend va a rechazar).
|
||
var esAdmin = false;
|
||
var sesionActualEl = document.getElementById("sesion-actual");
|
||
var navUsuarios = document.getElementById("nav-usuarios");
|
||
fetch("/session")
|
||
.then(function (r) { return r.ok ? r.json() : null; })
|
||
.then(function (s) {
|
||
if (s) {
|
||
esAdmin = s.perfil === "admin";
|
||
sesionActualEl.textContent = s.usuario + " · " + s.perfil;
|
||
if (esAdmin) navUsuarios.style.display = "";
|
||
if (!esAdmin) {
|
||
document.getElementById("add-key-trigger").style.display = "none";
|
||
document.getElementById("add-consumidor-trigger").style.display = "none";
|
||
}
|
||
}
|
||
})
|
||
.catch(function () {})
|
||
.finally(function () {
|
||
cargarKeys();
|
||
setInterval(cargarKeys, 30000);
|
||
cargarCheckins().then(cargarConsumidores);
|
||
setInterval(cargarConsumidores, 30000); // resumen de pools y 'Mentes sin keys' al día (P335/Fase 12)
|
||
cargarUsos();
|
||
setInterval(cargarUsos, 30000);
|
||
cargarResumen();
|
||
setInterval(cargarResumen, 30000);
|
||
cargarVersion();
|
||
});
|
||
|
||
// P204/Fase4 — build stamp visible (pedido del Operador, tras confusión
|
||
// real por caché del navegador): confirma que lo que se está viendo
|
||
// corresponde al último deploy, sin adivinar por el contenido.
|
||
function cargarVersion() {
|
||
var el = document.getElementById("version-tag");
|
||
if (!el) return;
|
||
fetch('/version')
|
||
.then(function (r) { return r.json(); })
|
||
.then(function (d) { el.textContent = 'v' + d.version; })
|
||
.catch(function () {});
|
||
}
|
||
|
||
function fmtRelative(iso) {
|
||
var ts = new Date(iso).getTime();
|
||
var diff = ts - Date.now();
|
||
var abs = Math.abs(diff);
|
||
var h = abs / HOUR;
|
||
var text;
|
||
if (h < 1) {
|
||
text = Math.round(abs / 60000) + "m";
|
||
} else if (h < 48) {
|
||
text = h.toFixed(1) + "h";
|
||
} else {
|
||
text = Math.round(h / 24) + "d";
|
||
}
|
||
return diff <= 0 ? "hace " + text : "en " + text;
|
||
}
|
||
|
||
// Texto que viene de afuera (motivo que manda un consumidor, nombres) nunca entra crudo al HTML (P335/Fase 7)
|
||
function esc(t) {
|
||
return String(t == null ? '' : t).replace(/[&<>"']/g, function (c) {
|
||
return { '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c];
|
||
});
|
||
}
|
||
|
||
// Chips "individuo · rol" de los pools de una key (P335/Fase 12): fuente única para APIs e Individuos
|
||
function chipsPools(pools) {
|
||
if (!pools || !pools.length) return '';
|
||
return '<div class="pools-chips">' + pools.map(function (p) {
|
||
return '<span class="pool-chip' + (p.rol === 'red' ? ' red' : '') + '">' + esc(p.individuo) + ' · ' + esc(p.rol) + '</span>';
|
||
}).join('') + '</div>';
|
||
}
|
||
|
||
function fmtClock(iso) {
|
||
var d = new Date(iso);
|
||
return d.toLocaleString("es-AR", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
|
||
}
|
||
|
||
// P337/Fase 2: el ESTADO viene del servidor (taxonomía única, Registro.estado_de); acá solo se muestra en palabras,
|
||
// con hora absoluta y relativa. Nunca se recalcula en el navegador.
|
||
var ESTADO_UI = {
|
||
disponible: { clase: 'ok', texto: 'disponible' },
|
||
en_uso: { clase: 'info', texto: 'en uso' },
|
||
en_pausa: { clase: 'pause', texto: 'en pausa' },
|
||
agotada: { clase: 'warn', texto: 'agotada' },
|
||
desactivada: { clase: 'inactive', texto: 'desactivada' },
|
||
sin_valor: { clase: 'inactive', texto: 'sin valor' }
|
||
};
|
||
var ESTADOS_ORDEN = ['disponible', 'en_uso', 'en_pausa', 'agotada', 'desactivada', 'sin_valor'];
|
||
|
||
function cuando(iso) {
|
||
return iso ? fmtClock(iso) + ' (' + fmtRelative(iso) + ')' : '';
|
||
}
|
||
|
||
function detalleEstado(f) {
|
||
switch (f.estado) {
|
||
case 'en_uso': return 'por ' + esc(f.por || '?') + ' · hasta ' + cuando(f.hasta);
|
||
case 'en_pausa': return 'límite del proveedor · vuelve ' + cuando(f.hasta) + (f.motivo ? ' · ' + esc(f.motivo) : '');
|
||
case 'agotada': return 'cuota agotada · vuelve ' + cuando(f.hasta) + (f.por ? ' · reportó ' + esc(f.por) : '') +
|
||
(f.motivo ? ' · ' + esc(f.motivo) : '');
|
||
case 'sin_valor': return 'cargada sin la clave: no se puede entregar';
|
||
default: return '';
|
||
}
|
||
}
|
||
|
||
function estadoHtml(f) {
|
||
var e = ESTADO_UI[f.estado] || { clase: 'inactive', texto: f.estado || '?' };
|
||
var d = detalleEstado(f);
|
||
return '<span class="pill ' + e.clase + '"><span class="dot"></span>' + e.texto + '</span>' +
|
||
(d ? '<div class="timing-sub">' + d + '</div>' : '');
|
||
}
|
||
|
||
// Eventos del registro en palabras (P337/Fase 2): UNA tabla. Los códigos son los que guarda el servidor.
|
||
var EVENTO_UI = {
|
||
dispensada: ['🟢', 'entregada'],
|
||
liberada: ['⚪', 'devuelta'],
|
||
renovada: ['🔄', 'reserva renovada'],
|
||
pausada: ['🟡', 'en pausa por límite del proveedor'],
|
||
agotada: ['🔴', 'agotada (cuota)'],
|
||
revertida: ['↩️', 'reporte deshecho'],
|
||
'liberada-admin': ['🛠', 'liberada por admin'],
|
||
alta: ['➕', 'dada de alta'],
|
||
editada: ['✏️', 'editada'],
|
||
renombrada: ['🏷', 'renombrada'],
|
||
baja: ['🗑', 'dada de baja']
|
||
};
|
||
|
||
function eventoTexto(e) {
|
||
var u = EVENTO_UI[e] || ['•', e];
|
||
return u[0] + ' ' + u[1];
|
||
}
|
||
|
||
function actionsHtml(k, keyId, activo, bloqueada) {
|
||
if (!esAdmin) return '';
|
||
return '<div class="card-icon-actions">' +
|
||
(bloqueada ? '<button type="button" class="icon-btn primary" data-action="liberar" title="Liberar ahora (queda disponible)">🔓</button>' : '') +
|
||
'<button type="button" class="icon-btn" data-action="edit" title="Editar">✏️</button>' +
|
||
'<button type="button" class="icon-btn' + (activo ? '' : ' primary') + '" data-action="toggle-activo" title="' +
|
||
(activo ? 'Desactivar' : 'Activar') + '">' + (activo ? '⏸' : '▶') +
|
||
'</button>' +
|
||
'<button type="button" class="icon-btn danger" data-action="delete" title="Eliminar">🗑</button>' +
|
||
'</div>';
|
||
}
|
||
|
||
function editPanelHtml(k) {
|
||
var options = RESET_OPTIONS.map(function (o) {
|
||
return '<option value="' + o.value + '"' + (String(k.reset_segundos) === String(o.value) ? ' selected' : '') + '>' + o.label + '</option>';
|
||
}).join('');
|
||
|
||
// Identificador editable (P335/Fase 13): NEXXA actualiza también los pools que la usan
|
||
var avisoPools = k.pools && k.pools.length ? ' title="También se actualiza en ' + k.pools.length + ' pool(s)"' : '';
|
||
return '<div class="edit-panel">' +
|
||
'<div class="ep-field">' +
|
||
'<label>Identificador</label>' +
|
||
'<input class="mono ep-identificador" type="text" value="' + esc(k.identificador) + '"' + avisoPools + ' />' +
|
||
'</div>' +
|
||
'<div class="ep-field">' +
|
||
'<label>Cuenta de origen</label>' +
|
||
'<input class="mono ep-cuenta" type="text" value="' + (k.cuenta_origen || '').replace(/"/g, '"') + '" />' +
|
||
'</div>' +
|
||
'<div class="ep-field">' +
|
||
'<label>Ciclo de cuota</label>' +
|
||
'<select class="mono ep-reset">' + options + '</select>' +
|
||
'</div>' +
|
||
'<button type="button" class="action-btn primary" data-action="save-edit">Guardar</button>' +
|
||
'<button type="button" class="action-btn" data-action="cancel-edit">Cancelar</button>' +
|
||
'</div>';
|
||
}
|
||
|
||
function patchKey(provider, identificador, body) {
|
||
return fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador), {
|
||
method: 'PATCH',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(body)
|
||
}).then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
});
|
||
}
|
||
|
||
function deleteKey(provider, identificador) {
|
||
return fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador), { method: 'DELETE' })
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
});
|
||
}
|
||
|
||
function mostrarErrorAccion(msg) {
|
||
loadError.textContent = msg;
|
||
loadError.classList.add('visible');
|
||
}
|
||
|
||
// ---------- Consumidores (individuos con token, P201/Fase3) ----------
|
||
|
||
var consumidores = [];
|
||
var consumidoresErrorBanner = document.getElementById("consumidores-error-banner");
|
||
var consumidoresErrorTitle = document.getElementById("consumidores-error-title");
|
||
var tokenBanner = document.getElementById("token-banner");
|
||
var tokenBannerTitle = document.getElementById("token-banner-title");
|
||
var tokenBannerValue = document.getElementById("token-banner-value");
|
||
var tokenCopyBtn = document.getElementById("token-copy-btn");
|
||
|
||
function mostrarErrorConsumidores(msg) {
|
||
consumidoresErrorTitle.textContent = msg;
|
||
consumidoresErrorBanner.classList.add('visible');
|
||
}
|
||
|
||
// ---------- Check-in proactivo (P216/Fase4) ----------
|
||
// Ventana de "reciente" — mismo criterio que bandeja.rb (4x una cadencia
|
||
// típica de latido ~300s). Best-effort: si /checkins falla, el resto del
|
||
// panel sigue funcionando, solo sin badges.
|
||
var checkins = {};
|
||
var CHECKIN_VENTANA_MS = 20 * 60 * 1000;
|
||
|
||
function cargarCheckins() {
|
||
return fetch('/checkins')
|
||
.then(function (r) { return r.ok ? r.json() : {}; })
|
||
.then(function (data) { checkins = data || {}; })
|
||
.catch(function () { checkins = {}; });
|
||
}
|
||
|
||
function checkinBadgeHtml(individuo) {
|
||
var c = checkins[individuo];
|
||
if (!c || !c.ultimo_reporte) {
|
||
return '<span class="badge">sin check-in</span>';
|
||
}
|
||
var edad = Date.now() - new Date(c.ultimo_reporte).getTime();
|
||
var reciente = edad <= CHECKIN_VENTANA_MS;
|
||
var clase = reciente && c.estado === 'ok' ? 'badge success' : reciente ? 'badge warning' : 'badge stale';
|
||
var etiqueta = reciente ? c.estado : 'stale';
|
||
var texto = etiqueta + ' · ' + fmtRelative(c.ultimo_reporte) + (c.detalle ? ' · ' + c.detalle : '');
|
||
return '<span class="' + clase + '" title="' + texto.replace(/"/g, '"') + '">' + texto + '</span>';
|
||
}
|
||
|
||
function cargarConsumidores() {
|
||
return fetch('/consumidores')
|
||
.then(function (r) {
|
||
if (!r.ok) throw new Error('HTTP ' + r.status);
|
||
return r.json();
|
||
})
|
||
.then(function (data) {
|
||
consumidores = data;
|
||
renderConsumidores();
|
||
})
|
||
.catch(function (e) {
|
||
mostrarErrorConsumidores('No se pudo cargar la lista (' + e.message + ').');
|
||
});
|
||
}
|
||
|
||
function renderConsumidores() {
|
||
document.getElementById("stat-consumidores").textContent = consumidores.length;
|
||
// Mente con keys asignadas pero ninguna disponible: NEXXA ya le informa 'agotado' y el individuo decide (red)
|
||
var sinMente = consumidores.filter(function (c) { var m = (c.pools || {}).mente; return m && m.total > 0 && m.disponibles === 0; });
|
||
var statMente = document.getElementById("stat-mente-agotada");
|
||
statMente.textContent = sinMente.length;
|
||
statMente.title = sinMente.map(function (c) { return c.individuo; }).join(', ');
|
||
|
||
actualizarOpcionesPoolAlta();
|
||
var list = document.getElementById("consumidores-list");
|
||
if (!consumidores.length) {
|
||
list.innerHTML = '<div class="empty-state">Sin individuos con token todavía. Generá el primero abajo.</div>';
|
||
return;
|
||
}
|
||
|
||
list.innerHTML = consumidores.map(function (c) {
|
||
return '<div class="consumidor-card" data-individuo="' + esc(c.individuo) + '">' +
|
||
'<div class="consumidor-info">' +
|
||
'<div class="id mono">' + esc(c.individuo) + '</div>' +
|
||
'<div class="meta">' + resumenPoolsHtml(c.pools) + '</div>' +
|
||
'<div class="meta">token creado ' + fmtRelative(c.creado) + ' · ' + fmtClock(c.creado) + '</div>' +
|
||
'<div class="meta">' + checkinBadgeHtml(c.individuo) + '</div>' +
|
||
'</div>' +
|
||
(esAdmin
|
||
? '<div class="card-icon-actions">' +
|
||
'<button type="button" class="icon-btn" data-consumidor-action="pools" title="Ver y editar sus pools">🧩</button>' +
|
||
'<button type="button" class="icon-btn" data-consumidor-action="rotar" title="Rotar token">🔄</button>' +
|
||
'<button type="button" class="icon-btn danger" data-consumidor-action="revocar" title="Revocar">🗑</button>' +
|
||
'</div>'
|
||
: '') +
|
||
'</div>';
|
||
}).join('');
|
||
}
|
||
|
||
// "🧠 Mente 3/4 · 🪫 Red 1/1" (disponibles/total) — P335/Fase 12
|
||
function resumenPoolsHtml(pools) {
|
||
if (!pools) return '';
|
||
return [['mente', '🧠 Mente'], ['red', '🪫 Red']].map(function (r) {
|
||
var p = pools[r[0]] || { total: 0, disponibles: 0 };
|
||
if (!p.total) return r[1] + ' <span class="unassigned">vacío</span>';
|
||
var clase = p.disponibles === 0 ? ' class="warn"' : '';
|
||
return r[1] + ' <span' + clase + '>' + p.disponibles + '/' + p.total + ' disponibles</span>';
|
||
}).join(' · ');
|
||
}
|
||
|
||
// Alta de key: asignarla a un pool en el mismo paso (opcional, P335/Fase 12)
|
||
function actualizarOpcionesPoolAlta() {
|
||
var sel = document.getElementById("f-pool");
|
||
var actual = sel.value;
|
||
sel.innerHTML = '<option value="">— ninguno —</option>' + consumidores.map(function (c) {
|
||
return ['mente', 'red'].map(function (rol) {
|
||
var v = esc(c.individuo) + '/' + rol;
|
||
return '<option value="' + v + '">' + esc(c.individuo) + ' · ' + rol + '</option>';
|
||
}).join('');
|
||
}).join('');
|
||
sel.value = actual;
|
||
}
|
||
|
||
function generarToken(individuo) {
|
||
return fetch('/consumidores', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ individuo: individuo })
|
||
}).then(function (r) {
|
||
return r.json().then(function (data) {
|
||
if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status));
|
||
return data;
|
||
});
|
||
});
|
||
}
|
||
|
||
function mostrarTokenGenerado(individuo, token) {
|
||
tokenBannerTitle.textContent = 'Token generado para ' + individuo + '.';
|
||
tokenBannerValue.textContent = token;
|
||
tokenBanner.classList.add('visible');
|
||
}
|
||
|
||
tokenCopyBtn.addEventListener("click", function () {
|
||
navigator.clipboard.writeText(tokenBannerValue.textContent).then(function () {
|
||
tokenCopyBtn.textContent = "Copiado";
|
||
setTimeout(function () { tokenCopyBtn.textContent = "Copiar"; }, 1500);
|
||
});
|
||
});
|
||
|
||
var nuevoIndividuoInput = document.getElementById("f-nuevo-individuo");
|
||
|
||
var addConsumidorToggler = crearTogglerInline("add-consumidor-trigger", "add-consumidor-form", "f-nuevo-individuo", function () {
|
||
nuevoIndividuoInput.value = "";
|
||
marcarCampoRequerido("field-nuevo-individuo", "hint-individuo-required", false);
|
||
});
|
||
|
||
document.getElementById("add-consumidor-trigger").addEventListener("click", addConsumidorToggler.abrir);
|
||
|
||
document.getElementById("add-consumidor-form").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-action]");
|
||
if (!btn) return;
|
||
if (btn.getAttribute("data-action") === "cancel-new-consumidor") addConsumidorToggler.cerrar();
|
||
if (btn.getAttribute("data-action") === "save-new-consumidor") guardarConsumidorNuevo(btn);
|
||
});
|
||
|
||
function guardarConsumidorNuevo(btn) {
|
||
var individuo = nuevoIndividuoInput.value.trim();
|
||
var vacio = !individuo;
|
||
marcarCampoRequerido("field-nuevo-individuo", "hint-individuo-required", vacio);
|
||
if (vacio) return;
|
||
|
||
btn.disabled = true;
|
||
|
||
generarToken(individuo)
|
||
.then(function (data) {
|
||
addConsumidorToggler.cerrar();
|
||
mostrarTokenGenerado(data.individuo, data.token);
|
||
return cargarConsumidores();
|
||
})
|
||
.catch(function (err) { mostrarErrorConsumidores('No se pudo generar el token: ' + err.message); })
|
||
.finally(function () { btn.disabled = false; });
|
||
}
|
||
|
||
document.getElementById("consumidores-list").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-consumidor-action]");
|
||
if (!btn) return;
|
||
var card = e.target.closest(".consumidor-card");
|
||
var individuo = card.getAttribute("data-individuo");
|
||
var action = btn.getAttribute("data-consumidor-action");
|
||
|
||
if (action === "rotar") {
|
||
generarToken(individuo)
|
||
.then(function (data) {
|
||
mostrarTokenGenerado(data.individuo, data.token);
|
||
return cargarConsumidores();
|
||
})
|
||
.catch(function (err) { mostrarErrorConsumidores('No se pudo rotar el token: ' + err.message); });
|
||
} else if (action === "pools") {
|
||
selectSection("pools");
|
||
} else if (action === "revocar") {
|
||
abrirModalConfirmacion({
|
||
titulo: "Revocar acceso",
|
||
confirmValue: individuo,
|
||
accion: "Sí, revocar",
|
||
accionEnCurso: "Revocando…",
|
||
bodyHtml: '¿Revocar el acceso de <b>' + esc(individuo) + '</b>? Esta acción no se puede deshacer — el individuo no va a poder pedir keys hasta que se le genere un token nuevo.' +
|
||
'<br><br>⚠️ También se borran sus pools Mente y Red (sin token no los puede usar).',
|
||
onConfirm: function () {
|
||
return fetch('/consumidores/' + encodeURIComponent(individuo), { method: 'DELETE' })
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
});
|
||
},
|
||
onDone: cargarConsumidores
|
||
});
|
||
}
|
||
});
|
||
|
||
// ---------- Usuarios (gestión del panel, P201/Fase4 — solo perfil admin) ----------
|
||
|
||
var usuarios = [];
|
||
var editingUsuario = null;
|
||
var usuariosErrorBanner = document.getElementById("usuarios-error-banner");
|
||
var usuariosErrorTitle = document.getElementById("usuarios-error-title");
|
||
|
||
function mostrarErrorUsuarios(msg) {
|
||
usuariosErrorTitle.textContent = msg;
|
||
usuariosErrorBanner.classList.add('visible');
|
||
}
|
||
|
||
function cargarUsuarios() {
|
||
return fetch('/usuarios')
|
||
.then(function (r) {
|
||
if (!r.ok) throw new Error('HTTP ' + r.status);
|
||
return r.json();
|
||
})
|
||
.then(function (data) {
|
||
usuarios = data;
|
||
renderUsuarios();
|
||
})
|
||
.catch(function (e) {
|
||
mostrarErrorUsuarios('No se pudo cargar la lista (' + e.message + ').');
|
||
});
|
||
}
|
||
|
||
function actionsHtmlUsuario(u) {
|
||
var activo = u.activo !== false;
|
||
return '<div class="card-icon-actions">' +
|
||
'<button type="button" class="icon-btn" data-usuario-action="edit" title="Editar">✏️</button>' +
|
||
'<button type="button" class="icon-btn' + (activo ? '' : ' primary') + '" data-usuario-action="toggle-activo" title="' +
|
||
(activo ? 'Desactivar' : 'Activar') + '">' + (activo ? '⏸' : '▶') +
|
||
'</button>' +
|
||
'<button type="button" class="icon-btn danger" data-usuario-action="delete" title="Eliminar">🗑</button>' +
|
||
'</div>';
|
||
}
|
||
|
||
function editPanelHtmlUsuario(u) {
|
||
return '<div class="edit-panel">' +
|
||
'<div class="ep-field">' +
|
||
'<label>Perfil</label>' +
|
||
'<select class="mono ep-perfil">' +
|
||
'<option value="operador"' + (u.perfil === 'operador' ? ' selected' : '') + '>operador</option>' +
|
||
'<option value="admin"' + (u.perfil === 'admin' ? ' selected' : '') + '>admin</option>' +
|
||
'</select>' +
|
||
'</div>' +
|
||
'<div class="ep-field">' +
|
||
'<label>Nueva password (opcional)</label>' +
|
||
'<input class="mono ep-password" type="password" placeholder="dejar vacío para no cambiar" />' +
|
||
'</div>' +
|
||
'<button type="button" class="action-btn primary" data-usuario-action="save-edit">Guardar</button>' +
|
||
'<button type="button" class="action-btn" data-usuario-action="cancel-edit">Cancelar</button>' +
|
||
'</div>';
|
||
}
|
||
|
||
function renderUsuarios() {
|
||
var list = document.getElementById("usuarios-list");
|
||
if (!usuarios.length) {
|
||
list.innerHTML = '<div class="empty-state">Sin usuarios todavía.</div>';
|
||
return;
|
||
}
|
||
|
||
list.innerHTML = usuarios.map(function (u) {
|
||
var activo = u.activo !== false;
|
||
var estadoHtml = activo
|
||
? '<span class="pill ok"><span class="dot"></span>activo</span>'
|
||
: '<span class="pill inactive"><span class="dot"></span>inactivo</span>';
|
||
return '<div class="key-card" data-usuario="' + u.usuario + '">' +
|
||
'<div class="id-block">' +
|
||
'<div class="field-label">Usuario</div>' +
|
||
'<div class="id mono">' + u.usuario + '</div>' +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Perfil</div>' +
|
||
'<div class="owner">' + u.perfil + '</div>' +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Estado</div>' +
|
||
estadoHtml +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Creado</div>' +
|
||
'<div class="timing mono"><span class="value">' + fmtRelative(u.creado) + '</span> · ' + fmtClock(u.creado) + '</div>' +
|
||
'</div>' +
|
||
(editingUsuario === u.usuario ? editPanelHtmlUsuario(u) : actionsHtmlUsuario(u)) +
|
||
'</div>';
|
||
}).join('');
|
||
}
|
||
|
||
document.getElementById("usuarios-list").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-usuario-action]");
|
||
if (!btn) return;
|
||
var card = e.target.closest(".key-card");
|
||
var usuario = card.getAttribute("data-usuario");
|
||
var action = btn.getAttribute("data-usuario-action");
|
||
var u = usuarios.find(function (uu) { return uu.usuario === usuario; });
|
||
|
||
if (action === "edit") {
|
||
editingUsuario = usuario;
|
||
renderUsuarios();
|
||
} else if (action === "cancel-edit") {
|
||
editingUsuario = null;
|
||
renderUsuarios();
|
||
} else if (action === "save-edit") {
|
||
var perfil = card.querySelector(".ep-perfil").value;
|
||
var passwordNueva = card.querySelector(".ep-password").value;
|
||
var body = { perfil: perfil };
|
||
if (passwordNueva) body.password = passwordNueva;
|
||
fetch('/usuarios/' + encodeURIComponent(usuario), {
|
||
method: 'PATCH',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(body)
|
||
})
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
})
|
||
.then(function () { editingUsuario = null; return cargarUsuarios(); })
|
||
.catch(function (err) { mostrarErrorUsuarios('No se pudo editar: ' + err.message); });
|
||
} else if (action === "toggle-activo") {
|
||
var nuevoActivo = !(u.activo !== false);
|
||
fetch('/usuarios/' + encodeURIComponent(usuario), {
|
||
method: 'PATCH',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ activo: nuevoActivo })
|
||
})
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
})
|
||
.then(function () { return cargarUsuarios(); })
|
||
.catch(function (err) { mostrarErrorUsuarios('No se pudo cambiar el estado: ' + err.message); });
|
||
} else if (action === "delete") {
|
||
abrirModalConfirmacion({
|
||
titulo: "Eliminar usuario",
|
||
confirmValue: usuario,
|
||
accion: "Sí, eliminar",
|
||
accionEnCurso: "Eliminando…",
|
||
bodyHtml: '¿Eliminar el usuario <b>' + usuario + '</b>? Esta acción no se puede deshacer — pierde acceso al panel inmediatamente.',
|
||
onConfirm: function () {
|
||
return fetch('/usuarios/' + encodeURIComponent(usuario), { method: 'DELETE' })
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return r.json();
|
||
});
|
||
},
|
||
onDone: cargarUsuarios
|
||
});
|
||
}
|
||
});
|
||
|
||
var nuevoUsuarioInput = document.getElementById("f-nuevo-usuario");
|
||
var nuevoUsuarioPasswordInput = document.getElementById("f-nuevo-usuario-password");
|
||
var toggleNuevoUsuarioPassword = document.getElementById("toggle-nuevo-usuario-password");
|
||
|
||
toggleNuevoUsuarioPassword.addEventListener("click", function () {
|
||
var showing = nuevoUsuarioPasswordInput.type === "text";
|
||
nuevoUsuarioPasswordInput.type = showing ? "password" : "text";
|
||
toggleNuevoUsuarioPassword.textContent = showing ? "mostrar" : "ocultar";
|
||
});
|
||
|
||
var addUsuarioToggler = crearTogglerInline("add-usuario-trigger", "add-usuario-form", "f-nuevo-usuario", function () {
|
||
nuevoUsuarioInput.value = "";
|
||
nuevoUsuarioPasswordInput.value = "";
|
||
nuevoUsuarioPasswordInput.type = "password";
|
||
toggleNuevoUsuarioPassword.textContent = "mostrar";
|
||
marcarCampoRequerido("field-nuevo-usuario", "hint-usuario-required", false);
|
||
marcarCampoRequerido("field-nuevo-usuario-password", "hint-usuario-password-required", false);
|
||
});
|
||
|
||
document.getElementById("add-usuario-trigger").addEventListener("click", addUsuarioToggler.abrir);
|
||
|
||
document.getElementById("add-usuario-form").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-action]");
|
||
if (!btn) return;
|
||
if (btn.getAttribute("data-action") === "cancel-new-usuario") addUsuarioToggler.cerrar();
|
||
if (btn.getAttribute("data-action") === "save-new-usuario") guardarUsuarioNuevo(btn);
|
||
});
|
||
|
||
function guardarUsuarioNuevo(btn) {
|
||
var usuario = nuevoUsuarioInput.value.trim();
|
||
var perfil = document.getElementById("f-nuevo-perfil").value;
|
||
var password = nuevoUsuarioPasswordInput.value;
|
||
|
||
var usuarioVacio = !usuario;
|
||
var passwordVacia = !password;
|
||
marcarCampoRequerido("field-nuevo-usuario", "hint-usuario-required", usuarioVacio);
|
||
marcarCampoRequerido("field-nuevo-usuario-password", "hint-usuario-password-required", passwordVacia);
|
||
if (usuarioVacio || passwordVacia) return;
|
||
|
||
btn.disabled = true;
|
||
|
||
fetch('/usuarios', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ usuario: usuario, perfil: perfil, password: password })
|
||
})
|
||
.then(function (r) {
|
||
return r.json().then(function (data) { return { ok: r.ok, data: data }; });
|
||
})
|
||
.then(function (result) {
|
||
if (!result.ok) throw new Error(result.data.error || ('HTTP ' + result.status));
|
||
addUsuarioToggler.cerrar();
|
||
return cargarUsuarios();
|
||
})
|
||
.catch(function (e) { mostrarErrorUsuarios(e.message); })
|
||
.finally(function () { btn.disabled = false; });
|
||
}
|
||
|
||
document.getElementById("groups").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-action]");
|
||
if (!btn) return;
|
||
|
||
var card = e.target.closest(".key-card");
|
||
var provider = card.getAttribute("data-provider");
|
||
var identificador = card.getAttribute("data-identificador");
|
||
var action = btn.getAttribute("data-action");
|
||
|
||
if (action === "edit") {
|
||
editing = provider + '/' + identificador;
|
||
render();
|
||
} else if (action === "cancel-edit") {
|
||
editing = null;
|
||
render();
|
||
} else if (action === "save-edit") {
|
||
var cuenta = card.querySelector(".ep-cuenta").value.trim();
|
||
var reset = card.querySelector(".ep-reset").value;
|
||
var nuevoId = card.querySelector(".ep-identificador").value.trim();
|
||
var cambios = { cuenta_origen: cuenta, reset_segundos: reset };
|
||
if (nuevoId && nuevoId !== identificador) cambios.identificador = nuevoId;
|
||
patchKey(provider, identificador, cambios)
|
||
.then(function () { editing = null; return cargarKeys(); })
|
||
.catch(function (err) { mostrarErrorAccion('No se pudo editar: ' + err.message); });
|
||
} else if (action === "toggle-activo") {
|
||
var k = keys.find(function (kk) { return kk.provider === provider && kk.identificador === identificador; });
|
||
var nuevoActivo = !(k.activo !== false);
|
||
patchKey(provider, identificador, { activo: nuevoActivo })
|
||
.then(function () { return cargarKeys(); })
|
||
.catch(function (err) { mostrarErrorAccion('No se pudo cambiar el estado: ' + err.message); });
|
||
} else if (action === "delete") {
|
||
abrirModalEliminar(provider, identificador);
|
||
} else if (action === "liberar") {
|
||
fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador) + '/liberar', { method: 'POST' })
|
||
.then(function (r) {
|
||
if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); });
|
||
return cargarKeys();
|
||
})
|
||
.catch(function (err) { mostrarErrorAccion('No se pudo liberar: ' + err.message); });
|
||
}
|
||
});
|
||
|
||
var deleteModalBackdrop = document.getElementById("delete-modal-backdrop");
|
||
var deleteModalTitle = document.getElementById("delete-modal-title");
|
||
var deleteModalBody = document.getElementById("delete-modal-body");
|
||
var deleteModalLabel = document.getElementById("delete-modal-label");
|
||
var deleteModalInput = document.getElementById("delete-modal-input");
|
||
var deleteModalCancel = document.getElementById("delete-modal-cancel");
|
||
var deleteModalConfirm = document.getElementById("delete-modal-confirm");
|
||
|
||
// Modal genérico de confirmación destructiva — "type to confirm" (pedido
|
||
// del Operador). Usado tanto para eliminar keys como revocar consumidores:
|
||
// pendingDelete = { confirmValue, accion, onConfirm, onDone }.
|
||
function abrirModalConfirmacion(opts) {
|
||
pendingDelete = opts;
|
||
deleteModalTitle.textContent = opts.titulo || "Confirmar";
|
||
deleteModalBody.innerHTML = opts.bodyHtml;
|
||
deleteModalLabel.textContent = 'Escribí "' + opts.confirmValue + '" para confirmar';
|
||
deleteModalInput.value = "";
|
||
deleteModalBackdrop.classList.add("visible");
|
||
deleteModalConfirm.textContent = opts.accion;
|
||
deleteModalConfirm.disabled = true;
|
||
deleteModalInput.focus();
|
||
}
|
||
|
||
// Qué pools pierden la key al eliminarla (P335/Fase 12): NEXXA la saca de todos, sin referencias colgadas
|
||
function avisoPoolsKey(provider, identificador) {
|
||
var k = keys.find(function (kk) { return kk.provider === provider && kk.identificador === identificador; });
|
||
if (!k || !k.pools || !k.pools.length) return '';
|
||
return '<br><br>⚠️ También sale de ' + k.pools.length + ' pool(s): ' +
|
||
k.pools.map(function (p) { return '<b>' + esc(p.individuo) + ' · ' + esc(p.rol) + '</b>'; }).join(', ') + '.';
|
||
}
|
||
|
||
function abrirModalEliminar(provider, identificador) {
|
||
abrirModalConfirmacion({
|
||
titulo: "Eliminar key",
|
||
confirmValue: identificador,
|
||
accion: "Sí, eliminar",
|
||
accionEnCurso: "Eliminando…",
|
||
bodyHtml: '¿Eliminar <b>' + esc(identificador) + '</b> (' + esc(provider) + ')? Esta acción no se puede deshacer — el historial de uso en <span class="mono">usos.log</span> se conserva, pero la key deja de existir en el registro.' +
|
||
avisoPoolsKey(provider, identificador),
|
||
onConfirm: function () { return deleteKey(provider, identificador); },
|
||
onDone: cargarKeys
|
||
});
|
||
}
|
||
|
||
function cerrarModalEliminar() {
|
||
pendingDelete = null;
|
||
deleteModalInput.value = "";
|
||
deleteModalBackdrop.classList.remove("visible");
|
||
}
|
||
|
||
deleteModalInput.addEventListener("input", function () {
|
||
deleteModalConfirm.disabled = !pendingDelete || deleteModalInput.value !== pendingDelete.confirmValue;
|
||
});
|
||
|
||
deleteModalCancel.addEventListener("click", cerrarModalEliminar);
|
||
|
||
deleteModalBackdrop.addEventListener("click", function (e) {
|
||
if (e.target === deleteModalBackdrop) cerrarModalEliminar();
|
||
});
|
||
|
||
document.addEventListener("keydown", function (e) {
|
||
if (e.key === "Escape" && deleteModalBackdrop.classList.contains("visible")) cerrarModalEliminar();
|
||
});
|
||
|
||
deleteModalConfirm.addEventListener("click", function () {
|
||
if (!pendingDelete) return;
|
||
var accionTexto = pendingDelete.accion;
|
||
var onDone = pendingDelete.onDone;
|
||
deleteModalConfirm.disabled = true;
|
||
deleteModalConfirm.textContent = pendingDelete.accionEnCurso;
|
||
pendingDelete.onConfirm()
|
||
.then(function () {
|
||
cerrarModalEliminar();
|
||
return onDone();
|
||
})
|
||
.catch(function (err) {
|
||
deleteModalConfirm.disabled = false;
|
||
deleteModalConfirm.textContent = accionTexto;
|
||
mostrarErrorAccion('No se pudo completar: ' + err.message);
|
||
});
|
||
});
|
||
|
||
function render() {
|
||
var groups = document.getElementById("groups");
|
||
groups.innerHTML = "";
|
||
|
||
var byProvider = {};
|
||
keys.forEach(function (k) {
|
||
(byProvider[k.provider] = byProvider[k.provider] || []).push(k);
|
||
});
|
||
|
||
var providers = Object.keys(byProvider).sort();
|
||
// Los conteos por estado salen de /resumen (cargarResumen, P337/Fase 2), no de un cálculo acá
|
||
document.getElementById("stat-total").textContent = keys.length;
|
||
document.getElementById("stat-providers").textContent = providers.length;
|
||
|
||
renderGauges(byProvider);
|
||
|
||
// Autocompletar "Cuenta de origen" con las ya cargadas (P204/Fase4,
|
||
// pedido del Operador) — evita retipear siempre desde cero. <datalist>
|
||
// nativo, sin JS de más: el navegador ya sabe filtrar/sugerir solo.
|
||
var cuentasList = document.getElementById("cuentas-origen-conocidas");
|
||
if (cuentasList) {
|
||
var cuentas = Array.from(new Set(keys.map(function (k) { return k.cuenta_origen; }).filter(Boolean))).sort();
|
||
cuentasList.innerHTML = cuentas.map(function (c) { return '<option value="' + c + '"></option>'; }).join('');
|
||
}
|
||
|
||
if (!keys.length) {
|
||
groups.innerHTML = '<div class="empty-state">Sin keys registradas todavía. Usá la pestaña «Alta de key» para cargar la primera.</div>';
|
||
return;
|
||
}
|
||
|
||
providers.forEach(function (provider) {
|
||
var title = document.createElement("div");
|
||
title.className = "group-title";
|
||
title.innerHTML = '<span>' + provider + '</span><span class="line"></span><span>' + byProvider[provider].length + '</span>';
|
||
groups.appendChild(title);
|
||
|
||
var list = document.createElement("div");
|
||
list.className = "card-list";
|
||
|
||
byProvider[provider]
|
||
.slice()
|
||
// Orden por último uso, no por disponible_desde (P204/Fase4, pedido
|
||
// del Operador: la vista tiene que reflejar cómo se CONSUME el pool,
|
||
// no un campo administrativo) — la que menos se usó recientemente
|
||
// aparece primero, mismo criterio que Registro.disponible en el
|
||
// backend (rotación) — así la lista muestra literalmente "quién
|
||
// sigue" en el orden real de reparto.
|
||
.sort(function (a, b) {
|
||
var uaA = a.ultimo_uso ? new Date(a.ultimo_uso).getTime() : 0;
|
||
var uaB = b.ultimo_uso ? new Date(b.ultimo_uso).getTime() : 0;
|
||
return uaA - uaB;
|
||
})
|
||
.forEach(function (k) {
|
||
var keyId = k.provider + '/' + k.identificador;
|
||
var activo = k.activo !== false;
|
||
// P204/Fase3: agotada (disponible_desde futuro, agotamiento real
|
||
// reportado por el consumidor) y reservada (reservado_hasta futuro,
|
||
// contención corta al dispensar) son estados distintos — una key
|
||
// puede estar reservada sin estar agotada, y viceversa nunca (agotada
|
||
// siempre libera la reserva). Reflejar exactamente el mismo filtro
|
||
// que usa Registro.disponible en el backend (Armonía Integral).
|
||
// P337/Fase 2: el estado lo calcula el servidor (k.estado/hasta/por/motivo); acá no se recalcula
|
||
var bloqueada = ['en_uso', 'en_pausa', 'agotada'].indexOf(k.estado) >= 0;
|
||
var isNew = lastCreated && lastCreated.provider === k.provider && lastCreated.identificador === k.identificador;
|
||
var card = document.createElement("div");
|
||
card.className = "key-card" + (isNew ? " is-new" : "");
|
||
card.setAttribute("data-provider", k.provider);
|
||
card.setAttribute("data-identificador", k.identificador);
|
||
|
||
// Estado + su timing van juntos (P204/Fase4, rediseño de columnas
|
||
// por propósito real — el timing es una aclaración del estado, no
|
||
// un dato independiente) — pill arriba, "vence en X"/"libera en X"
|
||
// como subtexto, sin ocupar una columna propia.
|
||
var asignadaHtml;
|
||
if (k.estado === 'en_uso' && k.por) {
|
||
asignadaHtml = '<div class="owner">' + esc(k.por) + '</div>';
|
||
} else if (k.ultimo_individuo) {
|
||
asignadaHtml = '<div class="owner unassigned">último: ' + esc(k.ultimo_individuo) + '</div>';
|
||
} else {
|
||
asignadaHtml = '<div class="owner unassigned">— libre —</div>';
|
||
}
|
||
|
||
// Último uso (P204/Fase4, pedido del Operador): NEXXA sirve keys —
|
||
// el dato que más importa operativamente es cuándo se dispensó por
|
||
// última vez, no cuándo "vence" algo. Es también la señal visual
|
||
// de que la rotación (Fase4/4.6) funciona: ninguna key debería
|
||
// quedar mucho más atrás que las demás del mismo provider.
|
||
var ultimoUsoHtml = k.ultimo_uso
|
||
? '<span class="value">' + fmtRelative(k.ultimo_uso) + '</span> · ' + fmtClock(k.ultimo_uso)
|
||
: '<span class="value">nunca</span>';
|
||
|
||
card.innerHTML =
|
||
'<div class="id-block">' +
|
||
'<div class="field-label">Identificador</div>' +
|
||
'<div class="id mono">' + esc(k.identificador) + '</div>' +
|
||
'<div class="provider">' + esc(k.provider) + ' · cuenta: ' + esc(k.cuenta_origen) + '</div>' +
|
||
chipsPools(k.pools) +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Estado</div>' +
|
||
estadoHtml(k) +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Último uso</div>' +
|
||
'<div class="timing mono">' + ultimoUsoHtml + '</div>' +
|
||
'</div>' +
|
||
'<div>' +
|
||
'<div class="field-label">Asignada a</div>' +
|
||
asignadaHtml +
|
||
'</div>' +
|
||
(editing === keyId ? editPanelHtml(k) : actionsHtml(k, keyId, activo, activo && bloqueada));
|
||
|
||
list.appendChild(card);
|
||
});
|
||
|
||
groups.appendChild(list);
|
||
});
|
||
}
|
||
|
||
// Gauges circulares por provider (P204/Fase4, estilo resumen de Proxmox) —
|
||
// distribución real del pool: qué % de las APIs registradas es de cada
|
||
// proveedor (no "% en uso", que confundía — un gauge de uso solo tiene
|
||
// sentido comparado contra el resto del mismo provider, no como % del
|
||
// total, y con un solo provider siempre daba una lectura rara). Se
|
||
// calcula de los datos ya cargados de /keys, sin fetch propio.
|
||
function renderGauges(byProvider) {
|
||
var el = document.getElementById("gauges");
|
||
if (!el) return;
|
||
|
||
var providers = Object.keys(byProvider).sort();
|
||
if (!providers.length) {
|
||
el.innerHTML = '';
|
||
return;
|
||
}
|
||
|
||
var totalKeys = providers.reduce(function (sum, p) {
|
||
return sum + byProvider[p].filter(function (k) { return k.activo !== false; }).length;
|
||
}, 0);
|
||
|
||
el.innerHTML = providers.map(function (provider) {
|
||
var count = byProvider[provider].filter(function (k) { return k.activo !== false; }).length;
|
||
var pct = totalKeys ? Math.round((count / totalKeys) * 100) : 0;
|
||
return gaugeHtml(pct, provider, count + '/' + totalKeys);
|
||
}).join('');
|
||
}
|
||
|
||
function gaugeHtml(pct, label, sub) {
|
||
var r = 46, c = Math.round(2 * Math.PI * r);
|
||
var offset = Math.round(c - (pct / 100) * c);
|
||
// Distribución, no alerta — a diferencia de un gauge de "% en uso", acá
|
||
// un valor alto no es malo (un solo provider = 100%, es normal), así
|
||
// que no escala a rojo/naranja como si fuera una advertencia.
|
||
var color = 'var(--accent)';
|
||
return (
|
||
'<div class="gauge">' +
|
||
'<svg viewBox="0 0 120 120">' +
|
||
'<circle class="gauge-bg" cx="60" cy="60" r="' + r + '"></circle>' +
|
||
'<circle class="gauge-fg" cx="60" cy="60" r="' + r + '" style="stroke:' + color + ';stroke-dasharray:' + c + ';stroke-dashoffset:' + offset + '" transform="rotate(-90 60 60)"></circle>' +
|
||
'<text x="60" y="56" class="gauge-pct">' + pct + '%</text>' +
|
||
'<text x="60" y="76" class="gauge-sub">' + sub + '</text>' +
|
||
'</svg>' +
|
||
'<div class="gauge-label">' + label + '</div>' +
|
||
'</div>'
|
||
);
|
||
}
|
||
|
||
// Actividad reciente + gráfico de dispensas por día (P204/Fase4) — ambos
|
||
// proporcionados al volumen real de usos.log (hoy escaso): la lista muestra
|
||
// lo que hay sin inventar agregados, el gráfico crece solo con el uso real.
|
||
// Una fila del registro (P337/Fase 2): la usan "Últimos eventos" y la sección Registro
|
||
function filaEvento(u) {
|
||
return (
|
||
'<tr>' +
|
||
'<td class="mono nowrap" title="' + esc(u.en) + '">' + fmtClock(u.en) + '<div class="timing-sub">' + fmtRelative(u.en) + '</div></td>' +
|
||
'<td class="mono">' + esc(u.provider) + '/' + esc(u.identificador) + '</td>' +
|
||
'<td>' + eventoTexto(u.evento) + '</td>' +
|
||
'<td class="mono">' + esc(u.individuo || '—') + '</td>' +
|
||
'<td>' + esc(u.motivo || '') + '</td>' +
|
||
'<td class="mono nowrap">' + (u.hasta ? cuando(u.hasta) : '') + '</td>' +
|
||
'</tr>'
|
||
);
|
||
}
|
||
|
||
function tablaEventos(usos, vacio) {
|
||
if (!usos.length) return '<div class="empty-state">' + vacio + '</div>';
|
||
return '<table class="tabla-registro"><thead><tr><th>Cuándo</th><th>Key</th><th>Qué pasó</th><th>Quién</th>' +
|
||
'<th>Detalle</th><th>Hasta</th></tr></thead><tbody>' + usos.map(filaEvento).join('') + '</tbody></table>';
|
||
}
|
||
|
||
function statHtml(etiqueta, valor, clase, ayuda) {
|
||
return '<div class="stat"' + (ayuda ? ' title="' + esc(ayuda) + '"' : '') + '><div class="stat-label">' + etiqueta +
|
||
'</div><div class="stat-value mono ' + (clase || '') + '">' + valor + '</div></div>';
|
||
}
|
||
|
||
// Dashboard desde /resumen (P337/Fase 2): estados AHORA (todos, también en 0) y lo que pasó en 24 h
|
||
function cargarResumen() {
|
||
return pedirJson('/resumen?horas=24').then(function (r) {
|
||
document.getElementById('stats-ahora').innerHTML = ESTADOS_ORDEN.map(function (e) {
|
||
var u = ESTADO_UI[e];
|
||
return statHtml('<span class="pill ' + u.clase + '"><span class="dot"></span>' + u.texto + '</span>', r.ahora[e] || 0);
|
||
}).join('');
|
||
var ev = r.eventos;
|
||
var cambios = ev.alta + ev.editada + ev.renombrada + ev.baja + ev['liberada-admin'];
|
||
document.getElementById('stats-24h').innerHTML =
|
||
statHtml('Entregas', ev.dispensada, '', 'keys entregadas a un consumidor') +
|
||
statHtml('Pausas por límite', ev.pausada, 'warn', 'el proveedor contestó límite por minuto: la key vuelve sola en minutos') +
|
||
statHtml('Agotamientos de cuota', ev.agotada, 'warn', 'cuota del ciclo agotada: vuelve al reiniciarse la cuota') +
|
||
statHtml('Cambios de admin', cambios, '', 'altas, ediciones, renombres, bajas y liberaciones por admin');
|
||
renderPorKey(r.por_key);
|
||
}).catch(function () { /* cargarKeys ya avisa los problemas de conexión */ });
|
||
}
|
||
|
||
function renderPorKey(filas) {
|
||
var el = document.getElementById('por-key');
|
||
if (!el) return;
|
||
if (!filas.length) { el.innerHTML = '<div class="empty-state">Sin keys registradas.</div>'; return; }
|
||
el.innerHTML = '<table class="tabla-registro"><thead><tr><th>Key</th><th>Estado</th><th>Entregas</th><th>Pausas</th>' +
|
||
'<th>Agotamientos</th><th>Último evento</th></tr></thead><tbody>' + filas.map(function (k) {
|
||
var ult = k.ultimo_evento;
|
||
return '<tr><td class="mono">' + esc(k.provider) + '/' + esc(k.identificador) + '</td><td>' + estadoHtml(k) + '</td>' +
|
||
'<td class="mono">' + k.eventos.dispensada + '</td><td class="mono">' + k.eventos.pausada + '</td>' +
|
||
'<td class="mono">' + k.eventos.agotada + '</td>' +
|
||
'<td>' + (ult ? eventoTexto(ult.evento) + '<div class="timing-sub">' + fmtRelative(ult.en) + '</div>' : '—') + '</td></tr>';
|
||
}).join('') + '</tbody></table>';
|
||
}
|
||
|
||
function renderBarChart(entregas) {
|
||
var el = document.getElementById("bar-chart");
|
||
if (!el) return;
|
||
|
||
var dias = [];
|
||
for (var i = 6; i >= 0; i--) {
|
||
var d = new Date();
|
||
d.setDate(d.getDate() - i);
|
||
dias.push(d.toLocaleDateString('sv-SE')); // AAAA-MM-DD en hora LOCAL (antes UTC: el día cambiaba a las 21 h)
|
||
}
|
||
var counts = {};
|
||
dias.forEach(function (d) { counts[d] = 0; });
|
||
entregas.forEach(function (u) {
|
||
var d = new Date(u.en).toLocaleDateString('sv-SE');
|
||
if (counts.hasOwnProperty(d)) counts[d]++;
|
||
});
|
||
var max = Math.max.apply(null, dias.map(function (d) { return counts[d]; }).concat([1]));
|
||
|
||
el.innerHTML = dias.map(function (d) {
|
||
var h = Math.max(2, Math.round((counts[d] / max) * 60));
|
||
return (
|
||
'<div class="bar-col" title="' + counts[d] + ' entregas el ' + d + '">' +
|
||
'<div class="bar" style="height:' + h + 'px"></div>' +
|
||
'<div class="bar-label">' + d.slice(5) + '</div>' +
|
||
'</div>'
|
||
);
|
||
}).join('');
|
||
}
|
||
|
||
// Sección Registro (P337/Fase 2): filtros que el SERVIDOR aplica (/usos); las opciones salen de los datos reales
|
||
function opcionesRegistro() {
|
||
var ev = document.getElementById('reg-evento');
|
||
if (ev.options.length === 1) {
|
||
Object.keys(EVENTO_UI).forEach(function (e) { ev.add(new Option(eventoTexto(e), e)); });
|
||
}
|
||
var sel = document.getElementById('reg-key');
|
||
var actual = sel.value;
|
||
sel.length = 1;
|
||
keys.map(function (k) { return k.provider + '/' + k.identificador; }).sort().forEach(function (ref) { sel.add(new Option(ref, ref)); });
|
||
sel.value = actual;
|
||
}
|
||
|
||
function cargarRegistro() {
|
||
opcionesRegistro();
|
||
var q = ['horas=' + encodeURIComponent(document.getElementById('reg-horas').value), 'limit=500'];
|
||
var ev = document.getElementById('reg-evento').value;
|
||
var key = document.getElementById('reg-key').value;
|
||
var quien = document.getElementById('reg-individuo').value.trim();
|
||
if (ev) q.push('evento=' + encodeURIComponent(ev));
|
||
if (key) {
|
||
var partes = key.split('/');
|
||
q.push('provider=' + encodeURIComponent(partes[0]), 'identificador=' + encodeURIComponent(partes.slice(1).join('/')));
|
||
}
|
||
if (quien) q.push('individuo=' + encodeURIComponent(quien));
|
||
return pedirJson('/usos?' + q.join('&')).then(function (usos) {
|
||
document.getElementById('reg-cuenta').textContent = usos.length + (usos.length === 500 ? '+ (los 500 más recientes)' : '') + ' evento(s)';
|
||
document.getElementById('registro-lista').innerHTML = tablaEventos(usos, 'Ningún evento con esos filtros.');
|
||
}).catch(function (e) {
|
||
document.getElementById('registro-lista').innerHTML = '<div class="empty-state">No se pudo leer el registro (' + esc(e.message) + ').</div>';
|
||
});
|
||
}
|
||
|
||
['reg-horas', 'reg-evento', 'reg-key'].forEach(function (id) {
|
||
document.getElementById(id).addEventListener('change', cargarRegistro);
|
||
});
|
||
document.getElementById('reg-individuo').addEventListener('keydown', function (e) { if (e.key === 'Enter') cargarRegistro(); });
|
||
document.querySelector('[data-ir-registro]').addEventListener('click', function (e) { e.preventDefault(); selectSection('registro'); });
|
||
|
||
// Últimos eventos y entregas por día desde /usos YA filtrado en el servidor (antes: los últimos 100 eventos de todo
|
||
// tipo, y el gráfico contaba como entrega cualquier evento)
|
||
function cargarUsos() {
|
||
return Promise.all([
|
||
pedirJson('/usos?horas=24&limit=12').then(function (usos) {
|
||
document.getElementById('actividad-lista').innerHTML = tablaEventos(usos, 'Nada en las últimas 24 h.');
|
||
}),
|
||
pedirJson('/usos?evento=dispensada&horas=168&limit=2000').then(renderBarChart)
|
||
]).catch(function () { /* cargarKeys ya avisa los problemas de conexión */ });
|
||
}
|
||
|
||
function cargarKeys() {
|
||
return fetch('/keys')
|
||
.then(function (r) {
|
||
if (!r.ok) throw new Error('HTTP ' + r.status);
|
||
return r.json();
|
||
})
|
||
.then(function (data) {
|
||
keys = data;
|
||
actualizarProvidersConocidos();
|
||
loadError.classList.remove('visible');
|
||
nodePill.classList.remove('error');
|
||
nodePillText.textContent = 'servicio activo · puerto 4568';
|
||
render();
|
||
})
|
||
.catch(function (e) {
|
||
loadError.textContent = 'No se pudo cargar el estado de las keys (' + e.message + ').';
|
||
loadError.classList.add('visible');
|
||
nodePill.classList.add('error');
|
||
nodePillText.textContent = 'sin conexión';
|
||
});
|
||
}
|
||
|
||
// Sugerencias de provider para el alta (P335/Fase 7): los que ya tienen keys + los habituales, sin lista fija
|
||
var PROVIDERS_HABITUALES = ["gemini", "deepseek", "groq", "openai", "anthropic"];
|
||
function actualizarProvidersConocidos() {
|
||
var vistos = {};
|
||
PROVIDERS_HABITUALES.concat(keys.map(function (k) { return k.provider; })).forEach(function (p) { vistos[p] = true; });
|
||
document.getElementById("providers-conocidos").innerHTML = Object.keys(vistos).sort().map(function (p) {
|
||
return '<option value="' + esc(p) + '"></option>';
|
||
}).join('');
|
||
}
|
||
|
||
var toggleValor = document.getElementById("toggle-valor");
|
||
var valorInput = document.getElementById("f-valor");
|
||
toggleValor.addEventListener("click", function () {
|
||
var showing = valorInput.type === "text";
|
||
valorInput.type = showing ? "password" : "text";
|
||
toggleValor.textContent = showing ? "mostrar" : "ocultar";
|
||
});
|
||
|
||
// Fichas inline de alta ("+" sobre la lista, P201/Fase3 — reemplazan las
|
||
// pestañas separadas de alta: mismo estilo visual que las fichas ya
|
||
// cargadas, se abren/cierran in-place). abrir/cerrar es el mismo
|
||
// mecanismo para keys y consumidores — un solo helper, no duplicado.
|
||
function crearTogglerInline(triggerId, formId, primerCampoId, limpiarFn) {
|
||
var trigger = document.getElementById(triggerId);
|
||
var form = document.getElementById(formId);
|
||
return {
|
||
abrir: function () {
|
||
trigger.style.display = "none";
|
||
form.classList.add("visible");
|
||
document.getElementById(primerCampoId).focus();
|
||
},
|
||
cerrar: function () {
|
||
if (limpiarFn) limpiarFn();
|
||
form.classList.remove("visible");
|
||
trigger.style.display = "";
|
||
}
|
||
};
|
||
}
|
||
|
||
// Toggle de error+hint de un campo requerido — mismo patrón repetido en
|
||
// el alta de keys y en el alta de consumidores, extraído una sola vez.
|
||
function marcarCampoRequerido(fieldId, hintId, vacio) {
|
||
document.getElementById(fieldId).classList.toggle("has-error", vacio);
|
||
document.getElementById(hintId).classList.toggle("visible", vacio);
|
||
}
|
||
|
||
var addKeyErrorBanner = document.getElementById("add-key-error-banner");
|
||
var addKeyErrorTitle = document.getElementById("add-key-error-title");
|
||
|
||
function limpiarAddKeyForm() {
|
||
document.getElementById("f-identificador").value = "";
|
||
document.getElementById("f-cuenta-origen").value = "";
|
||
document.getElementById("f-pool").value = "";
|
||
valorInput.value = "";
|
||
valorInput.type = "password";
|
||
toggleValor.textContent = "mostrar";
|
||
marcarCampoRequerido("field-identificador", "hint-id-required", false);
|
||
document.getElementById("hint-id-taken").classList.remove("visible");
|
||
marcarCampoRequerido("field-cuenta-origen", "hint-cuenta-required", false);
|
||
marcarCampoRequerido("field-valor", "hint-valor-required", false);
|
||
addKeyErrorBanner.classList.remove("visible");
|
||
}
|
||
|
||
var addKeyToggler = crearTogglerInline("add-key-trigger", "add-key-form", "f-identificador", limpiarAddKeyForm);
|
||
|
||
document.getElementById("add-key-trigger").addEventListener("click", addKeyToggler.abrir);
|
||
|
||
document.getElementById("add-key-form").addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-action]");
|
||
if (!btn) return;
|
||
if (btn.getAttribute("data-action") === "cancel-new") addKeyToggler.cerrar();
|
||
if (btn.getAttribute("data-action") === "save-new") guardarKeyNueva(btn);
|
||
});
|
||
|
||
function guardarKeyNueva(btn) {
|
||
var identificador = document.getElementById("f-identificador").value.trim();
|
||
var cuentaOrigen = document.getElementById("f-cuenta-origen").value.trim();
|
||
var valor = valorInput.value;
|
||
var provider = document.getElementById("f-provider").value.trim().toLowerCase();
|
||
var resetSegundos = document.getElementById("f-reset").value;
|
||
|
||
var idVacio = !identificador;
|
||
var idTaken = !idVacio && keys.some(function (k) { return k.provider === provider && k.identificador === identificador; });
|
||
|
||
marcarCampoRequerido("field-identificador", "hint-id-required", idVacio);
|
||
document.getElementById("hint-id-taken").classList.toggle("visible", idTaken);
|
||
document.getElementById("field-identificador").classList.toggle("has-error", idVacio || idTaken);
|
||
marcarCampoRequerido("field-cuenta-origen", "hint-cuenta-required", !cuentaOrigen);
|
||
marcarCampoRequerido("field-valor", "hint-valor-required", !valor);
|
||
addKeyErrorBanner.classList.remove("visible");
|
||
|
||
if (!provider) {
|
||
addKeyErrorTitle.textContent = 'Falta el provider (ej. gemini, deepseek).';
|
||
addKeyErrorBanner.classList.add("visible");
|
||
}
|
||
if (!provider || idVacio || idTaken || !cuentaOrigen || !valor) return;
|
||
|
||
btn.disabled = true;
|
||
|
||
fetch('/alta', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({
|
||
provider: provider,
|
||
identificador: identificador,
|
||
cuenta_origen: cuentaOrigen,
|
||
reset_segundos: resetSegundos,
|
||
valor: valor
|
||
})
|
||
})
|
||
.then(function (r) {
|
||
return r.json().then(function (data) { return { ok: r.ok, status: r.status, data: data }; });
|
||
})
|
||
.then(function (result) {
|
||
if (!result.ok) {
|
||
throw new Error(result.data.error || ('HTTP ' + result.status));
|
||
}
|
||
|
||
lastCreated = { provider: provider, identificador: identificador };
|
||
var pool = document.getElementById("f-pool").value;
|
||
var asignar = Promise.resolve();
|
||
if (pool) {
|
||
var partes = pool.split('/');
|
||
asignar = pedirJson('/pools/' + encodeURIComponent(partes[0]) + '/' + partes[1], {
|
||
method: 'POST', headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ provider: provider, identificador: identificador })
|
||
});
|
||
}
|
||
return asignar.then(function () {
|
||
addKeyToggler.cerrar();
|
||
return cargarKeys();
|
||
});
|
||
})
|
||
.catch(function (e) {
|
||
addKeyErrorTitle.textContent = e.message;
|
||
addKeyErrorBanner.classList.add("visible");
|
||
})
|
||
.finally(function () {
|
||
btn.disabled = false;
|
||
});
|
||
}
|
||
|
||
// ---------- Pools por individuo: mente y red (P335/Fase 7) ----------
|
||
// Lee /pools (estado de cada key de cada pool, nunca valores) y /consumidores (individuos con token: aparecen
|
||
// aunque todavía no tengan pool). Asignar/quitar solo admin; el backend lo valida igual (ME-683).
|
||
var poolsError = document.getElementById("pools-error");
|
||
var poolsLista = document.getElementById("pools-lista");
|
||
var ROLES_POOL = [
|
||
{ rol: "mente", titulo: "🧠 Mente", ayuda: "piensa y opera" },
|
||
{ rol: "red", titulo: "🪫 Red", ayuda: "solo aviso de batería baja" }
|
||
];
|
||
|
||
function pedirJson(url, opts) {
|
||
return fetch(url, opts).then(function (r) {
|
||
return r.json().then(function (d) {
|
||
if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status));
|
||
return d;
|
||
});
|
||
});
|
||
}
|
||
|
||
function cargarPools() {
|
||
poolsError.classList.remove('visible');
|
||
return Promise.all([pedirJson('/pools'), pedirJson('/consumidores')])
|
||
.then(function (res) {
|
||
consumidores = res[1] || [];
|
||
renderConsumidores(); // el resumen de pools de Individuos y el Dashboard quedan al día
|
||
renderPools(res[0].individuos || {}, consumidores);
|
||
return cargarKeys(); // los chips de pools de cada key (sección APIs) quedan al día tras cualquier cambio
|
||
})
|
||
.catch(function (e) {
|
||
poolsError.textContent = 'No se pudieron cargar los pools (' + e.message + ').';
|
||
poolsError.classList.add('visible');
|
||
});
|
||
}
|
||
|
||
// Misma presentación que APIs (P337/Fase 2): una sola función de estado
|
||
function pillEstado(f) {
|
||
return estadoHtml(f);
|
||
}
|
||
|
||
// Estado de la vista (P335/Fase 12): lo último que se leyó y qué columna se está editando ('individuo|rol')
|
||
var ultimoPools = {};
|
||
var ultimosConsumidores = [];
|
||
var editandoPool = null;
|
||
|
||
function renderPools(pools, consumidoresLista) {
|
||
ultimoPools = pools;
|
||
ultimosConsumidores = consumidoresLista;
|
||
var nombres = {};
|
||
consumidoresLista.forEach(function (c) { nombres[c.individuo] = true; });
|
||
Object.keys(pools).forEach(function (n) { nombres[n] = true; });
|
||
var lista = Object.keys(nombres).sort();
|
||
if (!lista.length) {
|
||
poolsLista.innerHTML = '<div class="empty-state">Sin individuos con token todavía. Dalos de alta en «Individuos».</div>';
|
||
return;
|
||
}
|
||
|
||
poolsLista.innerHTML = lista.map(function (ind) {
|
||
var columnas = ROLES_POOL.map(function (r) {
|
||
var filas = (pools[ind] && pools[ind][r.rol]) || [];
|
||
var cuerpo = editandoPool === ind + '|' + r.rol ? editorPoolHtml(filas) : vistaPoolHtml(filas, r);
|
||
return '<div class="pool-col" data-rol="' + r.rol + '">' +
|
||
'<div class="pool-col-titulo"><span class="field-label">' + r.titulo + ' <span class="provider">· ' + r.ayuda + '</span></span>' +
|
||
(esAdmin && editandoPool !== ind + '|' + r.rol
|
||
? '<button type="button" class="icon-btn" data-action="pool-editar" title="Editar el pool">✏️</button>' : '') +
|
||
'</div>' + cuerpo + '</div>';
|
||
}).join('');
|
||
return '<div class="key-card pool-card" data-individuo="' + esc(ind) + '">' +
|
||
'<div class="id-block"><div class="field-label">Individuo</div><div class="id mono">' + esc(ind) + '</div></div>' +
|
||
columnas + '</div>';
|
||
}).join('');
|
||
}
|
||
|
||
// Ver (R): cada key con su estado; el admin puede moverla al otro rol (⇄) o quitarla (✕)
|
||
function vistaPoolHtml(filas, r) {
|
||
if (!filas.length) return '<div class="owner unassigned">— vacío: NEXXA responde pool_vacio —</div>';
|
||
var otro = r.rol === 'mente' ? 'Red' : 'Mente';
|
||
return filas.map(function (f) {
|
||
return '<div class="pool-key" data-provider="' + esc(f.provider) + '" data-identificador="' + esc(f.identificador) + '">' +
|
||
'<div><span class="mono">' + esc(f.identificador) + '</span> <span class="provider">' + esc(f.provider) + '</span></div>' +
|
||
'<div>' + pillEstado(f) + '</div>' +
|
||
(esAdmin
|
||
? '<div class="card-icon-actions">' +
|
||
'<button type="button" class="icon-btn" data-action="pool-mover" title="Mover a ' + otro + '">⇄</button>' +
|
||
'<button type="button" class="icon-btn danger" data-action="pool-quitar" title="Quitar del pool">✕</button></div>'
|
||
: '') +
|
||
'</div>';
|
||
}).join('');
|
||
}
|
||
|
||
// Editar (C/U/D en un paso): todas las keys con casillas, agrupadas por provider; Guardar deja el pool exactamente así
|
||
function editorPoolHtml(filas) {
|
||
var enPool = {};
|
||
filas.forEach(function (f) { enPool[f.provider + '/' + f.identificador] = true; });
|
||
var porProvider = {};
|
||
keys.forEach(function (k) { (porProvider[k.provider] = porProvider[k.provider] || []).push(k); });
|
||
var grupos = Object.keys(porProvider).sort().map(function (prov) {
|
||
return '<div class="pool-editor-grupo"><div class="provider">' + esc(prov) + '</div>' +
|
||
porProvider[prov].map(function (k) {
|
||
var ref = k.provider + '/' + k.identificador;
|
||
return '<label class="pool-editor-item"><input type="checkbox" value="' + esc(ref) + '"' + (enPool[ref] ? ' checked' : '') + ' /> ' +
|
||
'<span class="mono">' + esc(k.identificador) + '</span>' + (k.activo === false ? ' <span class="provider">(desactivada)</span>' : '') +
|
||
'</label>';
|
||
}).join('') + '</div>';
|
||
}).join('');
|
||
return '<div class="pool-editor">' + (grupos || '<div class="owner unassigned">No hay keys cargadas.</div>') +
|
||
'<div class="pool-editor-acciones">' +
|
||
'<button type="button" class="action-btn primary" data-action="pool-guardar">Guardar</button>' +
|
||
'<button type="button" class="action-btn" data-action="pool-cancelar">Cancelar</button></div></div>';
|
||
}
|
||
|
||
function errorPools(err) {
|
||
poolsError.textContent = 'No se pudo cambiar el pool: ' + err.message;
|
||
poolsError.classList.add('visible');
|
||
}
|
||
|
||
function guardarPool(base, refs) {
|
||
return pedirJson(base, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ refs: refs }) })
|
||
.then(function () { editandoPool = null; return cargarPools(); });
|
||
}
|
||
|
||
poolsLista.addEventListener("click", function (e) {
|
||
var btn = e.target.closest("[data-action]");
|
||
if (!btn) return;
|
||
var card = btn.closest(".pool-card");
|
||
var col = btn.closest(".pool-col");
|
||
var ind = card.getAttribute("data-individuo");
|
||
var rol = col.getAttribute("data-rol");
|
||
var base = '/pools/' + encodeURIComponent(ind) + '/' + rol;
|
||
var accion = btn.getAttribute("data-action");
|
||
var item = btn.closest(".pool-key");
|
||
var refItem = item ? encodeURIComponent(item.getAttribute("data-provider")) + '/' + encodeURIComponent(item.getAttribute("data-identificador")) : null;
|
||
|
||
if (accion === "pool-editar") {
|
||
editandoPool = ind + '|' + rol;
|
||
renderPools(ultimoPools, ultimosConsumidores);
|
||
return;
|
||
}
|
||
if (accion === "pool-cancelar") {
|
||
editandoPool = null;
|
||
renderPools(ultimoPools, ultimosConsumidores);
|
||
return;
|
||
}
|
||
if (accion === "pool-guardar") {
|
||
var refs = Array.prototype.map.call(col.querySelectorAll('.pool-editor input:checked'), function (c) { return c.value; });
|
||
if (!refs.length && ((ultimoPools[ind] || {})[rol] || []).length) {
|
||
// Vaciar es destructivo: confirmación escribiendo el nombre del individuo (mismo modal que eliminar una key)
|
||
abrirModalConfirmacion({
|
||
titulo: "Vaciar pool",
|
||
confirmValue: ind,
|
||
accion: "Sí, vaciar",
|
||
accionEnCurso: "Vaciando…",
|
||
bodyHtml: '¿Dejar vacío el pool <b>' + esc(rol) + '</b> de <b>' + esc(ind) + '</b>? Mientras esté vacío, NEXXA le responde <span class="mono">pool_vacio</span> cuando pida por ese rol.',
|
||
onConfirm: function () { return guardarPool(base, []); },
|
||
onDone: function () { return Promise.resolve(); }
|
||
});
|
||
return;
|
||
}
|
||
btn.disabled = true;
|
||
guardarPool(base, refs).catch(function (err) { btn.disabled = false; errorPools(err); });
|
||
return;
|
||
}
|
||
|
||
var pedido;
|
||
if (accion === "pool-mover") {
|
||
pedido = pedirJson(base + '/' + refItem + '/mover', { method: 'POST' });
|
||
} else if (accion === "pool-quitar") {
|
||
pedido = pedirJson(base + '/' + refItem, { method: 'DELETE' });
|
||
} else {
|
||
return;
|
||
}
|
||
btn.disabled = true;
|
||
pedido.then(cargarPools).catch(function (err) { btn.disabled = false; errorPools(err); });
|
||
});
|
||
})();
|