// ════════════════════════════════════════════
// APP — Planificación Diaria Verona
// ════════════════════════════════════════════
const { useState, useEffect, useRef, useMemo } = React;
const API_URL = './api.php';
const PLAN_STORAGE_KEY = 'sp_plan_diaria_v1';
const THEME_KEY = 'sp_theme_v1';
const SCHED_KEY = 'verona_week_schedule_v1';
const VALID_THEMES = ['light', 'dark'];
const PLAN_DAY_POLL_INTERVAL_MS = 10000;
const PLAN_WEEK_POLL_INTERVAL_MS = 30000;
// Cadencia del sondeo unificado (action=sync). En vista diaria se mantiene el
// ritmo del tablero de maquinas (5 s); en semanal se revisa, no se opera.
const SYNC_POLL_DAY_MS = 5000;
const SYNC_POLL_WEEK_MS = 10000;
const SYNC_MSG_THROTTLE_MS = 10000;
// Contexto por defecto de la vista Personal (menú / recarga de /personal sin contexto previo).
const DEFAULT_PERSONAL_CTX = { dept: 'preparadores', from: 'preparadores', allowDeptSwitch: true };
const PRINT_PROFILES_KEY = 'sp_print_profiles_v1';
const PRINT_SETTINGS_KEY = 'sp_print_settings_v1';
const MACHINE_PROFILES_STORAGE_KEY = 'sp_machine_profiles_v1';
const EQUIPOS_STORAGE_KEY = 'sp_equipos_v1';
const MACHINE_STORAGE_KEY = 'sp_cp_machines_v1';
// ════════════════════════════════════════════
// Rutas URL por sección (Parte A)
// Este archivo vive únicamente en semanalprojectv1/caucho/, así que el
// path base se asume fijo en vez de detectarlo dinámicamente.
// ════════════════════════════════════════════
const APP_BASE_PATH = '/semanalprojectv1/caucho/';
// view -> segmento de URL. Cada vista tiene su PROPIO segmento (antes personal/
// preparadores y formulas/bformulas/consumo compartían uno y al recargar la URL
// se resolvía a la vista equivocada).
const VIEW_ROUTES = {
day: 'diaria',
week: 'semanal',
lista: 'lista',
matizacion: 'matizacion',
formulas: 'formulas',
bformulas: 'formulas-base',
consumo: 'consumo',
envasado: 'envasado',
control: 'control',
supervisor: 'supervisor',
personal: 'personal',
preparadores: 'preparadores',
historial: 'historial',
equipos: 'equipos',
mantenimiento: 'mantenimiento',
// 'backorden' choca con la carpeta física ./backorden/ (Apache la sirve como
// directorio, no como SPA); por eso el segmento de la SPA es 'back-orden'.
// El iframe sigue apuntando a ./backorden/.
backorden: 'back-orden',
// Ruta anidada (dos segmentos) — ver nota más abajo en viewFromLocation().
envasado_facturacion: 'envasado/facturacion',
};
// segmento -> view (inverso)
const ROUTE_VIEWS = {};
Object.keys(VIEW_ROUTES).forEach(v => {
const seg = VIEW_ROUTES[v];
if (!(seg in ROUTE_VIEWS)) ROUTE_VIEWS[seg] = v;
});
// Segmentos antiguos que siguen reconociéndose (favoritos/enlaces viejos). El efecto
// de URL los reescribe con replaceState al segmento canónico de VIEW_ROUTES.
ROUTE_VIEWS['backorden'] = 'backorden';
// Lee window.location.pathname y devuelve la view correspondiente, o null
// si no hay ruta reconocida (deja el valor por defecto 'day' sin tocar).
// Nota: soporta rutas de uno o más segmentos (p.ej. 'envasado' o
// 'envasado/facturacion'). Se compara primero el path completo restante
// contra ROUTE_VIEWS (rutas anidadas) y, si no matchea, se cae al primer
// segmento solo (rutas de un segmento, comportamiento original intacto).
function viewFromLocation() {
try {
const path = window.location.pathname || '';
const idx = path.toLowerCase().indexOf(APP_BASE_PATH.toLowerCase());
let rest = idx >= 0 ? path.slice(idx + APP_BASE_PATH.length) : '';
rest = rest.replace(/^\/+|\/+$/g, '').toLowerCase();
if (!rest) return null;
if (rest in ROUTE_VIEWS) return ROUTE_VIEWS[rest];
const firstSeg = rest.split('/')[0] || '';
return ROUTE_VIEWS[firstSeg] || null;
} catch (_) { return null; }
}
const DEFAULT_PRINT_SETTINGS = {
// Tipografía y espaciado
pageMargin: 7,
baseFontSize: 9.5,
lineHeight: 1.2,
cardSpacing: 1.8,
headPaddingV: 4,
headPaddingH: 6,
baseCodeSize: 8.5,
baseNameSize: 10,
baseMetaSize: 7.8,
colorRowPaddingV: 3,
colorRowPaddingH: 6,
colorRowFontSize: 8.2,
colorNameSize: 8,
theadFontSize: 7,
envasadoColWidth: 160,
envasadoFontSize: 7.2,
envPillFontSize: 6.8,
statusFontSize: 7,
footFontSize: 8,
// Columnas visibles
showColor: true,
showLote: false,
showCantidad: false,
showEnvasado: true,
showEstado: false,
showNotas: false,
// Campos de base
showBaseCode: true,
showPlanta: true,
// Extras
showLogo: true,
showBaseTotal: false,
showDayTotal: false,
};
function buildPrintCSS(s) {
// Columnas de la tabla de colores (8 en total)
// Orden: checks | color | lote | gl-plan | gl-real | envasado | estado | acciones
const COLS = [
{ nth: 1, w: '0', show: false }, // checks — siempre oculto
{ nth: 2, w: '1fr', show: s.showColor !== false },
{ nth: 3, w: '80px', show: !!s.showLote },
{ nth: 4, w: '65px', show: !!s.showCantidad },
{ nth: 5, w: '65px', show: !!s.showCantidad },
{ nth: 6, w: `${s.envasadoColWidth}px`, show: !!s.showEnvasado },
{ nth: 7, w: '65px', show: !!s.showEstado },
{ nth: 8, w: '0', show: false }, // acciones — siempre oculto
];
const visibleCols = COLS.filter(c => c.show);
const hiddenNths = COLS.filter(c => !c.show).map(c => c.nth);
const gridCols = visibleCols.map(c => c.w).join(' ') || '1fr';
const hideSel = hiddenNths
.map(n => `.colors-thead > :nth-child(${n}),.color-row > :nth-child(${n})`)
.join(',\n ');
return `@media print {
@page { size: letter portrait; margin: ${s.pageMargin}mm ${s.pageMargin}mm; }
body { font-size: ${s.baseFontSize}pt !important; line-height: ${s.lineHeight} !important; }
.base-card { margin-bottom: ${s.cardSpacing}mm !important; }
.base-head { padding: ${s.headPaddingV}pt ${s.headPaddingH}pt !important; }
body.print-mode .base-head { padding: ${Math.max(s.headPaddingV - 1, 1)}pt ${s.headPaddingH}pt !important; }
.base-code { font-size: ${s.baseCodeSize}pt !important; ${s.showBaseCode ? '' : 'display:none !important;'} }
.base-name { font-size: ${s.baseNameSize}pt !important; }
.base-meta { font-size: ${s.baseMetaSize}pt !important; }
.base-linea { ${s.showPlanta ? '' : 'display:none !important;'} }
/* Restaurar visibilidad base antes de aplicar toggles (anula el CSS base del archivo) */
.colors-thead > *, .color-row > * { display:revert !important; }
.colors-thead, .color-row { grid-template-columns: ${gridCols} !important; grid-template-areas:none !important; }
/* Ocultar columnas desactivadas */
${hideSel} { display:none !important; }
.colors-thead { padding: ${s.colorRowPaddingV}pt ${s.colorRowPaddingH}pt !important; font-size: ${s.theadFontSize}pt !important; }
.color-row { padding: ${s.colorRowPaddingV}pt ${s.colorRowPaddingH}pt !important; font-size: ${s.colorRowFontSize}pt !important; }
body.print-mode .color-row { padding: ${Math.max(s.colorRowPaddingV - 1, 1)}pt ${s.colorRowPaddingH}pt !important; font-size: ${s.colorRowFontSize}pt !important; }
body.print-mode .colors-thead { padding: ${Math.max(s.colorRowPaddingV - 1, 1)}pt ${s.colorRowPaddingH}pt !important; }
.color-name-text { font-size: ${s.colorNameSize}pt !important; color:#000 !important; font-weight:600 !important; }
.color-print-notas { display: ${s.showNotas ? 'block' : 'none'} !important; }
.envasado { font-size: ${s.envasadoFontSize}pt !important; }
.env-pill { font-size: ${s.envPillFontSize}pt !important; }
.color-status { font-size: ${s.statusFontSize}pt !important; }
.print-foot { font-size: ${s.footFontSize}pt !important; }
.print-logo-bar { display: ${s.showLogo ? 'flex' : 'none'} !important; }
.print-base-total { display: ${s.showBaseTotal ? 'flex' : 'none'} !important; }
.print-day-total { display: ${s.showDayTotal ? 'block' : 'none'} !important; }
}`;
}
// ════════════════════════════════════════════
// Reporte imprimible de la Planificación Diaria
// Mismo estilo de membrete + tablas que el Reporte de Producción
// (Historial / Control de Proceso). Se abre en ventana nueva.
// ════════════════════════════════════════════
function buildDailyPlanReport(bases, date, emphasized, includeColors = true) {
const emphSet = emphasized instanceof Set ? emphasized : new Set(emphasized || []);
const withColors = includeColors !== false;
// URL absoluta del logo (la ventana de impresión es about:blank).
let logoUrl = 'logo-verona.png';
try { logoUrl = new URL('logo-verona.png', document.baseURI).href; } catch (_) {}
const [y, m, d] = (date || '').split('-');
const months = ['Enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto','Septiembre','Octubre','Noviembre','Diciembre'];
const dateStr = (y && m && d) ? `${d} de ${months[parseInt(m,10)-1]} de ${y}` : (date || '');
const now = new Date();
const nowStr = `${now.getDate().toString().padStart(2,'0')}/${(now.getMonth()+1).toString().padStart(2,'0')}/${now.getFullYear()} ${now.getHours().toString().padStart(2,'0')}:${now.getMinutes().toString().padStart(2,'0')}`;
const list = (bases || []);
const fmtGL = v => (v == null ? 0 : (v % 1 === 0 ? v : v.toFixed(1)));
// Escapa también comillas: varios valores van dentro de atributos (src, style, title).
const esc = s => String(s == null ? '' : s).replace(/[&<>"']/g, c => ({ '&':'&', '<':'<', '>':'>', '"':'"', "'":''' }[c]));
// Envasado (plan) como texto agrupado por marca
const ENV_LABEL = { cu4:'CU·4', cu5:'CU·5', cu7:'CU·7', gl:'GL', ku:'CUÑ', pl:'1L', pm:'0.5L' };
const fmtEnv = (arr) => {
const byBrand = {};
(arr || []).forEach(e => {
const b = e.marca || 'SIN MARCA';
if (!byBrand[b]) byBrand[b] = {};
byBrand[b][e.tipo] = (byBrand[b][e.tipo] || 0) + (e.cantidad || 0);
});
const rows = Object.entries(byBrand).map(([brand, tot]) => {
const pills = ['cu4','cu5','cu7','gl','ku','pl','pm'].filter(t => tot[t] > 0).map(t => `${tot[t]} ${ENV_LABEL[t]}`).join(', ');
return pills ? `${esc(brand)} ${pills}` : '';
}).filter(Boolean);
return rows.length ? rows.join(' ') : '— ';
};
// Totales generales
const allColors = list.reduce((s, b) => s + (b.colors ? b.colors.length : 0), 0);
const totPlan = list.reduce((s, b) => s + (b.colors || []).reduce((a, c) => a + (c.cantidad || 0), 0), 0);
const totReal = list.reduce((s, b) => s + (b.colors || []).reduce((a, c) => a + (c.glReal || 0), 0), 0);
const th = (txt, right) => `
${txt} `;
const card = (num, label) =>
``;
const section = (base) => {
const colors = base.colors || [];
const unit = esc(base.unit || 'GL');
const cancelled = base.status === 'cancelled';
// Base marcada manualmente para imprimir con la letra oscurecida / resaltada.
const emph = emphSet.has(base.id);
const nameColor = emph ? '#000' : '#1a1a1a'; // texto de color más oscuro
const loteColor = emph ? '#111' : '#555'; // lote menos apagado
const nameWeight = emph ? 800 : 700;
const bPlan = colors.reduce((a, c) => a + (c.cantidad || 0), 0);
const bReal = colors.reduce((a, c) => a + (c.glReal || 0), 0);
const meta = [
base.tipo ? esc(base.tipo) : '',
base.lote ? `Lote ${esc(base.lote)}` : '',
base.linea ? esc(base.linea) : '',
`${colors.length} color${colors.length !== 1 ? 'es' : ''}`,
].filter(Boolean).join(' · ');
const rows = colors.length ? colors.map((c, idx) => {
const isCanc = !!c.cancelled;
const nameExtra = c.tipoColor === 'con_matizacion' ? ' C/Mat ' : '';
const cancTag = isCanc ? ' ✕ CANCELADO ' : '';
return `
${esc(c.nombre) || '—'} ${nameExtra}${cancTag}
${esc(c.lote) || '—'}
${c.cantidad > 0 ? fmtGL(c.cantidad) : '—'}
${c.glReal > 0 ? fmtGL(c.glReal) : '—'}
${fmtEnv(c.envasado)}
`;
}).join('') : `Sin colores en esta base. `;
return `
${esc(base.code)} ${esc(base.nombre)}${cancelled ? ' — CANCELADA' : ''}
${meta}
${withColors ? `
${th('Color')}${th('Lote')}${th('GL Plan', true)}${th('GL Real', true)}${th('Envasado')}
${rows}
Total base
${bPlan > 0 ? fmtGL(bPlan) : '—'} ${unit}
${bReal > 0 ? fmtGL(bReal) : '—'} ${unit}
` : `
Galonaje base
Plan: ${bPlan > 0 ? fmtGL(bPlan) : '—'} ${unit}
Real: ${bReal > 0 ? fmtGL(bReal) : '—'} ${unit}
`}
`;
};
return `
Planificación Diaria ${esc(date)}
PLANIFICACIÓN DIARIA DE PRODUCCIÓN — ${dateStr}
Dirigido al: Departamento de Producción
Generado: ${nowStr}
Fecha: ${esc(date)}
Control de Proceso:
Control Gerente de Planta:
${card(list.length, 'Bases planificadas')}
${card(allColors, 'Colores')}
${card(fmtGL(totPlan), 'GL Planificados')}
${card(fmtGL(totReal), 'GL Reales')}
${list.length
? list.map(section).join('')
: 'No hay bases planificadas para esta fecha.
'}
Firma Control de Proceso:
Nombre y sello
Firma Gerente de Planta:
Nombre y sello
Sistema de Planificación — VERONA COLOR PAINTS — ${esc(date)}
`;
}
// Fetch wrapper that always includes session credentials
// Acciones destructivas: el servidor exige `delete_key` en el cuerpo JSON.
// La clave la deja window.verifyDeleteKey() en window.__spDeleteKey; solo se
// adjunta a estas acciones (no a un autoguardado cualquiera que corra en medio).
const DELETE_KEY_ACTIONS = new Set([
'plan_batch_delete', 'cp_machine_delete', 'fact_factura_delete', 'fact_inventario_delete',
'fact_catalogo_delete', 'fact_catalogo_delete_bulk', 'fact_clases_delete', 'prep_delete',
'equipo_delete', 'db_clear_all', 'plan_db_delete',
]);
let _deleteKeyTimer = null;
function clearDeleteKeySoon(delay, tok) {
clearTimeout(_deleteKeyTimer);
// Se limpia tras la respuesta, con un pequeño margen: un autoguardado que borra varias
// bases en secuencia (await tras await) reutiliza la misma clave tecleada una vez.
// `tok` evita borrar una clave más nueva (verifyDeleteKey incrementa __spDeleteKeyTok).
_deleteKeyTimer = setTimeout(() => {
if (window.__spDeleteKeyTok === tok) window.__spDeleteKey = undefined;
}, delay);
}
// Prepara una petición a api.php: CSRF (X-Requested-With) + JSON en todo POST y
// delete_key en las acciones destructivas. Se aplica en fetch global (ver shim) para
// que también lo reciban los módulos que llaman fetch directamente (preparadores,
// control de proceso, facturación...), no solo apiFetch/callApi.
function spPrepareRequest(url, opts) {
const o = { ...(opts || {}) };
const method = String(o.method || 'GET').toUpperCase();
let usedDeleteKey = false;
if (method !== 'GET' && method !== 'HEAD') {
const h = { ...(o.headers || {}) };
const hasCT = Object.keys(h).some(k => k.toLowerCase() === 'content-type');
if (!hasCT && !(typeof FormData !== 'undefined' && o.body instanceof FormData)) h['Content-Type'] = 'application/json';
h['X-Requested-With'] = 'sp';
o.headers = h;
if (window.__spDeleteKey && typeof o.body === 'string') {
try {
const b = JSON.parse(o.body);
if (b && typeof b === 'object' && DELETE_KEY_ACTIONS.has(b.action) && !b.delete_key) {
b.delete_key = window.__spDeleteKey;
o.body = JSON.stringify(b);
usedDeleteKey = true;
}
} catch (_) {}
}
}
return { o, usedDeleteKey };
}
(function installApiFetchShim() {
if (window.__spFetchShim || typeof window.fetch !== 'function') return;
window.__spFetchShim = true;
const origFetch = window.fetch.bind(window);
window.fetch = function (url, opts) {
const u = typeof url === 'string' ? url : (url && url.url) || '';
if (!/(^|\/)api\.php(\?|$)/.test(u)) return origFetch(url, opts);
const { o, usedDeleteKey } = spPrepareRequest(u, opts);
const p = origFetch(url, o);
if (usedDeleteKey) { const tok = window.__spDeleteKeyTok; const done = () => clearDeleteKeySoon(15000, tok); p.then(done, done); }
return p;
};
})();
function apiFetch(url, opts = {}) {
// 'no-store' evita que un proxy/CDN intermedio (o el propio navegador)
// devuelva una respuesta cacheada de plan_batch_list/plan_batch_check ante
// una URL repetida (misma fecha), lo que se vería como si el plan
// "revirtiera" a un valor previo. El backend ya envía Cache-Control:
// no-store, pero esto lo refuerza también del lado del cliente.
// (La cabecera CSRF y delete_key los añade el shim de fetch de arriba.)
return fetch(url, { credentials: 'include', cache: 'no-store', ...opts });
}
window.spFetch = apiFetch;
class ApiError extends Error {
constructor(message, { status = 0, data = null } = {}) {
super(message);
this.name = 'ApiError';
this.status = status;
this.data = data;
}
}
async function readApiJson(response) {
const text = await response.text();
let data = null;
if (text) {
try {
data = JSON.parse(text);
} catch (_) {
throw new ApiError('Respuesta inválida del servidor', { status: response.status });
}
}
if (!response.ok) {
throw new ApiError(data?.error || `Error HTTP ${response.status}`, { status: response.status, data });
}
if (data && data.ok === false) {
throw new ApiError(data.error || 'La API rechazó la operación', { status: response.status, data });
}
return data || {};
}
// Reconstruye AppData (BASES_UNICAS, CATALOGO, COLOR_BASES) desde el snapshot estático
// más las entradas personalizadas del catálogo guardado en la nube.
function rebuildAppData(entries) {
if (!window._STATIC_APPDATA) return;
const s = window._STATIC_APPDATA;
const savedEntries = Array.isArray(entries) ? entries : [];
const sourceEntries = savedEntries.length > 0 ? savedEntries : null;
AppData.BASES_UNICAS = sourceEntries ? [] : [...s.BASES_UNICAS];
AppData.CATALOGO = sourceEntries ? [] : [...s.CATALOGO];
AppData.COLOR_BASES = sourceEntries ? [] : [...s.COLOR_BASES];
(sourceEntries || []).forEach(entry => {
const base = String(entry.nombre || '').trim().toUpperCase();
if (!base) return;
const tipo = entry.tipo || (window.location.pathname.toLowerCase().includes('/esmalte') ? 'ESMALTE' : 'CAUCHO');
if (!AppData.BASES_UNICAS.includes(base)) AppData.BASES_UNICAS.push(base);
(entry.colores || []).map(c => String(c || '').trim().toUpperCase()).filter(Boolean).forEach(color => {
if (!AppData.COLOR_BASES.includes(color)) AppData.COLOR_BASES.push(color);
if (!AppData.CATALOGO.some(c => c.base === base && c.producto === color)) {
AppData.CATALOGO.push({ tipo, base, producto: color, codigos: entry.codigos || '' });
}
});
});
}
// Aplica la configuración editable (guardada en la nube) sobre AppData.
// data.jsx queda como valores por defecto; esto los sobrescribe si hay guardado.
function applyAppConfig(cfg) {
if (!cfg || typeof cfg !== 'object' || !window.AppData) return;
if (Array.isArray(cfg.marcas) && cfg.marcas.length) window.AppData.MARCAS = cfg.marcas.slice();
if (Array.isArray(cfg.lineas)) window.AppData.LINEAS = cfg.lineas.map(l => ({ ...l }));
if (Array.isArray(cfg.phaseStatuses)) window.AppData.PHASE_STATUSES = cfg.phaseStatuses.map(p => ({ ...p }));
if (cfg.machineTypes && typeof cfg.machineTypes === 'object') {
const mt = window.AppData.MACHINE_TYPES || {};
const merged = {};
Object.keys(mt).forEach(k => {
merged[k] = { ...mt[k] }; // conserva icon/accepts del código
const o = cfg.machineTypes[k];
if (o) {
if (typeof o.name === 'string' && o.name.trim()) merged[k].name = o.name;
if (Array.isArray(o.defaultPhases)) merged[k].defaultPhases = o.defaultPhases.slice();
}
});
window.AppData.MACHINE_TYPES = merged;
}
if (Array.isArray(cfg.produccionOverrides))
window.AppData.PRODUCCION_OVERRIDES = cfg.produccionOverrides
.map(s => String(s || '').trim()).filter(Boolean);
}
// Tick de 1 s para los temporizadores de fases (Control, Matización, Envasado, Supervisor).
// Vive en este wrapper para que el segundo a segundo re-renderice SOLO la vista que
// lo necesita y no toda la App (antes un setInterval en App re-renderizaba todo cada 1 s).
function useSecondTick() {
const [tick, setTick] = useState(0);
useEffect(() => {
const id = setInterval(() => setTick(t => t + 1), 1000);
return () => clearInterval(id);
}, []);
return tick;
}
function WithTick({ as: View, ...props }) {
const tick = useSecondTick();
return ;
}
function App({ currentUser, onLogout }) {
const [theme, setTheme] = useState(() => {
try {
const saved = localStorage.getItem(THEME_KEY);
return VALID_THEMES.includes(saved) ? saved : 'light';
} catch { return 'light'; }
});
useEffect(() => {
document.documentElement.setAttribute('data-theme', theme === 'light' ? '' : theme);
try { localStorage.setItem(THEME_KEY, theme); } catch {}
}, [theme]);
// `viewState` es la vista pedida (URL/menú); `view` (más abajo, tras calcular los
// permisos) es la vista EFECTIVA: si no hay permiso para la pedida, cae a la primera permitida.
const [viewState, setView] = useState(() => viewFromLocation() || 'day');
const [navOpen, setNavOpen] = useState(false); // panel de navegación deslizante (drawer)
const isMobile = window.useIsMobile ? window.useIsMobile() : false;
// Marca la raíz para que styles/mobile.css (gated por body.mobile-view) se
// active/desactive sin tocar el layout de escritorio.
useEffect(() => {
document.body.classList.toggle('mobile-view', !!isMobile);
return () => document.body.classList.remove('mobile-view');
}, [isMobile]);
const [date, setDate] = useState(todayStr());
// "Hoy" según el reloj calibrado con el servidor. Si el usuario estaba parado en "hoy" y el
// día cambia (calibración tardía del reloj o medianoche con la pantalla abierta), la fecha
// activa avanza sola; si estaba mirando otro día, no se toca.
const lastTodayRef = useRef(todayStr());
const rolloverRef = useRef(null);
rolloverRef.current = () => {
const t = todayStr();
const prev = lastTodayRef.current;
if (t === prev) return;
lastTodayRef.current = t;
setDate(d => (d === prev ? t : d));
};
useEffect(() => {
const id = setInterval(() => rolloverRef.current && rolloverRef.current(), 60000);
return () => clearInterval(id);
}, []);
const [plan, setPlan] = useState(() => {
try {
const raw = localStorage.getItem(PLAN_STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (_) {}
return JSON.parse(JSON.stringify(AppData.SEED_PLAN));
});
const [expanded, setExpanded] = useState(() => new Set());
const [filter, setFilter] = useState({ tipo: 'all', status: 'all', origen: 'all' });
const [search, setSearch] = useState('');
const [toast, setToast] = useState(null);
const [baseModal, setBaseModal] = useState(null);
const [colorModalCtx, setColorModalCtx] = useState(null);
const [historialFrom, setHistorialFrom] = useState('control'); // vista desde la que se abrió el historial
const [syncMsg, setSyncMsg] = useState('');
const [syncStatus, setSyncStatus] = useState('idle'); // 'idle'|'saving'|'saved'|'error'|'offline'|'session'
const [isOnline, setIsOnline] = useState(typeof navigator !== 'undefined' ? navigator.onLine : true);
const [backendStatus, setBackendStatus] = useState('checking'); // 'checking'|'online'|'offline'|'session-expired'
const [backendMsg, setBackendMsg] = useState('Verificando conexión con el servidor…');
const [cloudReady, setCloudReady] = useState(false);
const [planReloadTick, setPlanReloadTick] = useState(0); // fuerza recargar el día activo desde el servidor
const [cpMachines, setCpMachines] = useState([]);
const cpMachinesRef = useRef([]); // última lista local (la lee el sondeo sin depender del cierre)
cpMachinesRef.current = cpMachines;
// Bases en máquina (asignadas ahora) y finalizadas (en el historial de lotes):
// se calculan de las máquinas, no de un evento puntual que puede perderse.
const machineBaseIds = useMemo(() => {
const inMachine = new Set(), finished = new Set();
(cpMachines || []).forEach(m => {
(m.assignments || []).forEach(a => { if (a.kind === 'base') inMachine.add(a.id); });
(m.history || []).filter(h => !h.failed).forEach(h => (h.assignments || []).forEach(a => { if (a.kind === 'base') finished.add(a.id); }));
});
return { inMachine, finished };
}, [cpMachines]);
const [cpCloudReady, setCpCloudReady] = useState(false);
const [pendingModal, setPendingModal] = useState(null);
const [showEnvasadoSummary, setShowEnvasadoSummary] = useState(false);
const [envasadoDay, setEnvasadoDay] = useState(null); // Lista: resumen de envasado de un día
const [listPrintDay, setListPrintDay] = useState(null); // Lista: día a imprimir
const [showPrintSettings, setShowPrintSettings] = useState(false);
const [printSelectModal, setPrintSelectModal] = useState(false);
const [printSettings, setPrintSettings] = useState(() => {
try {
const raw = localStorage.getItem(PRINT_SETTINGS_KEY);
if (raw) return { ...DEFAULT_PRINT_SETTINGS, ...JSON.parse(raw) };
} catch (_) {}
return { ...DEFAULT_PRINT_SETTINGS };
});
const [printProfiles, setPrintProfiles] = useState(() => {
try {
const raw = localStorage.getItem(PRINT_PROFILES_KEY);
if (raw) return JSON.parse(raw);
} catch (_) {}
return [];
});
const [schedules, setSchedules] = useState(() => {
try { return JSON.parse(localStorage.getItem(SCHED_KEY)) || {}; } catch (_) { return {}; }
});
const [customCatalog, setCustomCatalog] = useState([]);
const [showCatalog, setShowCatalog] = useState(false);
const [showConfig, setShowConfig] = useState(false);
const [appCfg, setAppCfg] = useState(null);
const [showUsers, setShowUsers] = useState(false);
const [showClearDb, setShowClearDb] = useState(false);
const [personalCtx, setPersonalCtx] = useState(null); // { dept, from, allowDeptSwitch } | null (null => DEFAULT_PERSONAL_CTX)
const [formulas, setFormulas] = useState([]); // fórmulas de matización (historial/evolución)
const [baseFormulas, setBaseFormulas] = useState([]); // fórmulas de BASE (separadas de color; usadas en Consumo MP)
const [baseFormulasCtx, setBaseFormulasCtx] = useState(null); // { producto, from } | null — abrir la fórmula de una base concreta
const [formulasCtx, setFormulasCtx] = useState(null); // { from, producto, colorId, base, lote, gl, unit } | null
const openFormulas = (ctx) => { setFormulasCtx(ctx || { from: 'matizacion' }); setView('formulas'); };
const [operators, setOperators] = useState({}); // { dept: { groups:[], people:[] } } para el campo Operador
const openPersonal = (dept, from, allowDeptSwitch = false) => {
setPersonalCtx({ dept, from, allowDeptSwitch });
setView('personal');
};
const [lang, setLang] = useState(window.SP_LANG || 'es');
const [machineProfiles, setMachineProfiles] = useState(() => {
try {
const raw = localStorage.getItem(MACHINE_PROFILES_STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (_) {}
return {};
});
const [equipos, setEquipos] = useState(() => {
try {
const raw = localStorage.getItem(EQUIPOS_STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (_) {}
return [];
});
const equiposRef = useRef(equipos);
equiposRef.current = equipos;
const handleEquiposChange = (next) => {
// Efectos secundarios FUERA del actualizador de setEquipos (se duplicarían si React
// invoca el actualizador dos veces). `prev` sale del ref con el último valor conocido.
const prev = equiposRef.current || [];
// Eliminar equipos es destructivo (equipo_delete exige delete_key en el servidor). Algunas
// pantallas ya piden la clave antes (Equipos); si no hay una vigente (p. ej. Mantenimiento),
// se pide aquí y, si se cancela, no se elimina nada.
const nextIdSet = new Set(next.map(e => e.id));
const removedCount = prev.filter(e => !nextIdSet.has(e.id)).length;
if (removedCount > 0 && !window.__spDeleteKey
&& !window.verifyDeleteKey(`¿Eliminar ${removedCount} equipo${removedCount !== 1 ? 's' : ''}?`)) return;
equiposRef.current = next;
setEquipos(next);
try { localStorage.setItem(EQUIPOS_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
// Sincronizar con la nube: guardar ítems nuevos/modificados, eliminar los que ya no están
const prevById = new Map(prev.map(e => [e.id, e]));
const nextIds = new Set(next.map(e => e.id));
next.forEach(e => {
const before = prevById.get(e.id);
if (!before || JSON.stringify(before) !== JSON.stringify(e)) {
const { id, ...data } = e;
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'equipo_save', equipo_id: id, data }),
}, 'guardar equipo').catch(err => notifyApiError('guardar el equipo', err));
}
});
prev.forEach(e => {
if (!nextIds.has(e.id)) {
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'equipo_delete', equipo_id: e.id }),
}, 'eliminar equipo').catch(err => notifyApiError('eliminar el equipo', err));
}
});
};
// Refs para guardado granular y polling (no disparan re-renders)
// { [date]: { [batchId]: JSON_string } } — qué hay guardado en el servidor
const savedBatchData = useRef({});
// { [date]: { [batchId]: updated_at } } — timestamps para polling
const batchTimestamps = useRef({});
const savedMachineData = useRef({});
const machineTimestamps = useRef({});
// { [date]: Set(batchId) } — evita que el auto-guardado duplique borrados explícitos.
const pendingBatchDeletes = useRef({});
const planPollInFlight = useRef(false);
const unifiedSyncActive = useRef(false); // el sondeo unificado hace de heartbeat
const cpInitialLoadDone = useRef(false); // la carga inicial de máquinas ya terminó
const machinePollInFlight = useRef(false);
const machinesSaveInFlight = useRef(new Set());
const pendingMachineDeletes = useRef(new Set());
const deletedMachineIds = useRef(new Set());
const lastSyncMsgAt = useRef(0);
const lastErrToastRef = useRef({ key: '', at: 0 }); // evita repetir el mismo toast de error
// Refs that always point to the latest state (used inside effects/timers without re-running them)
const planRef = useRef(plan);
useEffect(() => { planRef.current = plan; }, [plan]);
const perms = currentUser?.permissions || {};
const isAdmin = currentUser?.role === 'admin';
const canEdit = isAdmin || !!(perms.edit_planning);
const canDelete = isAdmin || !!(perms.delete_planning);
const canExport = isAdmin || !!(perms.export);
const canDuplicate = isAdmin || !!(perms.duplicate);
const canChangeDates = isAdmin || !!(perms.change_dates);
const accessEnvasadoOnly = !isAdmin && !!(perms.access_envasado_only);
const canEditGalonaje = isAdmin || !!(perms.edit_galonaje_real);
const canEditEnvasado = isAdmin || !!(perms.edit_envasado_select);
// Permiso acotado: ve SOLO la pestaña Diaria y lo único que puede hacer
// ahí es marcar el empaquetado como listo. No edita la planificación.
const soloDiariaEmpaque = !isAdmin && !!(perms.access_diaria_empaque);
// Corregir registros ya guardados del historial (además del administrador).
const canFixHistorial = isAdmin || !!(perms.fix_historial);
const canCheckEnvasado = isAdmin || !!(perms.check_envasado) || soloDiariaEmpaque;
const canEditHistorial = isAdmin || !!(perms.edit_historial);
const canCheckMatizacion = isAdmin || !!(perms.check_matizacion);
const canEditFormula = (isAdmin || !!(perms.check_matizacion) || !!(perms.edit_planning)) && (isOnline && backendStatus === 'online');
const canEditBaseFormula = (isAdmin || !!(perms.check_matizacion) || !!(perms.edit_planning) || !!(perms.access_consumo)) && (isOnline && backendStatus === 'online');
const canAccessEnvasadoTab = isAdmin || !!(perms.access_envasado_tab) || !!(perms.check_envasado) || !!(perms.access_envasado_only);
// Control de Proceso: el servidor acepta plan_batch_save de edit_control_proceso en
// modo "solo marcar" (avances) y cp_machine_save para edit_control_proceso.
const canEditCP = isAdmin || canEdit || !!(perms.edit_control_proceso);
const hasFullAccess = isAdmin || canEdit;
const canAccessMantenimiento = isAdmin || !!(perms.access_mantenimiento_tab);
// Mantenimiento también ve y administra los Equipos.
const canAccessEquipos = isAdmin || !!(perms.access_equipos_tab) || canAccessMantenimiento;
const canAccessBackorden = isAdmin || !!(perms.access_backorden_tab);
const canAccessPreparadores = isAdmin || !!(perms.access_preparadores_tab);
const canAccessConsumo = isAdmin || !!(perms.access_consumo);
const canAccessFacturacion = isAdmin || !!(perms.access_facturacion_tab);
// Nivel de acceso a la gestión de personal/puntos: 'full' | 'basic' | 'none'.
// full → personas, grupos, puntos, máquinas, tareas extras e historial.
// basic → solo agregar personas y moverlas de grupo.
const personalAccess = () => {
if (isAdmin || perms.edit_planning || perms.personal_full) return 'full';
if (perms.personal_basic) return 'basic';
return 'none';
};
const hasPersonalAccess = personalAccess() !== 'none';
const hasValidBackend = isOnline && backendStatus === 'online';
const canEditSafe = canEdit && hasValidBackend;
// Quién puede PERSISTIR cambios del plan. Debe cubrir a los permisos que
// marcan avances (empaquetado, matización, galonaje real): antes solo se
// guardaba con "Editar planificación", así que esas marcas se perdían.
// canEditCP se agrega por el mismo motivo: marcar el envasado desde la
// Empaquetadora (Control de Proceso) escribe sobre el mismo color del
// plan. El servidor acepta plan_batch_save de edit_control_proceso en modo
// solo-marcar (no estructura del plan), igual que para los demás permisos de avance.
const canPersistPlan = canEdit || canCheckEnvasado || canEditGalonaje
|| canEditEnvasado || canCheckMatizacion || canEditCP;
// Quién puede PERSISTIR máquinas (cp_machine_save): Control de Proceso y, desde la
// pantalla Historial, las correcciones/ediciones del historial (edit_historial /
// fix_historial), que escriben sobre las mismas máquinas.
const canPersistMachines = canEditCP || canEditHistorial || canFixHistorial;
const canDeleteSafe = canDelete && hasValidBackend;
const canDuplicateSafe = canDuplicate && hasValidBackend;
const isAdminSafe = isAdmin && hasValidBackend;
// ─ Permisos por vista (mismos criterios que el menú de navegación) ─
// Se aplican a TODAS las vistas, también cuando se llega por URL directa o por popstate.
const viewAllowedFor = (v) => {
switch (v) {
case 'day': return hasFullAccess || soloDiariaEmpaque;
case 'week':
case 'lista':
case 'supervisor': return hasFullAccess;
// Historial se abre desde Control/Matización/Envasado con sus propios permisos
// (y corregir/eliminar registros exige edit_historial/fix_historial).
case 'historial': return hasFullAccess || canEditCP || canCheckMatizacion || canAccessEnvasadoTab
|| canEditHistorial || canFixHistorial;
case 'control': return hasFullAccess || canEditCP;
case 'matizacion': return isAdmin || canCheckMatizacion;
case 'formulas': return hasFullAccess || canCheckMatizacion;
case 'consumo':
case 'bformulas': return canAccessConsumo;
case 'envasado': return isAdmin || canAccessEnvasadoTab;
case 'envasado_facturacion': return canAccessFacturacion;
case 'personal': return hasPersonalAccess;
case 'preparadores': return canAccessPreparadores;
case 'equipos': return hasFullAccess || canAccessEquipos;
case 'mantenimiento': return canAccessMantenimiento;
case 'backorden': return canAccessBackorden;
default: return false;
}
};
// Orden de preferencia para redirigir (coincide con el antiguo redireccionador de
// operadores restringidos: diaria-empaque, matización, envasado, control, ...).
const VIEW_FALLBACK_ORDER = ['day', 'matizacion', 'envasado', 'control', 'mantenimiento', 'equipos',
'backorden', 'preparadores', 'personal', 'week', 'lista', 'supervisor', 'formulas', 'consumo', 'historial'];
const view = (!currentUser || viewAllowedFor(viewState))
? viewState
: (VIEW_FALLBACK_ORDER.find(viewAllowedFor) || 'noaccess');
// Fecha sobre la que operan las acciones de edición. En Diaria es la fecha activa;
// en la vista Lista (varios días a la vez) la fija cada tarjeta con actOn(fecha, fn).
const opDateRef = useRef(null);
const od = () => (view === 'lista' && opDateRef.current) || date;
const actOn = (d, fn) => { opDateRef.current = d; return fn(); };
// Vista a la que vuelven Consumo / Fórmulas de base ('day' o 'lista').
const [backTo, setBackTo] = useState('day');
useEffect(() => { if (view === 'day' || view === 'lista') setBackTo(view); }, [view]);
// Fecha que muestra Control de Proceso (la cambia con sus flechas; ver onCpDateChange).
const cpDateRef = useRef(null);
useEffect(() => { if (view === 'control') cpDateRef.current = date; }, [view]);
// Menú de navegación: "Personal" necesita contexto (departamento); si el menú lo abre
// sin contexto, se usa uno por defecto en vez de dejar la pantalla en blanco.
const onNavView = (v) => {
if (v === 'personal') setPersonalCtx(ctx => ctx || DEFAULT_PERSONAL_CTX);
setView(v);
};
// ─ Reflejar la view activa en la URL (Parte A: rutas por sección) ─
// Nota: esta redirección se dispara DESPUÉS del efecto de permisos de arriba
// (declarado antes en el cuerpo del componente), así que si la URL pedía una
// vista sin acceso, la restricción de permisos ya habrá corregido `view`
// antes de que este efecto la escriba de vuelta en la URL.
const isFirstUrlSync = useRef(true);
useEffect(() => {
const seg = VIEW_ROUTES[view];
if (!seg) return;
const target = APP_BASE_PATH + seg;
const here = (window.location.pathname || '').replace(/\/+$/, '');
if (here !== target) {
const url = target + window.location.search + window.location.hash;
// replaceState: carga inicial, redirección por falta de permiso (view != viewState) y
// segmentos antiguos (p. ej. /backorden -> /back-orden); en cambios normales de vista, pushState.
if (isFirstUrlSync.current || viewState !== view || viewFromLocation() === view) window.history.replaceState({ view }, '', url);
else window.history.pushState({ view }, '', url);
}
isFirstUrlSync.current = false;
}, [view]);
// ─ Botón atrás/adelante del navegador ─
useEffect(() => {
const onPopState = () => {
const v = viewFromLocation();
if (v) setView(v);
};
window.addEventListener('popstate', onPopState);
return () => window.removeEventListener('popstate', onPopState);
}, []);
const handleSaveMachineProfile = async (machineCode, profile) => {
if (!isAdmin || !machineCode) return;
setMachineProfiles(prev => {
const next = { ...prev, [machineCode]: profile };
try { localStorage.setItem(MACHINE_PROFILES_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'machine_profile_save', machine_code: machineCode, profile }),
}, 'guardar perfil de máquina');
} catch (err) { notifyApiError('guardar el perfil de la máquina', err); }
};
// Cualquier usuario autenticado (supervisor de departamento) puede reportar
// una falla de máquina desde la pestaña Equipos, sin necesitar permisos de admin.
const handleReportMachineFalla = async (machineCode, descripcion, gravedad) => {
if (!currentUser || !machineCode || !descripcion) return;
const falla = {
id: 'f' + Date.now() + Math.random().toString(36).slice(2, 5),
descripcion, gravedad,
fechaReporte: cpCaracasDateStr(), reportadoPor: currentUser.name || currentUser.email || 'Usuario',
resuelta: false, fechaResolucion: null, solucion: '',
};
setMachineProfiles(prev => {
const prevProfile = prev[machineCode] || {};
const next = { ...prev, [machineCode]: { ...prevProfile, fallas: [...(prevProfile.fallas || []), falla] } };
try { localStorage.setItem(MACHINE_PROFILES_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'machine_report_falla', machine_code: machineCode, falla }),
}, 'reportar falla de máquina');
} catch (err) { notifyApiError('reportar la falla', err); }
};
// Mantenimiento/admin: cierra una falla de máquina (guarda quién la reparó y la solución).
const handleResolveMachineFalla = async (machineCode, fallaId, data) => {
if (!canAccessMantenimiento || !machineCode || !fallaId) return;
setMachineProfiles(prev => {
const prevProfile = prev[machineCode] || {};
const fallas = (prevProfile.fallas || []).map(f => f.id === fallaId
? { ...f, resuelta: true, fechaResolucion: data.fecha, solucion: data.solucion, reparadoPor: data.reparadoPor } : f);
const next = { ...prev, [machineCode]: { ...prevProfile, fallas } };
try { localStorage.setItem(MACHINE_PROFILES_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'machine_resolve_falla', machine_code: machineCode, falla_id: fallaId,
fecha: data.fecha, solucion: data.solucion, reparado_por: data.reparadoPor }),
}, 'resolver falla de máquina');
} catch (err) { notifyApiError('resolver la falla', err); }
};
// silentSync: el fallo viene de un sondeo, no de un guardado. Se sigue
// reportando el estado de la conexión, pero NO se pinta "Error al guardar":
// antes, un solo fallo pasajero del sondeo dejaba esa insignia encendida para
// siempre, porque nada vuelve a poner syncStatus en 'idle' al tener éxito.
const markApiFailure = (err, context = 'sincronización', opts = {}) => {
const status = err?.status || 0;
const silent = !!opts.silentSync;
// 409 conflict (cp_machine_save) y 403 delete_key_invalid no son fallas de conexión
// ni de permisos: se resuelven en el llamador / en callApi.
if (status === 409 && err?.data?.error === 'conflict') return;
if (status === 403 && (err?.data?.error === 'delete_key_invalid' || err?.data?.error === 'delete_key_not_configured')) return;
if (status === 401) {
setBackendStatus('session-expired');
setBackendMsg('La sesión expiró. Vuelve a iniciar sesión antes de guardar.');
setSyncStatus('session');
return;
}
if (status === 403) {
setBackendStatus('online');
setBackendMsg('Servidor conectado, pero no tienes permiso para esta operación.');
if (!silent) setSyncStatus('error');
return;
}
if (status === 404) return; // 404 = recurso no encontrado, no indica falla de conectividad
if (status > 0) {
// Hubo respuesta HTTP del servidor (así que sí hay conexión): el
// problema es otra cosa (un error real del backend, un timeout de
// PHP procesando algo grande, etc.). Mostrar el motivo real en vez
// de "sin conexión", que hace pensar que el dato nunca llegó al
// servidor cuando en realidad sí llegó y falló allá.
setBackendStatus('online');
setBackendMsg(`No se pudo completar "${context}": ${err?.message || 'error desconocido en el servidor'}.`);
if (!silent) setSyncStatus('error');
return;
}
setBackendStatus('offline');
setBackendMsg(`No hay conexión válida con el servidor (${context}).`);
setSyncStatus('offline');
};
const callApi = async (url, opts = {}, context = 'solicitud', failOpts = {}) => {
try {
const json = await readApiJson(await apiFetch(url, opts));
setBackendStatus('online');
setBackendMsg('Conexión con servidor activa');
return json;
} catch (err) {
if (err?.status === 403 && (err?.data?.error === 'delete_key_invalid' || err?.data?.error === 'delete_key_not_configured')) {
window.__spDeleteKey = undefined;
err.deleteKeyInvalid = true;
showToast(err.data.error === 'delete_key_not_configured'
? 'No se eliminó: un administrador debe crear primero la clave de eliminación (Usuarios)'
: 'Clave de eliminación incorrecta', 'err');
revertRejectedDelete(opts);
}
markApiFailure(err, context, failOpts);
throw err;
}
};
// El servidor rechazó un borrado por clave incorrecta: la UI ya lo había quitado
// (optimista). Se olvida la marca local de "eliminado" para que el sondeo
// (action=sync, 5-10 s) vuelva a traer el elemento desde el servidor, y se
// recargan los datos que no cubre el sondeo (equipos).
const revertRejectedDelete = (opts) => {
try {
const b = JSON.parse(opts?.body || '{}');
if (b.action === 'plan_batch_delete' && b.fecha && b.batch_id) {
pendingBatchDeletes.current[b.fecha]?.delete(b.batch_id);
if (savedBatchData.current[b.fecha]) delete savedBatchData.current[b.fecha][b.batch_id];
if (batchTimestamps.current[b.fecha]) delete batchTimestamps.current[b.fecha][b.batch_id];
if (b.fecha === date) setPlanReloadTick(t => t + 1);
} else if (b.action === 'cp_machine_delete' && b.machine_id) {
pendingMachineDeletes.current.delete(b.machine_id);
deletedMachineIds.current.delete(b.machine_id);
delete savedMachineData.current[b.machine_id];
delete machineTimestamps.current[b.machine_id];
} else if (b.action === 'equipo_delete') {
apiFetch(`${API_URL}?action=equipos_get`).then(readApiJson).then(j => {
if (j?.ok && Array.isArray(j.data)) {
setEquipos(j.data);
try { localStorage.setItem(EQUIPOS_STORAGE_KEY, JSON.stringify(j.data)); } catch (_) {}
}
}).catch(() => {});
} else if (b.action === 'plan_db_delete' || b.action === 'db_clear_all') {
setPlanReloadTick(t => t + 1);
}
} catch (_) {}
};
// Error visible de una operación de guardado/borrado (antes .catch(() => {}) mudo).
// callApi ya marcó backendStatus/syncStatus (markApiFailure); aquí se avisa al usuario.
// Los casos ya resueltos en otro sitio (clave de borrado incorrecta, conflicto 409) no repiten aviso.
const notifyApiError = (what, err) => {
if (err?.deleteKeyInvalid) return;
if (err?.status === 409 && err?.data?.error === 'conflict') return;
const msg = err?.status === 401 ? 'la sesión expiró; vuelve a iniciar sesión'
: (err?.message || 'error desconocido');
const key = `${what}|${msg}`;
const nowT = Date.now();
if (lastErrToastRef.current.key !== key || nowT - lastErrToastRef.current.at > 8000) {
lastErrToastRef.current = { key, at: nowT };
showToast(`No se pudo ${what}: ${msg}`, 'err');
}
setSyncMsg(`⚠ No se pudo ${what}`);
setSyncStatus(s => (err?.status === 401 ? 'session' : (err?.status > 0 ? 'error' : s)));
};
const showThrottledSyncMsg = (msg) => {
const now = Date.now();
if (now - lastSyncMsgAt.current < SYNC_MSG_THROTTLE_MS) return;
lastSyncMsgAt.current = now;
setSyncMsg(msg);
};
// ─ Detector de conexión a internet ─
useEffect(() => {
const goOnline = () => { setIsOnline(true); setBackendStatus('checking'); setSyncStatus(s => s === 'offline' ? 'idle' : s); };
const goOffline = () => { setIsOnline(false); setBackendStatus('offline'); setBackendMsg('El navegador está sin conexión.'); setSyncStatus('offline'); };
window.addEventListener('online', goOnline);
window.addEventListener('offline', goOffline);
return () => {
window.removeEventListener('online', goOnline);
window.removeEventListener('offline', goOffline);
};
}, []);
// ─ Heartbeat: mantiene viva la sesión y detecta expiración/desconexión ─
useEffect(() => {
let cancelled = false;
// Sincroniza el reloj contra el servidor. En el arranque toma 3 muestras
// consecutivas para que el filtro NTP tenga datos suficientes desde el inicio.
const syncClock = async (samples = 1) => {
for (let i = 0; i < samples; i++) {
try {
const t0 = Date.now();
const data = await readApiJson(await apiFetch(`${API_URL}?action=heartbeat&_=${t0}`));
const t1 = Date.now();
if (data?.server_time && window.calibrateFromServer) {
window.calibrateFromServer(data.server_time, t0, t1);
}
} catch {}
if (i < samples - 1) await new Promise(r => setTimeout(r, 200));
}
};
const heartbeat = async () => {
if (typeof navigator !== 'undefined' && !navigator.onLine) {
setIsOnline(false);
setBackendStatus('offline');
setBackendMsg('El navegador está sin conexión.');
setSyncStatus('offline');
return;
}
try {
const t0 = Date.now();
const data = await readApiJson(await apiFetch(`${API_URL}?action=heartbeat&_=${t0}`));
const t1 = Date.now();
if (data?.server_time && window.calibrateFromServer) {
window.calibrateFromServer(data.server_time, t0, t1);
}
if (cancelled) return;
setIsOnline(true);
setBackendStatus('online');
setBackendMsg('Conexión con servidor activa');
setSyncStatus(s => (s === 'offline' || s === 'session') ? 'idle' : s);
} catch (err) {
if (!cancelled) markApiFailure(err, 'heartbeat');
}
};
// 3 muestras rápidas al arrancar para calibrar bien desde el inicio
syncClock(3).then(() => { if (!cancelled) { heartbeat(); if (rolloverRef.current) rolloverRef.current(); } });
// Con sesion iniciada, el sondeo unificado (action=sync) ya trae server_time
// y refresca el estado de conexion, asi que este temporizador solo queda
// para la pantalla de login.
const id = setInterval(() => { if (!unifiedSyncActive.current) heartbeat(); }, 60000);
return () => { cancelled = true; clearInterval(id); };
}, []);
// ─ Cargar horario semanal desde la nube ─
useEffect(() => {
callApi(`${API_URL}?action=week_schedule_get`, {}, 'cargar horario semanal')
.then(j => {
if (j?.ok && j.data && typeof j.data === 'object') {
setSchedules(j.data);
try { localStorage.setItem(SCHED_KEY, JSON.stringify(j.data)); } catch (_) {}
}
})
.catch(() => showThrottledSyncMsg('⚠ No se pudo cargar el horario semanal'));
}, []);
// ─ Cargar catálogo personalizado y aplicarlo a AppData ─
useEffect(() => {
callApi(`${API_URL}?action=catalog_get`, {}, 'cargar catálogo')
.then(j => {
if (j?.ok && Array.isArray(j.data) && j.data.length > 0) {
setCustomCatalog(j.data);
rebuildAppData(j.data);
}
})
.catch(() => showThrottledSyncMsg('⚠ No se pudo cargar el catálogo'));
}, []);
const handleSaveCatalog = async (entries) => {
setCustomCatalog(entries);
rebuildAppData(entries);
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'catalog_save', catalog: entries }),
}, 'guardar catálogo');
} catch (err) { notifyApiError('guardar el catálogo', err); throw err; }
};
// ─ Cargar configuración editable (marcas, líneas, estados de fase, tipos de máquina) ─
useEffect(() => {
callApi(`${API_URL}?action=appconfig_get`, {}, 'cargar configuración')
.then(j => { if (j?.ok && j.data && typeof j.data === 'object') { applyAppConfig(j.data); setAppCfg(j.data); } })
.catch(() => showThrottledSyncMsg('⚠ No se pudo cargar la configuración'));
}, []);
const handleSaveConfig = async (cfg) => {
applyAppConfig(cfg);
setAppCfg(cfg);
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'appconfig_save', config: cfg }),
}, 'guardar configuración');
} catch (err) { notifyApiError('guardar la configuración', err); throw err; }
};
const onScheduleChange = (next) => {
setSchedules(next);
try { localStorage.setItem(SCHED_KEY, JSON.stringify(next)); } catch (_) {}
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'week_schedule_save', schedule: next }),
}, 'guardar horario semanal').catch(err => notifyApiError('guardar el horario semanal', err));
};
// ─ Cargar plan del día desde la nube ─
useEffect(() => {
setCloudReady(false);
const loadDay = async () => {
try {
// Intentar tabla granular primero
const json = await callApi(`${API_URL}?action=plan_batch_list&fecha=${date}`, {}, 'cargar plan');
let batches = null;
if (json?.ok && Array.isArray(json.data)) {
// [] es un estado válido: significa que el día existe en la tabla granular
// pero no tiene bases. No debe caer al respaldo legacy o reaparecen borrados.
batches = json.data.map(r => r.batch);
savedBatchData.current[date] = {};
batchTimestamps.current[date] = {};
json.data.forEach(r => {
savedBatchData.current[date][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[date][r.batch_id] = r.updated_at;
});
// Tombstones del servidor: marcar y excluir del plan para que auto-save no los reenvíe
if (Array.isArray(json.deleted_ids) && json.deleted_ids.length > 0) {
if (!pendingBatchDeletes.current[date]) pendingBatchDeletes.current[date] = new Set();
json.deleted_ids.forEach(id => {
savedBatchData.current[date][id] = null;
pendingBatchDeletes.current[date].add(id);
});
batches = batches.filter(b => !pendingBatchDeletes.current[date].has(b.id));
}
} else {
// Fallback a tabla monolítica (datos previos al cambio de arquitectura)
const oldJ = await callApi(`${API_URL}?action=plan_db_get&fecha=${date}`, {}, 'cargar plan legado');
if (oldJ?.ok && oldJ.data?.batches) {
batches = oldJ.data.batches;
savedBatchData.current[date] = {};
batchTimestamps.current[date] = {};
// Populate savedBatchData from legacy so auto-save migrates them
// and plan_batch_delete can find them (won't return 404)
batches.forEach(b => {
savedBatchData.current[date][b.id] = JSON.stringify(b);
});
} else {
savedBatchData.current[date] = {};
batchTimestamps.current[date] = {};
}
}
if (batches) {
setPlan(prev => {
const next = { ...prev, [date]: batches };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
setSyncMsg('☁ Cargado desde la nube');
} else {
setSyncMsg('ℹ Sin datos en nube para esta fecha');
}
} catch (_) {
setSyncMsg('⚠ No se pudo cargar desde la nube');
} finally {
setCloudReady(true);
}
};
loadDay();
}, [date, planReloadTick]);
// ─ Persistir en localStorage ─
useEffect(() => {
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(plan)); } catch (_) {}
}, [plan]);
// Auto-carryover eliminado — el traslado de bases pendientes es ahora
// manual mediante el botón "Pendientes de ayer" en la vista Diaria.
// ─ Cargar todos los días de la semana al abrir vista Semanal ─
useEffect(() => {
if (view !== 'week') return;
const start = startOfWeek(date);
const weekDays = Array.from({ length: 7 }, (_, i) => shiftDate(start, i));
weekDays.forEach(async (d) => {
if (d === date) return; // ya cargado por el efecto principal
try {
const json = await callApi(`${API_URL}?action=plan_batch_list&fecha=${d}`, {}, 'cargar semana');
if (json?.ok && Array.isArray(json.data)) {
// [] es un estado válido en granular y evita recuperar datos borrados desde legacy.
const batches = json.data.map(r => r.batch);
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
json.data.forEach(r => {
savedBatchData.current[d][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[d][r.batch_id] = r.updated_at;
});
setPlan(prev => {
const next = { ...prev, [d]: batches };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
} else {
// Fallback a tabla monolítica
const oldJ = await callApi(`${API_URL}?action=plan_db_get&fecha=${d}`, {}, 'cargar semana legado');
if (oldJ?.ok && oldJ.data?.batches) {
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
setPlan(prev => {
const next = { ...prev, [d]: oldJ.data.batches };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
} else {
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
}
}
} catch (_) {}
});
}, [view, date]);
// ════════════════════════════════════════════
// VISTA LISTA — todo un mes en una sola lista (1 consulta por mes)
// Las bases de cada día viven en `plan[fecha]`, igual que en Diaria; así las
// tarjetas, modales y totales son los mismos. Lo nuevo es cargar el mes con
// plan_batch_range y guardar los días que no son la fecha activa.
// ════════════════════════════════════════════
const [listMonth, setListMonth] = useState(() => todayStr().slice(0, 7));
const [listState, setListState] = useState({ loading: false, error: '', loadedAt: null });
const monthDates = (month) => {
const [y, m] = month.split('-').map(Number);
const n = new Date(y, m, 0).getDate();
return Array.from({ length: n }, (_, i) => `${month}-${String(i + 1).padStart(2, '0')}`);
};
// Un día con cambios sin guardar no se pisa al recargar el mes.
const dayHasUnsaved = (d) => {
const srv = savedBatchData.current[d];
if (!srv) return false;
const cur = planRef.current[d] || [];
if (cur.some(b => srv[b.id] !== null && JSON.stringify(b) !== srv[b.id])) return true;
const ids = new Set(cur.map(b => b.id));
const pend = pendingBatchDeletes.current[d] || new Set();
return Object.keys(srv).some(id => srv[id] !== null && !ids.has(id) && !pend.has(id));
};
const loadListMonth = async (month, silent = false) => {
if (!silent) setListState(st => ({ ...st, loading: true, error: '' }));
try {
const dates = monthDates(month);
const json = await callApi(`${API_URL}?action=plan_batch_range&desde=${dates[0]}&hasta=${dates[dates.length - 1]}`, {}, 'cargar lista del mes');
if (!json?.ok) throw new Error(json?.error || 'respuesta inválida');
const byDate = json.data || {};
const deleted = json.deleted || {};
const updates = {};
dates.forEach(d => {
if (dayHasUnsaved(d)) return;
const rows = byDate[d] || [];
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
rows.forEach(r => {
savedBatchData.current[d][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[d][r.batch_id] = r.updated_at;
});
const del = deleted[d] || [];
if (del.length) {
if (!pendingBatchDeletes.current[d]) pendingBatchDeletes.current[d] = new Set();
del.forEach(id => { savedBatchData.current[d][id] = null; pendingBatchDeletes.current[d].add(id); });
}
const pend = pendingBatchDeletes.current[d] || new Set();
updates[d] = rows.map(r => r.batch).filter(b => !pend.has(b.id));
});
setPlan(prev => {
const next = { ...prev, ...updates };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
setListState({ loading: false, error: '', loadedAt: Date.now() });
} catch (err) {
setListState(st => ({ ...st, loading: false, error: silent ? st.error : (err?.message || 'No se pudo cargar el mes') }));
}
};
// Carga al abrir la Lista o al cambiar de mes; refresco silencioso cada 60 s.
useEffect(() => {
if (view !== 'lista') return;
loadListMonth(listMonth);
const t = setInterval(() => { if (!document.hidden) loadListMonth(listMonth, true); }, 60000);
return () => clearInterval(t);
}, [view, listMonth]);
// Guarda los días del mes (excepto la fecha activa, que ya cubre el autoguardado
// de Diaria) con el mismo criterio: solo lo que cambió respecto a lo guardado.
const flushListDays = async (month, includeActive = false) => {
if (!hasValidBackend || (!canPersistPlan && !canDelete)) return false;
let didSave = false;
for (const d of monthDates(month)) {
if (!includeActive && d === date) continue;
const serverDay = savedBatchData.current[d];
if (!serverDay) continue; // día no cargado: nada con qué comparar
const dayBatches = planRef.current[d] || [];
const ids = new Set(dayBatches.map(b => b.id));
const pend = pendingBatchDeletes.current[d] || new Set();
const toSave = canPersistPlan ? dayBatches.filter(b => serverDay[b.id] !== null && JSON.stringify(b) !== serverDay[b.id]) : [];
const toDelete = Object.keys(serverDay).filter(id => serverDay[id] !== null && !ids.has(id) && !pend.has(id));
for (const batch of toSave) {
try {
const r = await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_save', fecha: d, batch_id: batch.id, batch_data: batch }),
}, 'guardar planificación');
if (r?.tombstoned) {
serverDay[batch.id] = null;
if (!pendingBatchDeletes.current[d]) pendingBatchDeletes.current[d] = new Set();
pendingBatchDeletes.current[d].add(batch.id);
setPlan(prev => ({ ...prev, [d]: (prev[d] || []).filter(b => b.id !== batch.id) }));
} else {
serverDay[batch.id] = JSON.stringify(batch);
}
didSave = true;
} catch (err) { notifyApiError('guardar la planificación', err); }
}
for (const id of toDelete) {
try {
serverDay[id] = null;
await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_delete', fecha: d, batch_id: id }),
}, 'eliminar planificación');
didSave = true;
} catch (err) { notifyApiError('eliminar la base', err); }
}
}
return didSave;
};
useEffect(() => {
if (view !== 'lista' || !cloudReady) return;
const t = setTimeout(async () => {
const dirty = monthDates(listMonth).some(d => d !== date && dayHasUnsaved(d));
if (!dirty) return;
setSyncStatus('saving');
const ok = await flushListDays(listMonth);
setSyncMsg(ok ? '☁ Guardado en la nube' : '');
setSyncStatus(ok ? 'saved' : 'idle');
setTimeout(() => setSyncStatus(s => s === 'saved' ? 'idle' : s), 3000);
}, 900);
return () => clearTimeout(t);
}, [plan, view, listMonth, date, cloudReady, hasValidBackend]);
// Al salir de la Lista o cambiar de mes, guarda lo pendiente (sin esperar el debounce).
const flushListRef = useRef(null);
flushListRef.current = flushListDays; // siempre la versión del último render
useEffect(() => {
if (view !== 'lista') return;
const m = listMonth;
return () => { flushListRef.current && flushListRef.current(m, true); };
}, [view, listMonth]);
// Ir a otra pantalla de un día concreto: guarda primero para que la recarga del día no pise lo editado.
const goToDay = async (d, target, from) => {
await flushListDays(listMonth, true);
setDate(d);
if (from) setBackTo(from);
setView(target);
};
// ─ Guardar cambios pendientes al cambiar de fecha ─
// Evita que el debounce de 900ms cancele un guardado en curso al navegar
const prevDateRef = useRef(date);
useEffect(() => {
const prevDate = prevDateRef.current;
prevDateRef.current = date;
if (prevDate === date || !canPersistPlan) return;
const prevBatches = planRef.current[prevDate] || [];
const serverDay = savedBatchData.current[prevDate] || {};
const toSave = prevBatches.filter(b => JSON.stringify(b) !== serverDay[b.id]);
const prevIds = new Set(prevBatches.map(b => b.id));
const pendingPrevDeletes = pendingBatchDeletes.current[prevDate] || new Set();
const toDelete = Object.keys(serverDay).filter(id => serverDay[id] !== null && !prevIds.has(id) && !pendingPrevDeletes.has(id));
if (toSave.length === 0 && toDelete.length === 0) return;
// Fire-and-forget: guarda sin bloquear la navegación
(async () => {
for (const batch of toSave) {
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_save', fecha: prevDate, batch_id: batch.id, batch_data: batch }),
}, 'guardar cambios al cambiar de fecha');
if (!savedBatchData.current[prevDate]) savedBatchData.current[prevDate] = {};
savedBatchData.current[prevDate][batch.id] = JSON.stringify(batch);
} catch (err) { notifyApiError('guardar los cambios del día anterior', err); }
}
for (const batchId of toDelete) {
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_delete', fecha: prevDate, batch_id: batchId }),
}, 'eliminar cambios al cambiar de fecha');
if (savedBatchData.current[prevDate]) savedBatchData.current[prevDate][batchId] = null;
} catch (err) { notifyApiError('eliminar la base del día anterior', err); }
}
})();
}, [date]); // solo se dispara al cambiar fecha
// ─ Auto-guardar batches granularmente (solo los que cambiaron) ─
useEffect(() => {
if (!cloudReady || !hasValidBackend || (!canPersistPlan && !canDelete)) return;
const dayBatches = plan[date] || [];
const serverDay = savedBatchData.current[date] || {};
const capturedDate = date;
let active = true;
// Detectar si hay algo que guardar antes del debounce
const toSaveCheck = canPersistPlan ? dayBatches.filter(b => JSON.stringify(b) !== serverDay[b.id]) : [];
const currentIdsCheck = new Set(dayBatches.map(b => b.id));
const pendingDeletesCheck = new Set(pendingBatchDeletes.current[capturedDate] || []);
const toDeleteCheck = Object.keys(serverDay).filter(id => serverDay[id] !== null && !currentIdsCheck.has(id) && !pendingDeletesCheck.has(id));
if (toSaveCheck.length > 0 || toDeleteCheck.length > 0) {
setSyncStatus('saving');
}
const t = setTimeout(async () => {
if (!active) return;
try {
// Lee savedBatchData fresco en este momento — puede haber cambiado durante el debounce
// (por polling que reemplazó el objeto, o por un delete que puso tombstone)
const freshServerDay = savedBatchData.current[capturedDate] || {};
// Batches añadidos o modificados (excluye los tombstoneados localmente con null)
const toSave = canPersistPlan
? dayBatches.filter(b => {
const entry = freshServerDay[b.id];
return entry !== null && JSON.stringify(b) !== entry;
})
: [];
// Batches eliminados localmente — lee refs en vivo, no capturas obsoletas
const currentIds = new Set(dayBatches.map(b => b.id));
const freshPendingDeletes = pendingBatchDeletes.current[capturedDate] || new Set();
const toDelete = Object.keys(freshServerDay).filter(id => freshServerDay[id] !== null && !currentIds.has(id) && !freshPendingDeletes.has(id));
for (const batch of toSave) {
const saveResult = await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_save', fecha: capturedDate, batch_id: batch.id, batch_data: batch }),
}, 'guardar planificación');
if (!savedBatchData.current[capturedDate]) savedBatchData.current[capturedDate] = {};
if (saveResult?.tombstoned) {
// El servidor tiene este batch como eliminado — quitarlo del plan local
savedBatchData.current[capturedDate][batch.id] = null;
if (!pendingBatchDeletes.current[capturedDate]) pendingBatchDeletes.current[capturedDate] = new Set();
pendingBatchDeletes.current[capturedDate].add(batch.id);
if (active) setPlan(prev => {
const next = { ...prev, [capturedDate]: (prev[capturedDate] || []).filter(b => b.id !== batch.id) };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
} else {
savedBatchData.current[capturedDate][batch.id] = JSON.stringify(batch);
}
}
for (const batchId of toDelete) {
// Marca tombstone antes del API call para que el polling lo filtre si llega durante el in-flight
if (!savedBatchData.current[capturedDate]) savedBatchData.current[capturedDate] = {};
savedBatchData.current[capturedDate][batchId] = null;
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_delete', fecha: capturedDate, batch_id: batchId }),
}, 'eliminar planificación');
}
if (toSave.length > 0 || toDelete.length > 0) {
// Actualiza timestamps locales para que el polling ignore nuestros propios cambios
const chkJ = await callApi(`${API_URL}?action=plan_batch_check&fecha=${capturedDate}`, {}, 'confirmar guardado del plan');
if (chkJ?.ok && active) {
batchTimestamps.current[capturedDate] = {};
(chkJ.data || []).forEach(({ batch_id, updated_at }) => {
batchTimestamps.current[capturedDate][batch_id] = updated_at;
});
}
if (active) {
setSyncMsg('☁ Guardado en la nube');
setSyncStatus('saved');
setTimeout(() => setSyncStatus(s => s === 'saved' ? 'idle' : s), 3000);
}
} else if (active) {
setSyncStatus('idle');
}
} catch (_) {
if (active) {
setSyncMsg('⚠ Sin sincronización');
setSyncStatus('error');
}
}
}, 900);
return () => {
active = false;
clearTimeout(t);
};
}, [plan, date, cloudReady, canPersistPlan, canDelete, hasValidBackend]);
// ─ Máquinas de Control de Proceso ─
// No se ejecuta cp_machine_list automáticamente: esa descarga reemplazaba el estado
// local con una versión vacía/antigua del servidor y borraba la información escrita
// en las máquinas. La pantalla trabaja con localStorage y el auto-guardado granular.
useEffect(() => {
setCpCloudReady(true);
}, []);
// ─ Cargar perfiles de máquinas al inicio ─
useEffect(() => {
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=machine_profiles_get`, {}, 'cargar perfiles de máquinas');
if (json?.ok && json.data) {
setMachineProfiles(json.data);
try { localStorage.setItem(MACHINE_PROFILES_STORAGE_KEY, JSON.stringify(json.data)); } catch (_) {}
}
} catch (_) { showThrottledSyncMsg('⚠ No se pudieron cargar los perfiles de máquinas'); }
};
load();
}, []);
// ─ Cargar fórmulas de matización (historial/evolución, compartidas) ─
useEffect(() => {
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=formula_get`, {}, 'cargar fórmulas');
if (json?.ok && Array.isArray(json.data)) setFormulas(json.data);
} catch (_) { showThrottledSyncMsg('⚠ No se pudieron cargar las fórmulas'); }
};
load();
}, []);
// ─ Cargar fórmulas de BASE (separadas de color; para Consumo MP) ─
useEffect(() => {
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=bformula_get`, {}, 'cargar fórmulas de base');
if (json?.ok && Array.isArray(json.data)) setBaseFormulas(json.data);
} catch (_) { showThrottledSyncMsg('⚠ No se pudieron cargar las fórmulas de base'); }
};
load();
}, []);
// ─ Cargar operadores (grupos + personas sin grupo) por departamento ─
// Se refresca al entrar a Control para reflejar cambios del panel Personal.
useEffect(() => {
if (view !== 'control' && view !== 'day') return;
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=prep_operators`, {}, 'cargar operadores');
if (json?.ok && json.data) setOperators(json.data);
} catch (_) { showThrottledSyncMsg('⚠ No se pudieron cargar los operadores'); }
};
load();
}, [view]);
const saveFormula = async (rec) => {
setFormulas(prev => {
const exists = prev.some(f => f.id === rec.id);
return exists ? prev.map(f => f.id === rec.id ? rec : f) : [...prev, rec];
});
// Si la fórmula corresponde a un color del día actual, márcalo como matizado.
if (rec.colorId && canCheckMatizacion) {
const b = (plan[date] || []).find(bb => (bb.colors || []).some(c => c.id === rec.colorId));
const c = b && (b.colors || []).find(x => x.id === rec.colorId);
if (c && !c.checkMA) updateColor(b.id, { ...c, checkMA: true });
}
try {
await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'formula_save', formula_id: rec.id, producto: rec.producto || '', data: rec }),
}, 'guardar fórmula');
showToast('Fórmula guardada');
} catch (err) {
showToast(`No se pudo guardar la fórmula: ${err?.message || 'error'}`, 'err');
}
};
const deleteFormula = async (id) => {
setFormulas(prev => prev.filter(f => f.id !== id));
try {
await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'formula_delete', formula_id: id }),
}, 'eliminar fórmula');
showToast('Registro eliminado');
} catch (err) {
showToast(`No se pudo eliminar: ${err?.message || 'error'}`, 'err');
}
};
const saveBaseFormula = async (rec) => {
setBaseFormulas(prev => {
const exists = prev.some(f => f.id === rec.id);
return exists ? prev.map(f => f.id === rec.id ? rec : f) : [...prev, rec];
});
try {
await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'bformula_save', formula_id: rec.id, producto: rec.producto || '', data: rec }),
}, 'guardar fórmula de base');
showToast('Fórmula de base guardada');
} catch (err) {
showToast(`No se pudo guardar la fórmula: ${err?.message || 'error'}`, 'err');
}
};
const deleteBaseFormula = async (id) => {
setBaseFormulas(prev => prev.filter(f => f.id !== id));
try {
await callApi(API_URL, {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'bformula_delete', formula_id: id }),
}, 'eliminar fórmula de base');
showToast('Registro eliminado');
} catch (err) {
showToast(`No se pudo eliminar: ${err?.message || 'error'}`, 'err');
}
};
// ─ Cargar equipos/herramientas al inicio (compartidos en la nube) ─
useEffect(() => {
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=equipos_get`, {}, 'cargar equipos');
if (json?.ok && Array.isArray(json.data)) {
setEquipos(json.data);
try { localStorage.setItem(EQUIPOS_STORAGE_KEY, JSON.stringify(json.data)); } catch (_) {}
}
} catch (_) { showThrottledSyncMsg('⚠ No se pudieron cargar los equipos'); }
};
load();
}, []);
// ─ Auto-guardar máquinas — mismo patrón que la sección Diaria ─
// Debounce 900ms: espera a que el usuario termine de editar antes de guardar.
// Guarda cada máquina individualmente solo si cambió respecto al servidor.
// También persiste en localStorage como backup ante fallos de red.
useEffect(() => {
// canPersistMachines = Control de Proceso + correcciones/ediciones del historial
// (edit_historial/fix_historial), que el servidor acepta en cp_machine_save.
if (!cpCloudReady || !canPersistMachines) return;
// Guardar en localStorage inmediatamente como backup local, sin depender de
// cp_machine_list para reconstruir el estado de las máquinas.
try { localStorage.setItem(MACHINE_STORAGE_KEY, JSON.stringify(cpMachines)); } catch (_) {}
const currentIds = new Set(cpMachines.map(m => m.id));
const serverMachines = savedMachineData.current || {};
const toSaveCheck = cpMachines.filter(m => {
const entry = serverMachines[m.id];
return entry !== null && JSON.stringify(m) !== entry && !machinesSaveInFlight.current.has(m.id);
});
const toDeleteCheck = Object.keys(serverMachines).filter(id => (
serverMachines[id] !== null &&
!currentIds.has(id) &&
!pendingMachineDeletes.current.has(id)
));
if (toSaveCheck.length === 0 && toDeleteCheck.length === 0) return;
const t = setTimeout(async () => {
try {
const serverMachines = savedMachineData.current;
const currentIds = new Set(cpMachines.map(m => m.id));
const pendingDeletes = new Set(pendingMachineDeletes.current);
const toSave = cpMachines.filter(m =>
!pendingDeletes.has(m.id) &&
serverMachines[m.id] !== null &&
JSON.stringify(m) !== serverMachines[m.id]
);
const toDelete = Object.keys(serverMachines).filter(id =>
serverMachines[id] !== null && !currentIds.has(id) && !pendingDeletes.has(id)
);
const savedNow = new Set(); // máquinas guardadas en ESTA ronda (sus timestamps son fiables)
for (const machine of toSave) {
machinesSaveInFlight.current.add(machine.id);
try {
const saveResult = await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
action: 'cp_machine_save', machine_id: machine.id, machine_data: machine,
// Control de concurrencia: el servidor responde 409 si otro usuario la modificó antes.
expected_updated_at: machineTimestamps.current[machine.id] || null,
}),
}, 'guardar máquina');
if (saveResult?.tombstoned) {
savedMachineData.current[machine.id] = null;
deletedMachineIds.current.add(machine.id);
setCpMachines(prev => prev.filter(m => m.id !== machine.id));
showToast('Otro usuario eliminó esta máquina; se quitó de la lista', 'warn');
} else {
savedMachineData.current = { ...savedMachineData.current, [machine.id]: JSON.stringify(machine) };
if (saveResult?.updated_at) machineTimestamps.current[machine.id] = saveResult.updated_at;
savedNow.add(machine.id);
}
} catch (err) {
if (err?.status === 409 && err?.data?.error === 'conflict' && err.data.machine_data) {
// Otro usuario modificó esta máquina: se adopta la versión del servidor.
const srv = err.data.machine_data;
if (JSON.stringify(srv) === savedMachineData.current[machine.id]) {
// El servidor tiene lo mismo que ya sabíamos (solo cambió el sello de tiempo):
// no hay conflicto real; se adopta el sello y se reintenta sin pisar lo local.
if (err.data.updated_at) machineTimestamps.current[machine.id] = err.data.updated_at;
setTimeout(() => setCpMachines(prev => [...prev]), 200);
continue;
}
savedMachineData.current = { ...savedMachineData.current, [machine.id]: JSON.stringify(srv) };
if (err.data.updated_at) machineTimestamps.current[machine.id] = err.data.updated_at;
setCpMachines(prev => (prev || []).map(m => m.id === machine.id ? srv : m));
showToast('Otro usuario modificó esta máquina; se actualizó', 'warn');
} else {
// Forzar reintento en 3s disparando el efecto de auto-save de nuevo
setTimeout(() => setCpMachines(prev => [...prev]), 3000);
}
} finally {
machinesSaveInFlight.current.delete(machine.id);
}
}
for (const machineId of toDelete) {
savedMachineData.current[machineId] = null;
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'cp_machine_delete', machine_id: machineId }),
}, 'eliminar máquina');
} catch (err) { notifyApiError('eliminar la máquina', err); }
}
// Actualizar timestamps para futuras operaciones sin descargar cp_machine_list.
// silentSync: si esta confirmación falla, el guardado YA se hizo; no es un
// "Error al guardar".
try {
const chkJ = await callApi(`${API_URL}?action=cp_machine_check`, {}, 'confirmar guardado de máquinas', { silentSync: true });
if (chkJ?.ok) {
// Solo se actualizan las máquinas que ESTE guardado acaba de escribir (y se
// descartan las borradas). Reemplazar todo el mapa ocultaba al sondeo los
// cambios de otros usuarios y falseaba expected_updated_at.
const serverIds = new Set();
(chkJ.data || []).forEach(({ machine_id, updated_at }) => {
serverIds.add(machine_id);
if (savedNow.has(machine_id)) machineTimestamps.current[machine_id] = updated_at;
});
toDelete.forEach(id => { if (!serverIds.has(id)) delete machineTimestamps.current[id]; });
}
} catch (_) {}
// Lo que se editó MIENTRAS este guardado estaba en vuelo se quedó fuera:
// toSaveCheck excluye las máquinas con guardado en curso y, si no queda
// nada más por hacer, el efecto hace return sin programar otro intento.
// Como savedMachineData es un ref y no una dependencia, nada vuelve a
// despertar el efecto y esa edición se perdía en silencio — había que
// volver a escribirla varias veces hasta acertar un hueco sin guardado en
// curso. Al terminar comprobamos si quedó algo pendiente y re-disparamos.
if (toSave.length > 0 || toDelete.length > 0) {
const saved = savedMachineData.current || {};
const quedaPendiente = (cpMachinesRef.current || []).some(m =>
saved[m.id] !== null
&& !machinesSaveInFlight.current.has(m.id)
&& JSON.stringify(m) !== saved[m.id]
);
if (quedaPendiente) setCpMachines(prev => [...prev]);
}
} catch (err) {
setSyncMsg(`⚠ No se pudieron sincronizar máquinas: ${err?.message || 'error desconocido'}`);
setSyncStatus('error');
}
}, 900);
return () => clearTimeout(t);
}, [cpMachines, cpCloudReady, canPersistMachines]);
// ─ Sondeo unificado: heartbeat + máquinas + planificación en UNA petición ─
// Antes había tres temporizadores independientes (heartbeat 60 s, máquinas 5 s,
// planificación 10/30 s) y cada ciclo costaba 3 peticiones — en vista semanal,
// hasta 9. Una petición cuesta ~300-600 ms de ida y vuelta aunque devuelva 400
// bytes, así que lo que manda es el NÚMERO de peticiones, no su tamaño. Ahora
// un solo `action=sync` trae el reloj del servidor y los timestamps de máquinas
// y de cada día; el detalle se pide solo para lo que realmente cambió.
useEffect(() => {
if (!currentUser) return;
unifiedSyncActive.current = true;
let cancelled = false;
// ── Máquinas: descarga SOLO las que cambiaron ──
// Antes bajaba las 22 con todo su historial (~350 kB) porque cambió una.
const applyMachineCheck = async (serverList) => {
// Copia: más abajo se muta machineTimestamps.current y hace falta el estado previo.
const localTs = { ...machineTimestamps.current };
const serverIds = new Set(serverList.map(r => r.machine_id));
// Esperar a que termine la carga inicial (cp_machine_list completo): si no,
// sin timestamps locales TODO parecería nuevo y bajaríamos las máquinas dos
// veces. Una vez terminada seguimos adelante aunque los refs estén vacíos,
// porque eso significa que la carga inicial falló y el sondeo debe recuperar.
if (!cpInitialLoadDone.current) return;
const changedIds = serverList
.filter(r => r.updated_at !== localTs[r.machine_id])
.map(r => r.machine_id);
const removedIds = Object.keys(localTs).filter(id => !serverIds.has(id));
if (!changedIds.length && !removedIds.length) return;
let fetched = [];
if (changedIds.length) {
const q = encodeURIComponent(changedIds.join(','));
const fullJ = await callApi(`${API_URL}?action=cp_machine_list&ids=${q}`, {}, 'actualizar máquinas', { silentSync: true });
if (cancelled || !fullJ?.ok || !Array.isArray(fullJ.data)) return;
fetched = fullJ.data;
}
// Máquinas con cambios locales que aún no están guardadas (o con el guardado en
// curso): NO se pisan con lo que devuelve el servidor, que todavía trae la versión
// anterior. Sin esto, un lote finalizado "se devuelve" en la pantalla de otro.
const prevSaved = savedMachineData.current || {};
const dirty = new Set(
(cpMachinesRef.current || [])
.filter(m => machinesSaveInFlight.current.has(m.id)
|| (prevSaved[m.id] !== null && JSON.stringify(m) !== prevSaved[m.id]))
.map(m => m.id)
);
// Fusionar, no reemplazar: lo que no vino en la respuesta sigue siendo válido.
fetched = fetched.filter(r => !deletedMachineIds.current.has(r.machine_id)); // eliminadas (tombstone)
fetched.forEach(r => {
if (dirty.has(r.machine_id)) return;
savedMachineData.current[r.machine_id] = JSON.stringify(r.machine);
machineTimestamps.current[r.machine_id] = r.updated_at;
});
removedIds.forEach(id => {
if (dirty.has(id)) return;
delete savedMachineData.current[id];
delete machineTimestamps.current[id];
});
setCpMachines(prev => {
const byId = new Map((prev || []).map(m => [m.id, m]));
fetched.forEach(r => {
if (dirty.has(r.machine_id) || !r.machine) return;
byId.set(r.machine_id, r.machine);
});
removedIds.forEach(id => { if (!dirty.has(id)) byId.delete(id); });
return [...byId.values()];
});
const updaters = [...new Set(
serverList.filter(r => r.updated_at !== localTs[r.machine_id]).map(r => r.updated_by)
)].filter(Boolean).join(', ');
if (updaters) showThrottledSyncMsg(window.t('↻ Máquinas actualizadas por {u}').replace('{u}', updaters));
};
// ── Planificación de un día: igual que antes, pero sin su propio check ──
const applyBatchCheck = async (d, serverList) => {
const localTs = { ...(batchTimestamps.current[d] || {}) };
const serverIds = new Set(serverList.map(r => r.batch_id));
// Hay cambio si algún timestamp difiere o si hay batches nuevos/eliminados
const hasChange = serverList.some(r => r.updated_at !== localTs[r.batch_id])
|| Object.keys(localTs).some(id => !serverIds.has(id));
if (!hasChange) return;
const fullJ = await callApi(`${API_URL}?action=plan_batch_list&fecha=${d}`, {}, 'descargar planificación actualizada', { silentSync: true });
if (cancelled || !fullJ?.ok || !Array.isArray(fullJ.data)) return;
const batches = fullJ.data.map(r => r.batch);
// Captura datos previos ANTES de sobreescribir refs
const prevSaved = savedBatchData.current[d] || {};
// Bases con cambios locales que aún NO están guardadas. No se pisan con lo
// que devuelve el servidor, que todavía trae la versión anterior: sin esto,
// un dato recién anotado se perdía en cuanto cualquier otra base del mismo
// día cambiaba en el servidor (propia o de otro usuario), porque el sondeo
// reemplazaba el día entero. Es la misma proteccion que ya tienen las
// máquinas, y la que loadListMonth aplica con dayHasUnsaved().
const localDay = planRef.current[d] || [];
const dirtyIds = new Set(
localDay
.filter(b => prevSaved[b.id] !== null && JSON.stringify(b) !== prevSaved[b.id])
.map(b => b.id)
);
const nextSaved = {};
const nextTs = {};
fullJ.data.forEach(r => {
if (dirtyIds.has(r.batch_id)) {
// Conserva lo que el auto-guardado conoce, para que siga viendo el cambio
// pendiente y lo suba; si no, lo daria por guardado y se perderia.
if (r.batch_id in prevSaved) nextSaved[r.batch_id] = prevSaved[r.batch_id];
if (r.batch_id in localTs) nextTs[r.batch_id] = localTs[r.batch_id];
} else {
nextSaved[r.batch_id] = JSON.stringify(r.batch);
nextTs[r.batch_id] = r.updated_at;
}
});
// Bases creadas aquí que el servidor todavía no conoce
dirtyIds.forEach(id => {
if (!(id in nextSaved) && id in prevSaved) nextSaved[id] = prevSaved[id];
});
savedBatchData.current[d] = nextSaved;
batchTimestamps.current[d] = nextTs;
// Aplicar tombstones del servidor para que auto-save no los reenvíe
const serverDeletedIds = fullJ.deleted_ids || [];
if (serverDeletedIds.length > 0) {
if (!pendingBatchDeletes.current[d]) pendingBatchDeletes.current[d] = new Set();
serverDeletedIds.forEach(id => {
savedBatchData.current[d][id] = null;
pendingBatchDeletes.current[d].add(id);
});
}
const updaters = [...new Set(
serverList.filter(r => r.updated_at !== localTs[r.batch_id]).map(r => r.updated_by)
)].filter(Boolean).join(', ');
setPlan(prev => {
const pending = pendingBatchDeletes.current[d] || new Set();
const localNow = prev[d] || [];
const localById = new Map(localNow.map(b => [b.id, b]));
const serverIdSet = new Set(batches.map(b => b.id));
// Filtra batches que están siendo eliminados (pendingDeletes) o marcados como
// tombstone, y se queda con la versión LOCAL de las que tienen cambios sin guardar.
const merged = batches
.filter(b => !pending.has(b.id) && prevSaved[b.id] !== null)
.map(b => (dirtyIds.has(b.id) && localById.has(b.id)) ? localById.get(b.id) : b);
// Una base nueva todavía sin guardar no está en el servidor: se conserva.
localNow.forEach(b => {
if (dirtyIds.has(b.id) && !serverIdSet.has(b.id) && !pending.has(b.id)) merged.push(b);
});
const next = { ...prev, [d]: merged };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
if (updaters) showThrottledSyncMsg(window.t('↻ Bases actualizadas por {u}').replace('{u}', updaters));
};
const poll = async () => {
// Pestaña en segundo plano: no gastar peticiones (el servidor limita por IP).
if (typeof document !== 'undefined' && document.hidden) return;
if (planPollInFlight.current) return; // nunca encolar dos ciclos
planPollInFlight.current = true;
try {
const fechas = view === 'week'
? Array.from({ length: 7 }, (_, i) => shiftDate(startOfWeek(date), i))
: [date];
const t0 = Date.now();
const json = await callApi(`${API_URL}?action=sync&fechas=${fechas.join(',')}`, {}, 'sincronización', { silentSync: true });
const t1 = Date.now();
if (cancelled || !json?.ok) return;
if (json.server_time && window.calibrateFromServer) {
window.calibrateFromServer(json.server_time, t0, t1);
if (rolloverRef.current) rolloverRef.current();
}
try { await applyMachineCheck(json.machines || []); } catch (_) {}
for (const d of fechas) {
if (cancelled) break;
try { await applyBatchCheck(d, (json.batches && json.batches[d]) || []); } catch (_) {}
}
} catch (_) {
// callApi ya reportó el estado (sin conexión / 429 / sesión expirada)
} finally {
planPollInFlight.current = false;
}
};
const interval = view === 'week' ? SYNC_POLL_WEEK_MS : SYNC_POLL_DAY_MS;
const id = setInterval(poll, interval);
// Al volver a la pestaña, refrescar de inmediato en vez de esperar al próximo ciclo.
const onVisible = () => { if (!document.hidden) poll(); };
document.addEventListener('visibilitychange', onVisible);
return () => {
cancelled = true;
unifiedSyncActive.current = false;
clearInterval(id);
document.removeEventListener('visibilitychange', onVisible);
};
}, [currentUser, date, view]);
// ─ Cargar máquinas desde la BD ─
useEffect(() => {
if (!currentUser) return;
setCpCloudReady(false);
cpInitialLoadDone.current = false;
const load = async () => {
try {
const json = await callApi(`${API_URL}?action=cp_machine_list`, {}, 'cargar máquinas');
if (json?.ok && Array.isArray(json.data) && json.data.length > 0) {
savedMachineData.current = {};
machineTimestamps.current = {};
json.data.forEach(r => {
savedMachineData.current[r.machine_id] = JSON.stringify(r.machine);
machineTimestamps.current[r.machine_id] = r.updated_at;
});
setCpMachines(json.data.map(r => r.machine).filter(Boolean));
} else {
savedMachineData.current = {};
machineTimestamps.current = {};
setCpMachines([]);
}
} catch (_) {
savedMachineData.current = {};
machineTimestamps.current = {};
setCpMachines([]);
} finally {
cpInitialLoadDone.current = true;
setCpCloudReady(true);
}
};
load();
}, [currentUser]);
const deleteMachine = async (id) => {
if (!canEditCP) return;
const removed = (cpMachinesRef.current || []).find(m => m.id === id);
setCpMachines(prev => prev.filter(m => m.id !== id));
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'cp_machine_delete', machine_id: id }),
}, 'eliminar máquina');
delete savedMachineData.current[id];
delete machineTimestamps.current[id];
} catch (err) {
notifyApiError('eliminar la máquina', err);
// Revierte el borrado optimista (si el servidor no la eliminó, vuelve a mostrarse).
if (removed && err?.status !== 404) setCpMachines(prev => (prev.some(m => m.id === id) ? prev : [...prev, removed]));
}
};
// ─ Auto-expand base en curso ─
useEffect(() => {
const bases = plan[date] || [];
const running = bases.find(b => b.status === 'running');
if (running && !expanded.has(running.id)) {
setExpanded(prev => new Set([...prev, running.id]));
}
}, [date]);
// ─ Pendientes de ayer: carga y abre el modal ─
// Trae un día a `plan` si aún no está cargado (p. ej. el día anterior al 1.º de un mes).
// Bases de un día en el orden manual de la Diaria (campo `orden`).
const orderedDay = (d) => (plan[d] || [])
.map((b, i) => ({ b, i, o: (typeof b.orden === 'number' ? b.orden : i) }))
.sort((x, y) => (x.o - y.o) || (x.i - y.i)).map(x => x.b);
const ensureDayLoaded = async (d) => {
if (planRef.current[d]) return planRef.current[d];
try {
const json = await callApi(`${API_URL}?action=plan_batch_list&fecha=${d}`, {}, 'cargar día');
if (json?.ok && Array.isArray(json.data)) {
let batches = json.data.map(r => r.batch);
if (!savedBatchData.current[d]) {
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
json.data.forEach(r => {
savedBatchData.current[d][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[d][r.batch_id] = r.updated_at;
});
// Tombstones del servidor: no se muestran ni se reenvían desde el autoguardado
if (Array.isArray(json.deleted_ids) && json.deleted_ids.length > 0) {
if (!pendingBatchDeletes.current[d]) pendingBatchDeletes.current[d] = new Set();
json.deleted_ids.forEach(id => {
savedBatchData.current[d][id] = null;
pendingBatchDeletes.current[d].add(id);
});
batches = batches.filter(b => !pendingBatchDeletes.current[d].has(b.id));
}
}
setPlan(prev => (prev[d] ? prev : { ...prev, [d]: batches }));
return batches;
}
} catch (_) {}
return null;
};
const openPendingModal = async () => {
if (!canEditSafe) return;
const yesterday = shiftDate(od(), -1);
let yBases = plan[yesterday] || await ensureDayLoaded(yesterday);
if (!yBases) {
try {
const json = await callApi(`${API_URL}?action=plan_db_get&fecha=${yesterday}`, {}, 'cargar pendientes de ayer');
if (json?.ok && json.data?.batches) {
yBases = json.data.batches;
setPlan(prev => ({ ...prev, [yesterday]: yBases }));
}
} catch (_) {}
}
// Envasado es el punto de activación definitivo: una base está pendiente
// si tiene al menos un color sin checkEnvasado, sin importar su status
const pending = (yBases || []).filter(b => {
const incompleteColors = (b.colors || []).filter(c => !c.checkEM && !c.cancelled);
return incompleteColors.length > 0;
});
if (pending.length === 0) {
showToast('Sin bases pendientes del día anterior');
return;
}
setPendingModal({ yesterday, bases: pending });
};
// ─ Traer bases seleccionadas al día actual (solo colores incompletos) ─
const bringPendingBases = (selectedIds) => {
const { yesterday, bases } = pendingModal;
const selected = bases.filter(b => selectedIds.includes(b.id));
const todayBases = plan[od()] || [];
const existingOrigIds = new Set(todayBases.map(b => b.carryoverOriginalId || b.id));
const toAdd = selected.filter(b => !existingOrigIds.has(b.carryoverOriginalId || b.id));
if (toAdd.length === 0) {
showToast('Esas bases ya están en el plan de hoy');
setPendingModal(null);
return;
}
const carried = toAdd.map(b => {
// Solo traer colores sin empaquetado (checkEM=false y status!='ready'), excluyendo cancelados
const incompleteColors = (b.colors || []).filter(c => !c.checkEM && c.status !== 'ready' && !c.cancelled);
const newGL = incompleteColors.reduce((sum, c) => sum + (c.cantidad || 0), 0);
return {
...b,
id: uid('b'),
carryoverFrom: b.carryoverFrom || yesterday,
carryoverOriginalId: b.carryoverOriginalId || b.id,
status: 'planned',
cantidad: newGL || b.cantidad,
colors: incompleteColors.map(c => ({
...c,
id: uid('c'),
checkEM: false,
completedAt: null,
status: (c.checkEC || c.checkMA || c.checkEN) ? 'running' : 'pending',
})),
};
});
updatePlan(arr => [...arr, ...carried]);
const totalColores = carried.reduce((sum, b) => sum + b.colors.length, 0);
showToast(`${carried.length} base${carried.length !== 1 ? 's' : ''} traída${carried.length !== 1 ? 's' : ''} con ${totalColores} color${totalColores !== 1 ? 'es' : ''} pendiente${totalColores !== 1 ? 's' : ''}`);
setPendingModal(null);
};
const showToast = (msg, type = 'ok') => {
setToast({ msg, type });
const duration = (type === 'warn' || type === 'info') ? 5000 : 2400;
setTimeout(() => setToast(null), duration);
};
// Exponer para componentes en archivos separados (p.ej. fórmulas).
if (typeof window !== 'undefined') window.showToast = showToast;
// Orden manual estable: las bases se muestran según su campo `orden`
// (fijado al arrastrar). Las que aún no tienen `orden` conservan su
// posición actual como respaldo. Así el orden no cambia al editar/recargar.
const bases = useMemo(() => {
const arr = plan[date] || [];
return arr
.map((b, i) => ({ b, i, o: (typeof b.orden === 'number' ? b.orden : i) }))
.sort((x, y) => (x.o - y.o) || (x.i - y.i))
.map(x => x.b);
}, [plan, date]);
// Nombres de base del plan del día (para el catálogo de Fórmulas de base y el cruce del Consumo).
const dayBaseNames = useMemo(() => {
const seen = new Set(), out = [];
bases.forEach(b => { const n = (b && b.nombre != null) ? String(b.nombre).trim() : ''; if (n && !seen.has(n.toUpperCase())) { seen.add(n.toUpperCase()); out.push(n); } });
return out;
}, [bases]);
const openBaseFormula = (producto) => { setBaseFormulasCtx({ producto, from: 'consumo' }); setView('bformulas'); };
const openColorFormulaFromConsumo = (producto) => openFormulas({ producto, from: 'consumo' });
// Al renombrar un grupo, las máquinas de Control de Proceso que lo tengan
// como Operario guardan el NOMBRE anterior: se actualizan aquí para que las
// máquinas en producción sigan apuntando al mismo grupo (y sus puntos se
// otorguen bien al cerrarlas). Devuelve cuántas máquinas se actualizaron.
// LIMITACIÓN (documentada): el operario se guarda como texto (nombre), no como id de grupo.
// Solo se actualizan las máquinas CARGADAS en este navegador (todas las de cp_machine_list,
// vía cpMachinesRef con el último valor); no se reescriben los lotes ya cerrados del historial
// (conservan el nombre antiguo) ni las pantallas de otros usuarios hasta que sondeen el
// cambio. Una solución completa requiere guardar el id del grupo en la máquina y resolver el
// nombre actual al mostrar/otorgar puntos.
const renameGroupInMachines = (dept, oldName, newName) => {
const from = String(oldName || '').trim();
const to = String(newName || '').trim();
if (!from || !to || from === to) return 0;
const afecta = (m) => {
const mDept = (typeof cpOperatorDept === 'function') ? cpOperatorDept(m.type) : null;
return mDept === dept && String(m.operario || '').trim() === from;
};
const n = (cpMachinesRef.current || []).filter(afecta).length;
if (n > 0) setCpMachines(prev => (prev || []).map(m => afecta(m) ? { ...m, operario: to } : m));
// Refresca las opciones del selector de Operario con el nombre nuevo.
callApi(`${API_URL}?action=prep_operators`, {}, 'cargar operadores')
.then(json => { if (json?.ok && json.data) setOperators(json.data); })
.catch(() => showThrottledSyncMsg('⚠ No se pudieron refrescar los operadores'));
return n;
};
const filtered = useMemo(() => {
let out = bases;
if (filter.tipo !== 'all') out = out.filter(b => b.tipo === filter.tipo);
if (filter.status !== 'all') out = out.filter(b => b.status === filter.status);
if (filter.origen === 'today') out = out.filter(b => !b.carryoverFrom);
if (filter.origen === 'past') out = out.filter(b => !!b.carryoverFrom);
if (search.trim()) {
const qWords = search.toLowerCase().split(/\s+/).filter(Boolean);
out = out.filter(b => {
const haystack = [b.code, b.nombre, b.lote, b.colors.map(c => `${c.nombre} ${c.lote}`).join(' ')]
.join(' ').toLowerCase();
return qWords.every(w => haystack.includes(w));
});
}
return out;
}, [bases, filter, search]);
// Indicador "no enviado" para la vista móvil: compara el batch actual con
// el último confirmado por el servidor (mismo ref que usa el autoguardado
// granular de arriba), sin duplicar la lógica de guardado/():
const isBasePending = (base) => {
const serverDay = savedBatchData.current[date] || {};
const entry = serverDay[base.id];
if (entry === undefined) return false; // aún no se intentó guardar (recién cargado)
return entry !== null && JSON.stringify(base) !== entry;
};
const toggleExpand = (id) => {
setExpanded(prev => {
const next = new Set(prev);
if (next.has(id)) next.delete(id); else next.add(id);
return next;
});
};
const updatePlan = (updater) => {
const d = od();
setPlan(prev => {
const dayBases = prev[d] || [];
return { ...prev, [d]: updater(dayBases) };
});
};
// ─ Orden manual de bases (arrastrar y soltar) ─
const [dragBaseId, setDragBaseId] = useState(null);
const [dragOverBaseId, setDragOverBaseId] = useState(null);
// Solo se permite reordenar cuando no hay filtros/búsqueda activos, para no
// reacomodar un subconjunto y dejar el resto en un orden ambiguo.
const canReorder = canEditSafe
&& filter.tipo === 'all' && filter.status === 'all' && filter.origen === 'all'
&& !search.trim();
const reorderBases = (draggedId, targetId) => {
if (!draggedId || draggedId === targetId) return;
setPlan(prev => {
const arr = prev[date] || [];
const ordered = arr
.map((b, i) => ({ b, i, o: (typeof b.orden === 'number' ? b.orden : i) }))
.sort((x, y) => (x.o - y.o) || (x.i - y.i))
.map(x => x.b);
const from = ordered.findIndex(b => b.id === draggedId);
if (from < 0) return prev;
const [moved] = ordered.splice(from, 1);
const to = ordered.findIndex(b => b.id === targetId);
if (to < 0) return prev;
ordered.splice(to, 0, moved);
// Reasignar `orden` secuencial; al cambiar el JSON de cada base, el
// autoguardado por batches la persiste en la nube.
const byId = {};
ordered.forEach((b, idx) => { byId[b.id] = idx; });
return {
...prev,
[date]: arr.map(b => (byId[b.id] !== undefined ? { ...b, orden: byId[b.id] } : b)),
};
});
};
const onBaseDragStart = (id) => setDragBaseId(id);
const onBaseDragEnter = (id) => setDragOverBaseId(prev => (prev === id ? prev : id));
const onBaseDrop = (id) => {
reorderBases(dragBaseId, id);
setDragBaseId(null);
setDragOverBaseId(null);
};
const onBaseDragEnd = () => { setDragBaseId(null); setDragOverBaseId(null); };
// ─ BASE CRUD ─
const saveBase = (data) => {
if (!canEditSafe) return;
if (data.id) {
// Se fusionan SOLO los campos editados del formulario sobre la base ACTUAL del plan
// (updatePlan recibe el estado vigente). Nunca se escribe `colors` ni campos de avance
// (checks, status de avance...) con la copia vieja que tenía abierto el modal.
const { id: baseId, colors: _ignoredColors, ...patch } = data;
updatePlan(arr => arr.map(b => b.id === baseId ? { ...b, ...patch } : b));
showToast('Base actualizada');
} else {
const dayArr = plan[od()] || [];
const maxO = dayArr.reduce((m, b) => Math.max(m, typeof b.orden === 'number' ? b.orden : -1), dayArr.length - 1);
const newBase = { ...data, id: uid('b'), colors: [], orden: maxO + 1 };
updatePlan(arr => [...arr, newBase]);
setExpanded(prev => new Set([...prev, newBase.id]));
showToast('Base creada');
}
setBaseModal(null);
};
const updateBase = (updated) => {
if (!canEditSafe) return;
updatePlan(arr => arr.map(b => b.id === updated.id ? updated : b));
};
// Aplica `mapDay` al plan de la fecha `dateStr`. Los efectos secundarios (persistir un día
// que no es el activo) se ejecutan FUERA del actualizador de setPlan: los actualizadores deben
// ser puros (React puede invocarlos dos veces y se duplicarían las peticiones).
// planRef se actualiza de inmediato para que dos llamadas seguidas en el mismo tick vean el
// resultado de la anterior. `isChanged(b)` identifica el batch que hay que guardar.
const patchDay = (dateStr, mapDay, isChanged) => {
const prevDay = planRef.current[dateStr] || [];
const nextDay = mapDay(prevDay);
planRef.current = { ...planRef.current, [dateStr]: nextDay };
setPlan(prev => ({ ...prev, [dateStr]: mapDay(prev[dateStr] || []) }));
if (dateStr !== date && isChanged) {
const changed = nextDay.find(isChanged);
const before = changed && prevDay.find(b => b.id === changed.id);
if (changed && changed !== before) persistBatchForOtherDate(dateStr, changed);
}
};
// Control de Proceso: cambiar la fecha carga ese día con la tabla GRANULAR (plan_batch_list),
// registrando savedBatchData/batchTimestamps; antes usaba plan_db_get (legado) y quedaba sin
// referencia de servidor para los guardados por base.
const onCpDateChange = async (newDate) => {
cpDateRef.current = newDate;
if (planRef.current[newDate] !== undefined) return;
const loaded = await ensureDayLoaded(newDate);
if (!loaded) {
showThrottledSyncMsg('⚠ No se pudo cargar la fecha de Control de Proceso');
setPlan(prev => (prev[newDate] ? prev : { ...prev, [newDate]: [] }));
}
};
// Actualiza campos de una base en cualquier fecha (para checks de control de proceso)
const onCpUpdateBase = (baseId, patch, dateStr) => {
if (!canEditSafe) return;
patchDay(dateStr, arr => arr.map(b => b.id === baseId ? { ...b, ...patch } : b), b => b.id === baseId);
};
// Callbacks de Control de Proceso (escritorio y móvil comparten la misma lógica).
const handleBaseStarted = (itemId, itemKind, dateStr, machineType) => {
if (!hasValidBackend) return;
const isInitialMachine = ['dispersor','dispersor1','dispersorp'].includes(machineType);
const isMatizacion = machineType === 'dispersor1';
const isEnvasado = machineType === 'envasado';
patchDay(dateStr, dayBases => dayBases.map(b => {
if (itemKind === 'base') {
if (b.id !== itemId) return b;
// Base asignada a máquina: solo EC en la base, no en sus colores
return {
...b,
status: b.status === 'planned' ? 'running' : b.status,
...(isInitialMachine ? { checkEC: true } : {}),
};
}
// Color asignado directo a una máquina: checks solo en ese color
if (!(b.colors || []).some(c => c.id === itemId)) return b;
return {
...b,
status: b.status === 'planned' ? 'running' : b.status,
colors: b.colors.map(c => {
if (c.id !== itemId) return c;
const setEC = isInitialMachine;
const setMA = isMatizacion && c.tipoColor === 'con_matizacion';
const setEN = isEnvasado;
const anySet = setEC || setMA || setEN;
return {
...c,
...(setEC ? { checkEC: true } : {}),
...(setMA ? { checkMA: true } : {}),
...(setEN ? { checkEN: true } : {}),
...(anySet ? { status: c.checkEM ? 'ready' : 'running' } : {}),
};
}),
};
}), itemKind === 'base' ? (b => b.id === itemId) : (b => (b.colors || []).some(c => c.id === itemId)));
};
const handleAssignmentRemoved = (itemId, itemKind, dateStr, machineType) => {
if (!hasValidBackend) return;
const isInitialMachine = ['dispersor','dispersor1','dispersorp'].includes(machineType);
const isMatizacion = machineType === 'dispersor1';
const isEnvasado = machineType === 'envasado';
patchDay(dateStr, dayBases => dayBases.map(b => {
if (itemKind === 'base') {
if (b.id !== itemId) return b;
// Base quitada de la máquina: solo se limpia EC en la base, no en sus colores
return {
...b,
...(isInitialMachine ? { checkEC: false } : {}),
status: b.status === 'running' ? 'planned' : b.status,
};
}
if (!(b.colors || []).some(c => c.id === itemId)) return b;
return {
...b,
colors: b.colors.map(c => {
if (c.id !== itemId) return c;
return {
...c,
...(isInitialMachine ? { checkEC: false } : {}),
...(isMatizacion ? { checkMA: false } : {}),
...(isEnvasado ? { checkEN: false } : {}),
};
}),
};
}), itemKind === 'base' ? (b => b.id === itemId) : (b => (b.colors || []).some(c => c.id === itemId)));
};
const handleBaseComplete = (baseId, dateStr) => {
if (!hasValidBackend) return;
patchDay(dateStr, dayBases => dayBases.map(b => b.id === baseId ? { ...b, status: 'done', checkFN: true } : b),
b => b.id === baseId);
};
const handleSetPackagingEnvasado = (colorId, dateStr, entries) => {
if (!hasValidBackend) return;
const validEntries = (entries || []).filter(e => Number(e.cantidad) > 0);
const completedAt = syncedNowIso();
patchDay(dateStr, dayBases => dayBases.map(b => {
if (!(b.colors || []).some(c => c.id === colorId)) return b;
return {
...b,
colors: b.colors.map(c => c.id === colorId ? {
...c, checkEM: true, envasadoReal: validEntries, status: 'ready', completedAt,
} : c),
};
}), b => (b.colors || []).some(c => c.id === colorId));
};
const deleteBase = async (id) => {
const d = od();
if (!canDeleteSafe) return;
if (!window.verifyDeleteKey('¿Eliminar esta base y todos sus colores?')) return;
const previousDay = planRef.current[d] || [];
const nextDay = previousDay.filter(b => b.id !== id);
// Registra como pendiente ANTES de cualquier actualización de estado
if (!pendingBatchDeletes.current[d]) pendingBatchDeletes.current[d] = new Set();
pendingBatchDeletes.current[d].add(id);
// Pone tombstone ANTES del API call para que el polling lo filtre durante el in-flight
if (!savedBatchData.current[d]) savedBatchData.current[d] = {};
const prevEntry = savedBatchData.current[d][id]; // undefined = nunca guardado en servidor
savedBatchData.current[d][id] = null;
// Actualización optimista
setPlan(prev => {
const next = { ...prev, [d]: nextDay };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
setSyncStatus('saving');
// Fase 1: Borrar del servidor (con manejo separado para no mezclar errores)
// Si el batch nunca existió en el servidor (prevEntry === undefined), plan_batch_delete
// devolverá 404 que se trata como éxito — sin API skipping para evitar datos huérfanos.
let deleteSucceeded = false;
try {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_delete', fecha: d, batch_id: id }),
}, 'eliminar base');
deleteSucceeded = true;
} catch (err) {
if (err?.status === 404) {
// No encontrada — ya fue borrada o nunca existió en el servidor
deleteSucceeded = true;
} else {
// Error real de red/auth — revertir tombstone, limpiar pending y restaurar UI
savedBatchData.current[d][id] = prevEntry;
pendingBatchDeletes.current[d]?.delete(id); // permite que el polling vuelva a mostrar el batch
setPlan(prev => {
const rollback = { ...prev, [d]: previousDay };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(rollback)); } catch (_) {}
return rollback;
});
setSyncMsg(`⚠ No se pudo eliminar: ${err?.message || 'error desconocido'}`);
setSyncStatus('error');
showToast('No se pudo eliminar en el servidor', 'err');
return;
}
}
if (deleteSucceeded) {
// Fase 2: Actualizar timestamps locales para que el polling no vuelva a detectar cambio
// Si esta llamada falla, no importa — el tombstone ya evitará que el polling restaure el batch
try {
const chkJ = await callApi(`${API_URL}?action=plan_batch_check&fecha=${d}`, {}, 'confirmar eliminación');
if (chkJ?.ok) {
batchTimestamps.current[d] = {};
(chkJ.data || []).forEach(({ batch_id, updated_at }) => {
batchTimestamps.current[d][batch_id] = updated_at;
});
}
} catch (_) {}
setSyncMsg('☁ Base eliminada en la nube');
setSyncStatus('saved');
setTimeout(() => setSyncStatus(s => s === 'saved' ? 'idle' : s), 3000);
showToast('Base eliminada');
}
};
// ─ COLOR CRUD ─
const saveColor = (baseId, colorData) => {
if (!hasValidBackend || (!canEdit && !canEditGalonaje && !canEditEnvasado && !canCheckEnvasado)) return;
updatePlan(arr => arr.map(b => {
if (b.id !== baseId) return b;
const existing = b.colors.find(c => c.id === colorData.id);
if (existing) return { ...b, colors: b.colors.map(c => c.id === colorData.id ? colorData : c) };
return { ...b, colors: [...b.colors, colorData] };
}));
setColorModalCtx(null);
showToast('Color guardado');
};
const updateColor = (baseId, color) => {
if (!hasValidBackend || (!canEdit && !canCheckEnvasado && !canEditGalonaje && !canEditEnvasado && !canCheckMatizacion)) return;
updatePlan(arr => arr.map(b => {
if (b.id !== baseId) return b;
return { ...b, colors: b.colors.map(c => c.id === color.id ? color : c) };
}));
};
// Persiste UN batch para una fecha que no es la actualmente activa en
// Diaria (donde el auto-guardado granular normal no corre, ya que solo
// observa `plan[date]`). Usado por los callbacks de Control de Proceso
// (onBaseComplete/onBaseStarted/onAssignmentRemoved/onSetPackagingEnvasado)
// cuando se trabaja una fecha distinta a la abierta en Diaria — por ejemplo,
// cerrando el empaquetado de un día anterior. Antes usaban la tabla legada
// (`plan_db_save`, sobrescribiendo TODOS los batches del día), que no
// actualiza la tabla granular que lee el resto de la app: el cambio se
// veía en pantalla pero nunca quedaba guardado, y reaparecía el valor
// anterior al recargar o pasados unos días. Guarda solo el batch afectado
// (no todo el día) para no arriesgar sobrescribir cambios de otros batches
// que este cliente no tenga sincronizados (esa fecha no recibe polling).
const persistBatchForOtherDate = (dateStr, batch) => {
if (!batch) return;
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'plan_batch_save', fecha: dateStr, batch_id: batch.id, batch_data: batch }),
}, 'guardar control de proceso').then(r => {
if (!savedBatchData.current[dateStr]) savedBatchData.current[dateStr] = {};
if (r?.tombstoned) {
// El servidor lo tiene como eliminado: se quita del plan local.
savedBatchData.current[dateStr][batch.id] = null;
if (!pendingBatchDeletes.current[dateStr]) pendingBatchDeletes.current[dateStr] = new Set();
pendingBatchDeletes.current[dateStr].add(batch.id);
setPlan(prev => ({ ...prev, [dateStr]: (prev[dateStr] || []).filter(b => b.id !== batch.id) }));
} else {
savedBatchData.current[dateStr][batch.id] = JSON.stringify(batch);
if (r?.updated_at) {
if (!batchTimestamps.current[dateStr]) batchTimestamps.current[dateStr] = {};
batchTimestamps.current[dateStr][batch.id] = r.updated_at;
}
}
}).catch(err => notifyApiError('guardar el cambio de control de proceso', err));
};
const deleteColor = (baseId, colorId) => {
if (!canDeleteSafe) return;
if (!window.verifyDeleteKey('¿Eliminar este color?')) return;
updatePlan(arr => arr.map(b => {
if (b.id !== baseId) return b;
return { ...b, colors: b.colors.filter(c => c.id !== colorId) };
}));
};
// ─ Listen for edit events ─
useEffect(() => {
// En Lista las bases de todos los días del mes están en `plan`; en Diaria solo las del día.
const pools = () => (view === 'lista' ? Object.entries(planRef.current || {}) : [[date, bases]]);
const onEditBase = (e) => {
if (!canEditSafe) return;
for (const [d, arr] of pools()) {
const b = (arr || []).find(x => x.id === e.detail);
if (b) { opDateRef.current = d; setBaseModal({ base: b }); break; }
}
};
const onEditColor = (e) => {
// Permitir abrir el modal si puede editar completo O si tiene permisos de envasado
if (!hasValidBackend || (!canEdit && !canEditGalonaje && !canEditEnvasado && !canCheckEnvasado)) return;
for (const [d, arr] of pools()) {
for (const b of (arr || [])) {
const c = (b.colors || []).find(x => x.id === e.detail);
if (c) { opDateRef.current = d; setColorModalCtx({ baseId: b.id, color: c, baseNombre: b.nombre || '' }); return; }
}
}
};
window.addEventListener('edit-base', onEditBase);
window.addEventListener('edit-color', onEditColor);
return () => {
window.removeEventListener('edit-base', onEditBase);
window.removeEventListener('edit-color', onEditColor);
};
}, [bases, canEdit, view, date]);
// ─ Duplicar día anterior ─
const duplicateYesterday = async () => {
if (!canDuplicateSafe) return;
const cur = od();
const yesterday = shiftDate(cur, -1);
const yBases = plan[yesterday] || await ensureDayLoaded(yesterday);
if (!yBases || !yBases.length) { showToast('Sin plan ayer', 'err'); return; }
if ((plan[cur] || []).length && !window.verifyDeleteKey('Reemplazar el plan de hoy con el de ayer eliminará las bases actuales de hoy.')) return;
// Clon "limpio": sin avances del día anterior (checks EC/MA/EN/EM/FN, envasado y galonaje
// reales, marcas de finalización ni referencias de arrastre).
const cloned = yBases.map(b => {
const { carryoverFrom, carryoverOriginalId, completedAt: _bc, ...baseRest } = b;
return {
...baseRest, id: uid('b'), status: 'planned', operador: '',
checkEC: false, checkMA: false, checkEN: false, checkEM: false, checkFN: false,
colors: (b.colors || []).map(c => {
const { envasadoReal, glReal, completedAt, ...colorRest } = c;
return {
...colorRest, id: uid('c'), status: 'pending', completedAt: null,
checkEC: false, checkMA: false, checkEN: false, checkEM: false,
};
}),
};
});
opDateRef.current = cur; // tras el await, vuelve a fijar el día destino
updatePlan(() => cloned);
showToast(`Plan duplicado (${cloned.length} bases)`);
};
// ─ Exportar ─
const onExport = () => {
if (!canExport) return;
const f = fmtDate(date);
const txt = [`PRODUCCIÓN ${f.dowFull} ${f.day} ${f.month} ${f.year}`, ''];
bases.forEach(b => {
txt.push(`${b.code} — ${b.nombre} | ${b.cantidad} ${b.unit} | Lote ${b.lote}`);
b.colors.forEach(c => txt.push(` · ${c.nombre} | ${c.cantidad} ${c.unit} | ${c.lote} | ${c.notas || ''}`));
txt.push('');
});
const blob = new Blob([txt.join('\n')], { type: 'text/plain' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url; a.download = `produccion-${date}.txt`; a.click();
URL.revokeObjectURL(url);
showToast('Exportado');
};
const savePrintProfile = (name) => {
const updated = [
...printProfiles.filter(p => p.name !== name),
{ name, settings: { ...printSettings } },
].sort((a, b) => a.name.localeCompare(b.name));
setPrintProfiles(updated);
try { localStorage.setItem(PRINT_PROFILES_KEY, JSON.stringify(updated)); } catch (_) {}
};
const loadPrintProfile = (name) => {
const p = printProfiles.find(p => p.name === name);
if (p) setPrintSettings({ ...DEFAULT_PRINT_SETTINGS, ...p.settings });
};
const deletePrintProfile = (name) => {
const updated = printProfiles.filter(p => p.name !== name);
setPrintProfiles(updated);
try { localStorage.setItem(PRINT_PROFILES_KEY, JSON.stringify(updated)); } catch (_) {}
};
// Genera y abre la ventana de impresión de la vista diaria con las bases dadas.
const printDailyReport = (basesToPrint, emphIds, includeColors = true, forDate = date) => {
const html = buildDailyPlanReport(basesToPrint, forDate, new Set(emphIds || []), includeColors);
const win = window.open('', '_blank', 'width=940,height=720');
if (!win) { showToast('Permita las ventanas emergentes para imprimir', 'err'); return; }
try {
win.document.write(html);
win.document.close();
} catch (err) {
try { win.close(); } catch (_) {}
showToast('No se pudo generar el informe de impresión', 'err');
return;
}
setTimeout(() => { try { win.focus(); win.print(); } catch (_) {} }, 600);
};
const onPrint = () => {
if (!canExport) return;
// Vista diaria: primero permitir seleccionar qué bases imprimir
// (evita reimprimir bases que ya se imprimieron). Otras vistas conservan
// la impresión del DOM.
if (view === 'lista') { window.dispatchEvent(new CustomEvent('lista-print')); return; }
if (view === 'day') {
if (!bases.length) { showToast('No hay bases para imprimir', 'err'); return; }
setPrintSelectModal(true);
return;
}
document.body.classList.add('print-mode');
setExpanded(new Set(bases.map(b => b.id)));
setTimeout(() => window.print(), 120);
};
useEffect(() => {
const cleanupPrintMode = () => document.body.classList.remove('print-mode');
window.addEventListener('afterprint', cleanupPrintMode);
return () => window.removeEventListener('afterprint', cleanupPrintMode);
}, []);
useEffect(() => {
const handler = (e) => setLang(e.detail.lang);
window.addEventListener('sp_lang_change', handler);
return () => window.removeEventListener('sp_lang_change', handler);
}, []);
useEffect(() => {
let el = document.getElementById('verona-print-overrides');
if (!el) {
el = document.createElement('style');
el.id = 'verona-print-overrides';
document.head.appendChild(el);
}
el.textContent = buildPrintCSS(printSettings);
try { localStorage.setItem(PRINT_SETTINGS_KEY, JSON.stringify(printSettings)); } catch (_) {}
}, [printSettings]);
// ─ Refresh manual desde la nube ─
const [refreshing, setRefreshing] = useState(false);
const refreshFromCloud = async () => {
if (refreshing) return;
setRefreshing(true);
try {
const datesToFetch = view === 'week'
? Array.from({ length: 7 }, (_, i) => shiftDate(startOfWeek(date), i))
: [date];
for (const d of datesToFetch) {
try {
const json = await callApi(`${API_URL}?action=plan_batch_list&fecha=${d}`, {}, 'refrescar planificación');
if (json?.ok && Array.isArray(json.data)) {
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
json.data.forEach(r => {
savedBatchData.current[d][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[d][r.batch_id] = r.updated_at;
});
const pending = pendingBatchDeletes.current[d] || new Set();
const batches = json.data.map(r => r.batch).filter(b => !pending.has(b.id));
setPlan(prev => {
const next = { ...prev, [d]: batches };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
}
} catch (_) {}
}
setSyncMsg('☁ Sincronizado');
} finally {
setRefreshing(false);
}
};
const clearAllData = async () => {
try {
// Block auto-save immediately so no stale closure re-saves machines after refs are cleared
setCpCloudReady(false);
const json = await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'db_clear_all' }),
}, 'limpiar base de datos');
if (json?.ok) {
savedBatchData.current = {};
batchTimestamps.current = {};
savedMachineData.current = {};
machineTimestamps.current = {};
pendingBatchDeletes.current = {};
setPlan({});
setCpMachines([]);
try { localStorage.removeItem(PLAN_STORAGE_KEY); } catch (_) {}
showToast('Base de datos limpiada correctamente');
setSyncMsg('☁ Base de datos vaciada');
setSyncStatus('saved');
setTimeout(() => setSyncStatus(s => s === 'saved' ? 'idle' : s), 4000);
// Re-enable auto-save after state settles
setTimeout(() => setCpCloudReady(true), 500);
return true;
}
} catch (err) {
showToast(`Error al limpiar: ${err?.message || 'error desconocido'}`, 'err');
}
setCpCloudReady(true);
return false;
};
return (
window.SP_SET_LANG(lang === 'ar' ? 'es' : 'ar')}
onMenuToggle={() => setNavOpen(o => !o)}
onPrint={onPrint}
onExport={onExport}
onConfig={isAdmin ? () => setShowConfig(true) : null}
onUsers={isAdmin ? () => setShowUsers(true) : null}
/>
{isMobile ? (
setNavOpen(false)}
currentUser={currentUser}
showMatizacion={isAdmin || canCheckMatizacion}
showEnvasado={isAdmin || canAccessEnvasadoTab}
showFacturacion={canAccessFacturacion}
showDay={hasFullAccess || soloDiariaEmpaque}
showWeek={hasFullAccess}
showLista={hasFullAccess}
showControl={hasFullAccess || canEditCP}
showSupervisor={hasFullAccess}
showEquipos={hasFullAccess || canAccessEquipos}
showMantenimiento={canAccessMantenimiento}
showBackorden={canAccessBackorden}
showPreparadores={canAccessPreparadores}
showConsumo={canAccessConsumo}
showBaseFormulas={canAccessConsumo}
showFormulas={hasFullAccess || canCheckMatizacion}
showPersonal={hasPersonalAccess}
showHistorial={hasFullAccess}
/>
) : (
setNavOpen(false)}
currentUser={currentUser}
showMatizacion={isAdmin || canCheckMatizacion}
showEnvasado={isAdmin || canAccessEnvasadoTab}
showDay={hasFullAccess || soloDiariaEmpaque}
showWeek={hasFullAccess}
showLista={hasFullAccess}
showControl={hasFullAccess || canEditCP}
showSupervisor={hasFullAccess}
showEquipos={hasFullAccess || canAccessEquipos}
showMantenimiento={canAccessMantenimiento}
showBackorden={canAccessBackorden}
showPreparadores={canAccessPreparadores}
/>
)}
{!hasValidBackend && (
No se puede guardar: {backendMsg}
)}
{view === 'day' && isMobile && (
{})}
canToggleEnvasado={(canCheckEnvasado || canEdit) && hasValidBackend}
canEditColor={!soloDiariaEmpaque}
onAddBase={canEditSafe ? () => setBaseModal({ base: null }) : null}
onDuplicate={canDuplicateSafe ? duplicateYesterday : null}
onPending={canEditSafe ? openPendingModal : null}
onEnvasadoSummary={() => setShowEnvasadoSummary(true)}
onConsumo={canAccessConsumo ? () => { setBackTo('day'); setView('consumo'); } : null}
onBaseFormulas={canAccessConsumo ? () => { setBaseFormulasCtx(null); setBackTo('day'); setView('bformulas'); } : null}
canEditSafe={canEditSafe}
canDuplicateSafe={canDuplicateSafe}
canDeleteSafe={canDeleteSafe}
onEditBase={(b) => setBaseModal({ base: b })}
onCancelBase={(baseId, restore) => {
setPlan(prev => {
const updated = (prev[date] || []).map(x =>
x.id === baseId ? { ...x, status: restore ? 'planned' : 'cancelled' } : x
);
return { ...prev, [date]: updated };
});
}}
onDeleteBase={(id) => deleteBase(id)}
isBasePending={isBasePending}
/>
)}
{view === 'day' && !isMobile && (
<>
setBaseModal({ base: null }) : null}
onDuplicate={canDuplicateSafe ? duplicateYesterday : null}
onPending={canEditSafe ? openPendingModal : null}
onEnvasadoSummary={() => setShowEnvasadoSummary(true)}
onConsumo={canAccessConsumo ? () => setView('consumo') : null}
onBaseFormulas={canAccessConsumo ? () => { setBaseFormulasCtx(null); setView('bformulas'); } : null}
/>
{filtered.length === 0 && bases.length === 0 && (
📋
Sin planificación para este día
{canEditSafe ? (
<>
Empieza agregando una base de producción, o duplica el plan del día anterior.
{canDuplicateSafe && Duplicar día anterior }
setBaseModal({ base: null })}> Nueva Base
>
) : (
No hay producción planificada para este día.
)}
)}
{filtered.length === 0 && bases.length > 0 && (
🔍
Sin resultados
No hay bases que coincidan con los filtros aplicados.
)}
{filtered.map(b => (
toggleExpand(b.id)}
reorderable={canReorder}
isDragging={dragBaseId === b.id}
isDragOver={dragOverBaseId === b.id && dragBaseId !== b.id}
onBaseDragStart={onBaseDragStart}
onBaseDragEnter={onBaseDragEnter}
onBaseDrop={onBaseDrop}
onBaseDragEnd={onBaseDragEnd}
onUpdate={canEditSafe ? updateBase : (() => {})}
onDelete={canDeleteSafe ? (() => deleteBase(b.id)) : null}
onAddColor={canEditSafe ? ((bid) => { const b = bases.find(x => x.id === bid); setColorModalCtx({ baseId: bid, color: null, baseNombre: b?.nombre || '' }); }) : null}
onUpdateColor={((canEdit || canCheckEnvasado) && hasValidBackend) ? updateColor : (() => {})}
onDeleteColor={canDeleteSafe ? deleteColor : null}
canToggleEnvasado={(canCheckEnvasado || canEdit) && hasValidBackend}
canEditColor={!soloDiariaEmpaque}
onCancelBase={canEditSafe ? (baseId, restore) => {
setPlan(prev => {
const updated = (prev[date] || []).map(x =>
x.id === baseId ? { ...x, status: restore ? 'planned' : 'cancelled' } : x
);
return { ...prev, [date]: updated };
});
} : null}
/>
))}
{filtered.length > 0 && canEditSafe && (
setBaseModal({ base: null })}>
Agregar otra base de producción
)}
>
)}
{view === 'lista' && window.ListaView && (
loadListMonth(listMonth)}
practice={!!(window.spPracticeOn && window.spPracticeOn())}
machineBaseIds={machineBaseIds}
expanded={expanded}
onToggle={toggleExpand}
actOn={actOn}
perms={{
canEdit: canEditSafe, canDelete: canDeleteSafe, canDuplicate: canDuplicateSafe,
canColor: (canEdit || canCheckEnvasado) && hasValidBackend,
canToggleEnvasado: (canCheckEnvasado || canEdit) && hasValidBackend,
canEditColor: !soloDiariaEmpaque, canConsumo: canAccessConsumo, canExport,
}}
actions={{
updateBase, deleteBase, updateColor, deleteColor,
addBase: () => setBaseModal({ base: null }),
addColor: (bid, d) => { const b = (plan[d] || []).find(x => x.id === bid); setColorModalCtx({ baseId: bid, color: null, baseNombre: b?.nombre || '' }); },
cancelBase: (baseId, restore) => updatePlan(arr => arr.map(x => x.id === baseId ? { ...x, status: restore ? 'planned' : 'cancelled' } : x)),
pending: openPendingModal,
duplicate: duplicateYesterday,
envasado: (d) => setEnvasadoDay(d),
consumo: (d) => goToDay(d, 'consumo', 'lista'),
baseFormulas: (d) => { setBaseFormulasCtx(null); goToDay(d, 'bformulas', 'lista'); },
openDay: (d) => goToDay(d, 'day'),
print: (d) => setListPrintDay(d),
}}
/>
)}
{view === 'matizacion' && (
{
const base = bases.find(b => b.id === baseId);
const color = base?.colors.find(c => c.id === colorId);
if (color) {
const next = (val === undefined) ? !color.checkMA : !!val;
updateColor(baseId, { ...color, checkMA: next });
}
} : null}
canMark={canCheckMatizacion && hasValidBackend}
onShowHistorial={() => { setHistorialFrom('matizacion'); setView('historial'); }}
onOpenPersonal={hasPersonalAccess ? (() => openPersonal('matizacion', 'matizacion')) : null}
formulas={formulas}
canEditFormula={canEditFormula}
onOpenFormulas={openFormulas}
/>
)}
{view === 'formulas' && (
setView(formulasCtx?.from || 'matizacion')}
/>
)}
{view === 'consumo' && canAccessConsumo && (
setView(backTo)}
backLabel={backTo === 'lista' ? 'Volver a Lista' : 'Volver a Diaria'}
onLoadFormula={canEditBaseFormula ? openBaseFormula : null}
onLoadColorFormula={canEditFormula ? openColorFormulaFromConsumo : null}
/>
)}
{view === 'bformulas' && canAccessConsumo && (
setView(baseFormulasCtx?.from === 'consumo' ? 'consumo' : backTo)}
/>
)}
{view === 'envasado' && (
{ setHistorialFrom('envasado'); setView('historial'); }}
onOpenPersonal={hasPersonalAccess ? (() => openPersonal('envasado', 'envasado')) : null}
onOpenFacturacion={canAccessFacturacion ? (() => setView('envasado_facturacion')) : null}
/>
)}
{view === 'envasado_facturacion' && canAccessFacturacion && (
setView('envasado')}
/>
)}
{view === 'preparadores' && (
openPersonal('preparadores', 'preparadores')) : null}
/>
)}
{view === 'noaccess' && (
🔒
Sin permiso
Tu usuario no tiene acceso a esta sección. Pide al administrador que te asigne los permisos necesarios.
)}
{view === 'personal' && (() => {
const pctx = personalCtx || DEFAULT_PERSONAL_CTX;
const BACK_LABELS = {
matizacion: 'Volver a Matización',
envasado: 'Volver a Envasado',
preparadores: 'Volver a Preparadores',
supervisor: 'Volver a Supervisor',
};
return (
setView(pctx.from || 'preparadores')}
/>
);
})()}
{view === 'week' && (
)}
{view === 'control' && isMobile && (
)}
{view === 'control' && !isMobile && (
setBaseModal({ base: null }) : null}
onAddColor={canEditSafe ? (bid) => {
const b = Object.values(plan).flat().find(x => x && x.id === bid);
setColorModalCtx({ baseId: bid, color: null, baseNombre: b?.nombre || '' });
} : null}
onCancelBase={canEditSafe ? (baseId, restore = false, dateStr) => {
// La base pertenece a la fecha que muestra Control de Proceso (cpDate), que puede
// ser distinta de la fecha de la App: se usa la que notificó onCpDateChange.
const d = dateStr || cpDateRef.current || date;
const newStatus = restore ? 'planned' : 'cancelled';
patchDay(d, arr => arr.map(b => b.id === baseId ? { ...b, status: newStatus } : b),
b => b.id === baseId);
} : null}
onUpdateBase={canEditSafe ? onCpUpdateBase : null}
onShowHistorial={() => { setHistorialFrom('control'); setView('historial'); }}
operators={operators}
/>
)}
{view === 'historial' && (() => {
// Configuración del historial según el área desde la que se abrió
const HIST_AREAS = {
control: { types: null, backView: 'control', backLabel: 'Volver al Control', area: '' },
matizacion: { types: ['dispersor1'], backView: 'matizacion', backLabel: 'Volver a Matización', area: 'Matización' },
envasado: { types: ['envasado', 'empaquetadora'], backView: 'envasado', backLabel: 'Volver a Envasado', area: 'Envasado' },
};
const cfg = HIST_AREAS[historialFrom] || HIST_AREAS.control;
return (
setView(cfg.backView)}
/>
);
})()}
{view === 'supervisor' && (
openPersonal('preparadores', 'supervisor', true)) : null}
/>
)}
{view === 'equipos' && (
)}
{view === 'mantenimiento' && canAccessMantenimiento && window.MantenimientoView && (
setView('equipos')}
/>
)}
{view === 'backorden' && canAccessBackorden && (
)}
{showEnvasadoSummary && (
setShowEnvasadoSummary(false)}
/>
)}
{envasadoDay && (
setEnvasadoDay(null)}
/>
)}
{listPrintDay && (
{
const set = new Set(ids);
printDailyReport(orderedDay(listPrintDay).filter(b => set.has(b.id)), emphIds, includeColors, listPrintDay);
setListPrintDay(null);
}}
onClose={() => setListPrintDay(null)}
/>
)}
{pendingModal && canEditSafe && (
setPendingModal(null)}
/>
)}
{baseModal && canEditSafe && (
setBaseModal(null)} />
)}
{colorModalCtx && canEditSafe && (
saveColor(colorModalCtx.baseId, c)}
onClose={() => setColorModalCtx(null)}
canEditEnvasado={canEditEnvasado ? undefined : false}
canEditGalonaje={canEditGalonaje ? undefined : false}
canCheckEnvasado={canCheckEnvasado}
/>
)}
{showCatalog && isAdminSafe && (
setShowCatalog(false)}
/>
)}
{showConfig && isAdmin && (
{ setShowConfig(false); setShowCatalog(true); } : null}
onClose={() => setShowConfig(false)}
/>
)}
{showUsers && isAdmin && (
setShowUsers(false)} />
)}
{showClearDb && isAdminSafe && (
{
const ok = await clearAllData();
if (ok) setShowClearDb(false);
}}
onClose={() => setShowClearDb(false)}
/>
)}
{printSelectModal && (
{
const set = new Set(ids);
printDailyReport(bases.filter(b => set.has(b.id)), emphIds, includeColors);
setPrintSelectModal(false);
}}
onClose={() => setPrintSelectModal(false)}
/>
)}
{showPrintSettings && (
setShowPrintSettings(false)}
/>
)}
{toast && {toast.msg}
}
{syncMsg && {syncMsg}
}
);
}
// ─── PANTALLA DE LOGIN ─────────────────────────────────────────────────────────
function LoginForm({ onLogin, onPlantDenied }) {
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [error, setError] = useState('');
const [loading, setLoading] = useState(false);
const submit = async (e) => {
e.preventDefault();
setLoading(true);
setError('');
try {
const j = await readApiJson(await apiFetch(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'login', email: email.trim(), password }),
}));
if (j.user) {
onLogin(j.user);
} else {
setError(j.error || 'Credenciales inválidas');
}
} catch (err) {
if (err?.data?.plant_denied && onPlantDenied) {
onPlantDenied({ plant: err.data.plant, allowed: err.data.allowed_plants || [] });
return;
}
setError(err?.message || 'Error de conexión. Intenta de nuevo.');
} finally {
setLoading(false);
}
};
return (
VERONA COLOR PAINTS
{window.t('Sistema de Planificación de Producción')}
);
}
// ─── PANTALLA: SIN ACCESO A ESTA PLANTA ────────────────────────────────────────
function PlantAccessScreen({ plant, allowed, onLogout }) {
const PLANT_LABEL = { caucho: 'Caucho', esmalte: 'Esmalte' };
const cur = (plant || window.SP_PLANT || 'caucho').toLowerCase();
const list = (Array.isArray(allowed) ? allowed : []).filter(p => p && p !== cur);
return (
VERONA COLOR PAINTS
Sin acceso a la planta {PLANT_LABEL[cur] || cur.toUpperCase()}
Tu cuenta no está habilitada para esta planta. Pide al administrador que te dé acceso,
{list.length ? ' o entra a la planta que sí tienes asignada:' : ' o cierra sesión.'}
{list.length > 0 && (
)}
Cerrar sesión
);
}
// ─── RAÍZ CON AUTENTICACIÓN ────────────────────────────────────────────────────
function RootApp() {
const [currentUser, setCurrentUser] = useState(null);
const [authLoading, setAuthLoading] = useState(true);
const [plantDenied, setPlantDenied] = useState(null); // { plant, allowed } | null
useEffect(() => {
apiFetch(`${API_URL}?action=session`)
.then(readApiJson)
.then(j => { setCurrentUser(j.user || null); })
.catch(err => {
if (err?.data?.plant_denied) {
setPlantDenied({ plant: err.data.plant, allowed: err.data.allowed_plants || [] });
}
})
.finally(() => setAuthLoading(false));
}, []);
const handleLogout = async () => {
try {
await apiFetch(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'logout' }),
});
} catch (_) {}
setCurrentUser(null);
setPlantDenied(null);
};
if (authLoading) {
return (
);
}
if (plantDenied) {
return ;
}
if (!currentUser) {
return ;
}
return ;
}
ReactDOM.createRoot(document.getElementById('root')).render( );