Tests ADN / test (push) Canceled after 0s
PATCH /keys acepta 'identificador': renombra en el registro y en todos los pools, deja el evento 'renombrada (antes X)' en usos y lo rechaza si la key está reservada o el nombre existe (409). Campo Identificador en el panel de edición. Los chips de pools de APIs se refrescan tras cambiar un pool. Suite: humo HTTP 63, pools 45, revertir 10. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
1421 lines
64 KiB
JavaScript
1421 lines
64 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", 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-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 === "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);
|
|
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" });
|
|
}
|
|
|
|
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();
|
|
var ahora = Date.now();
|
|
// P204/Fase3: agotada = disponible_desde en el futuro (agotamiento REAL,
|
|
// reportado por el consumidor) — reservada = bajo reserva corta de
|
|
// contención (reservado_hasta en el futuro), no es lo mismo.
|
|
var agotadas = keys.filter(function (k) { return new Date(k.disponible_desde).getTime() > ahora; }).length;
|
|
var reservadas = keys.filter(function (k) {
|
|
return k.reservado_hasta && new Date(k.reservado_hasta).getTime() > ahora;
|
|
}).length;
|
|
|
|
document.getElementById("stat-total").textContent = keys.length;
|
|
document.getElementById("stat-providers").textContent = providers.length;
|
|
document.getElementById("stat-agotadas").textContent = agotadas;
|
|
document.getElementById("stat-reservadas").textContent = reservadas;
|
|
|
|
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).
|
|
var agotada = new Date(k.disponible_desde).getTime() > ahora;
|
|
var reservada = !agotada && k.reservado_hasta && new Date(k.reservado_hasta).getTime() > ahora;
|
|
var disponible = activo && !agotada && !reservada;
|
|
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 estadoHtml, timingSub;
|
|
if (!activo) {
|
|
estadoHtml = '<span class="pill inactive"><span class="dot"></span>desactivada</span>';
|
|
timingSub = '';
|
|
} else if (disponible) {
|
|
estadoHtml = '<span class="pill ok"><span class="dot"></span>disponible</span>';
|
|
timingSub = '';
|
|
} else if (reservada) {
|
|
estadoHtml = '<span class="pill info"><span class="dot"></span>reservada</span>';
|
|
timingSub = 'vence ' + fmtRelative(k.reservado_hasta);
|
|
} else {
|
|
estadoHtml = '<span class="pill warn"><span class="dot"></span>agotada</span>';
|
|
timingSub = 'libera ' + fmtRelative(k.disponible_desde) +
|
|
(k.agotada_por ? ' · por ' + esc(k.agotada_por) : '') +
|
|
(k.motivo_agotada ? ' · ' + esc(k.motivo_agotada) : '');
|
|
}
|
|
|
|
var asignadaHtml;
|
|
if (reservada && k.reservado_por) {
|
|
asignadaHtml = '<div class="owner">' + esc(k.reservado_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 +
|
|
(timingSub ? '<div class="timing-sub">' + timingSub + '</div>' : '') +
|
|
'</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 && (agotada || reservada)));
|
|
|
|
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.
|
|
function renderActividad(usos) {
|
|
var el = document.getElementById("actividad-lista");
|
|
if (!el) return;
|
|
|
|
if (!usos.length) {
|
|
el.innerHTML = '<div class="empty-state">Sin actividad registrada todavía.</div>';
|
|
return;
|
|
}
|
|
|
|
el.innerHTML = usos.slice(0, 15).map(function (u) {
|
|
var agotada = u.evento === 'agotada';
|
|
var icon = agotada ? '🔴' : '🟢';
|
|
var accion = agotada ? 'reportó agotada' : 'pidió';
|
|
return (
|
|
'<div class="activity-row">' +
|
|
'<span>' + icon + '</span>' +
|
|
'<span class="activity-text"><b>' + u.individuo + '</b> ' + accion + ' <span class="mono">' + u.provider + '/' + u.identificador + '</span></span>' +
|
|
'<span class="timing mono">' + fmtRelative(u.en) + '</span>' +
|
|
'</div>'
|
|
);
|
|
}).join('');
|
|
}
|
|
|
|
function renderBarChart(usos) {
|
|
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.toISOString().slice(0, 10));
|
|
}
|
|
var counts = {};
|
|
dias.forEach(function (d) { counts[d] = 0; });
|
|
usos.forEach(function (u) {
|
|
var d = String(u.en).slice(0, 10);
|
|
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] + ' el ' + d + '">' +
|
|
'<div class="bar" style="height:' + h + 'px"></div>' +
|
|
'<div class="bar-label">' + d.slice(5) + '</div>' +
|
|
'</div>'
|
|
);
|
|
}).join('');
|
|
}
|
|
|
|
// Reportes por individuo (P204/Fase4, pedido del Operador) — mismo /usos,
|
|
// otra lectura: no "cuándo" sino "quién reporta qué" — barra apilada
|
|
// sana+liberada (verde) vs agotada (naranja) por individuo, ordenado por
|
|
// volumen total.
|
|
function renderReportesPorIndividuo(usos) {
|
|
var el = document.getElementById("reportes-individuo");
|
|
if (!el) return;
|
|
|
|
var counts = {};
|
|
usos.forEach(function (u) {
|
|
counts[u.individuo] = counts[u.individuo] || { ok: 0, agotada: 0 };
|
|
if (u.evento === 'agotada') counts[u.individuo].agotada++;
|
|
else counts[u.individuo].ok++;
|
|
});
|
|
|
|
var individuos = Object.keys(counts).sort(function (a, b) {
|
|
var totalA = counts[a].ok + counts[a].agotada;
|
|
var totalB = counts[b].ok + counts[b].agotada;
|
|
return totalB - totalA;
|
|
});
|
|
|
|
if (!individuos.length) {
|
|
el.innerHTML = '<div class="empty-state">Sin reportes todavía.</div>';
|
|
return;
|
|
}
|
|
|
|
var max = Math.max.apply(null, individuos.map(function (i) { return counts[i].ok + counts[i].agotada; }));
|
|
|
|
el.innerHTML = individuos.map(function (ind) {
|
|
var c = counts[ind];
|
|
var total = c.ok + c.agotada;
|
|
var pctOk = max ? (c.ok / max) * 100 : 0;
|
|
var pctAgotada = max ? (c.agotada / max) * 100 : 0;
|
|
return (
|
|
'<div class="report-row">' +
|
|
'<div class="report-label mono">' + ind + '</div>' +
|
|
'<div class="report-bar">' +
|
|
'<div class="report-seg ok" style="width:' + pctOk + '%"></div>' +
|
|
'<div class="report-seg warn" style="width:' + pctAgotada + '%"></div>' +
|
|
'</div>' +
|
|
'<div class="report-count mono">' + total + '</div>' +
|
|
'</div>'
|
|
);
|
|
}).join('');
|
|
}
|
|
|
|
function cargarUsos() {
|
|
return fetch('/usos')
|
|
.then(function (r) {
|
|
if (!r.ok) throw new Error('HTTP ' + r.status);
|
|
return r.json();
|
|
})
|
|
.then(function (usos) {
|
|
renderActividad(usos);
|
|
renderBarChart(usos);
|
|
renderReportesPorIndividuo(usos);
|
|
})
|
|
.catch(function () {
|
|
// Silencioso a propósito — cargarKeys ya reporta problemas de conexión
|
|
// en el banner principal, no hace falta duplicar el aviso acá.
|
|
});
|
|
}
|
|
|
|
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');
|
|
});
|
|
}
|
|
|
|
function pillEstado(f) {
|
|
var clase = { disponible: 'ok', reservada: 'info', agotada: 'warn', inactiva: 'inactive' }[f.estado] || 'inactive';
|
|
var detalle = f.estado === 'agotada'
|
|
? (f.libera_en ? ' · libera ' + fmtRelative(f.libera_en) : '') + (f.agotada_por ? ' · por ' + esc(f.agotada_por) : '') +
|
|
(f.motivo ? ' · ' + esc(f.motivo) : '')
|
|
: (f.estado === 'reservada' && f.reservado_por ? ' · ' + esc(f.reservado_por) : '');
|
|
return '<span class="pill ' + clase + '"><span class="dot"></span>' + esc(f.estado) + '</span>' +
|
|
(detalle ? '<div class="timing-sub">' + detalle + '</div>' : '');
|
|
}
|
|
|
|
// 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); });
|
|
});
|
|
})();
|