// ════════════════════════════════════════════ // 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) => `
${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)}
Verona Color Paints
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 && }
) : (

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 && ( )}
)} {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 && (