// ════════════════════════════════════════════
// 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;
const SYNC_MSG_THROTTLE_MS = 10000;
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 MOLIENDAS_STORAGE_KEY = 'sp_moliendas_v1';
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)));
const esc = s => String(s == null ? '' : s).replace(/[&<>]/g, c => ({ '&':'&', '<':'<', '>':'>' }[c]));
// Envasado (plan) como texto agrupado por marca
const ENV_LABEL = { cu4:'CU·4', cu7:'CU·7', gl:'GL', ku:'CUÑ', p4:'4L', 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','cu7','gl','ku','p4','pl','pm'].filter(t => tot[t] > 0).map(t => `${tot[t]} ${ENV_LABEL[t]}`).join(', ');
return pills ? `${esc(brand)} ${pills}` : '';
}).filter(Boolean);
return rows.length ? rows.join(' ') : '— ';
};
// Totales generales
const allColors = list.reduce((s, b) => s + (b.colors ? b.colors.length : 0), 0);
const totPlan = list.reduce((s, b) => s + (b.colors || []).reduce((a, c) => a + (c.cantidad || 0), 0), 0);
const totReal = list.reduce((s, b) => s + (b.colors || []).reduce((a, c) => a + (c.glReal || 0), 0), 0);
const th = (txt, right) => `
${txt} `;
const card = (num, label) =>
``;
const section = (base) => {
const colors = base.colors || [];
const unit = base.unit || 'GL';
const cancelled = base.status === 'cancelled';
// Base marcada manualmente para imprimir con la letra oscurecida / resaltada.
const emph = emphSet.has(base.id);
const nameColor = emph ? '#000' : '#1a1a1a'; // texto de color más oscuro
const loteColor = emph ? '#111' : '#555'; // lote menos apagado
const nameWeight = emph ? 800 : 700;
const bPlan = colors.reduce((a, c) => a + (c.cantidad || 0), 0);
const bReal = colors.reduce((a, c) => a + (c.glReal || 0), 0);
const meta = [
base.tipo ? esc(base.tipo) : '',
base.lote ? `Lote ${esc(base.lote)}` : '',
base.linea ? esc(base.linea) : '',
`${colors.length} color${colors.length !== 1 ? 'es' : ''}`,
].filter(Boolean).join(' · ');
const rows = colors.length ? colors.map((c, idx) => {
const isCanc = !!c.cancelled;
const nameExtra = c.tipoColor === 'con_matizacion' ? ' C/Mat ' : '';
const cancTag = isCanc ? ' ✕ CANCELADO ' : '';
return `
${esc(c.nombre) || '—'} ${nameExtra}${cancTag}
${esc(c.lote) || '—'}
${c.cantidad > 0 ? fmtGL(c.cantidad) : '—'}
${c.glReal > 0 ? fmtGL(c.glReal) : '—'}
${fmtEnv(c.envasado)}
`;
}).join('') : `Sin colores en esta base. `;
return `
${esc(base.code)} ${esc(base.nombre)}${cancelled ? ' — CANCELADA' : ''}
${meta}
${withColors ? `
${th('Color')}${th('Lote')}${th('GL Plan', true)}${th('GL Real', true)}${th('Envasado')}
${rows}
Total base
${bPlan > 0 ? fmtGL(bPlan) : '—'} ${unit}
${bReal > 0 ? fmtGL(bReal) : '—'} ${unit}
` : `
Galonaje base
Plan: ${bPlan > 0 ? fmtGL(bPlan) : '—'} ${unit}
Real: ${bReal > 0 ? fmtGL(bReal) : '—'} ${unit}
`}
`;
};
return `
Planificación Diaria ${esc(date)}
PLANIFICACIÓN DIARIA DE PRODUCCIÓN — ${dateStr}
Dirigido al: Departamento de Producción
Generado: ${nowStr}
Fecha: ${esc(date)}
Control de Proceso:
Control Gerente de Planta:
${card(list.length, 'Bases planificadas')}
${card(allColors, 'Colores')}
${card(fmtGL(totPlan), 'GL Planificados')}
${card(fmtGL(totReal), 'GL Reales')}
${list.length
? list.map(section).join('')
: 'No hay bases planificadas para esta fecha.
'}
Firma Control de Proceso:
Nombre y sello
Firma Gerente de Planta:
Nombre y sello
Sistema de Planificación — VERONA COLOR PAINTS — ${esc(date)}
`;
}
// Fetch wrapper that always includes session credentials
function apiFetch(url, opts = {}) {
return fetch(url, { credentials: 'include', ...opts });
}
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);
}
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]);
const [view, setView] = useState('day');
const [personalCtx, setPersonalCtx] = useState(null); // { dept, from, allowDeptSwitch } | null
const openPersonal = (dept, from, allowDeptSwitch = false) => {
setPersonalCtx({ dept, from, allowDeptSwitch });
setView('personal');
};
const [date, setDate] = useState(todayStr());
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 [cpMachines, setCpMachines] = useState([]);
const [cpCloudReady, setCpCloudReady] = useState(false);
const [cpTick, setCpTick] = useState(0);
const [pendingModal, setPendingModal] = useState(null);
const [showEnvasadoSummary, setShowEnvasadoSummary] = useState(false);
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 [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 handleEquiposChange = (next) => {
setEquipos(prev => {
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(() => {});
}
});
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(() => {});
}
});
return next;
});
};
const [moliendas, setMoliendas] = useState(() => {
try {
const raw = localStorage.getItem(MOLIENDAS_STORAGE_KEY);
if (raw) return JSON.parse(raw);
} catch (_) {}
return [];
});
const handleMoliendasChange = (next) => {
setMoliendas(prev => {
try { localStorage.setItem(MOLIENDAS_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
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: 'molienda_save', molienda_id: id, data }),
}, 'guardar molienda').catch(() => {});
}
});
prev.forEach(e => {
if (!nextIds.has(e.id)) {
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'molienda_delete', molienda_id: e.id }),
}, 'eliminar molienda').catch(() => {});
}
});
return next;
});
};
// Registrar molienda en inventario al finalizar un molino en Control de Proceso
const handleMoliendaFromCP = (machine) => {
const asg = machine.assignments || [];
const src = asg.find(a => a.kind === 'molienda') || asg.find(a => a.kind === 'base') || {};
const producto = (src.nombre || machine.name || 'Molienda').trim();
const lote = (src.lote || machine.lote || '').trim();
const origen = 'cp:' + machine.id + ':' + (lote || producto);
if (moliendas.some(m => m.origen === origen)) return;
const rec = {
id: 'mol_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7),
// La molienda se lleva en KILOS: el peso final cargado en el molino manda.
// Si no se cargó, se cae a la cantidad de la asignación (que ya viene en Kg);
// NO se usa la cantidad del batch, que está en galones.
producto, lote,
cantidad: parseFloat(machine.pesoFinalKg) || parseFloat(src.cantidad) || 0,
unidad: 'Kg',
estado: 'lista', consumido: 0, fecha: machine.fecha || cpCaracasDateStr(),
responsable: currentUser?.name || currentUser?.email || '',
molino: machine.name || machine.code || '',
notas: 'Generada al finalizar el molino en Control de Proceso',
origen, createdAt: new Date().toISOString(),
};
handleMoliendasChange([rec, ...moliendas]);
showToast('Molienda registrada en inventario');
};
// Registrar molienda en inventario al marcar terminada la molienda de una base (Diaria)
const handleBaseMoliendaTerminada = (base) => {
const mol = base.molienda || {};
const origen = 'base:' + base.id;
if (!moliendas.some(m => m.origen === origen)) {
const rec = {
id: 'mol_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7),
producto: (mol.producto || base.nombre || 'Molienda').trim(),
lote: (mol.lote || base.lote || '').trim(),
cantidad: parseFloat(mol.cantidad) || 0, unidad: 'Kg',
estado: 'lista', consumido: 0, fecha: cpCaracasDateStr(),
responsable: currentUser?.name || currentUser?.email || '',
molino: '', notas: 'Molienda de la base ' + (base.code || base.nombre || ''),
origen, createdAt: new Date().toISOString(),
};
handleMoliendasChange([rec, ...moliendas]);
}
updateBase({ ...base, molienda: { ...mol, terminada: true } });
showToast('Molienda terminada y registrada en inventario');
};
// 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 machinePollInFlight = useRef(false);
const machinesSaveInFlight = useRef(new Set());
const pendingMachineDeletes = useRef(new Set());
const deletedMachineIds = useRef(new Set());
const lastSyncMsgAt = useRef(0);
// 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 canAccessEnvasadoTab = isAdmin || !!(perms.access_envasado_tab) || !!(perms.check_envasado) || !!(perms.access_envasado_only);
const canEditCP = isAdmin || canEdit || !!(perms.edit_control_proceso);
const hasFullAccess = isAdmin || canEdit;
const canAccessEquipos = isAdmin || !!(perms.access_equipos_tab);
const canAccessMoliendas = isAdmin || !!(perms.access_moliendas_tab);
const canAccessBackorden = isAdmin || !!(perms.access_backorden_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.
const canPersistPlan = canEdit || canCheckEnvasado || canEditGalonaje
|| canEditEnvasado || canCheckMatizacion;
const canDeleteSafe = canDelete && hasValidBackend;
const canDuplicateSafe = canDuplicate && hasValidBackend;
const isAdminSafe = isAdmin && hasValidBackend;
// Redirigir operadores restringidos a su pestaña correspondiente al entrar
useEffect(() => {
if (!currentUser || hasFullAccess) return;
const p = currentUser.permissions || {};
if (p.access_diaria_empaque) setView('day');
else if (p.check_matizacion) setView('matizacion');
else if (p.access_envasado_tab || p.check_envasado || p.access_envasado_only) setView('envasado');
else if (p.edit_control_proceso) setView('control');
else if (p.access_equipos_tab) setView('equipos');
else if (p.access_backorden_tab) setView('backorden');
}, [currentUser?.id]);
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 (_) {}
};
// 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 (_) {}
};
const markApiFailure = (err, context = 'sincronización') => {
const status = err?.status || 0;
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.');
setSyncStatus('error');
return;
}
if (status === 404) return; // 404 = recurso no encontrado, no indica falla de conectividad
setBackendStatus('offline');
setBackendMsg(`No hay conexión válida con el servidor (${context}).`);
setSyncStatus('offline');
};
const callApi = async (url, opts = {}, context = 'solicitud') => {
try {
const json = await readApiJson(await apiFetch(url, opts));
setBackendStatus('online');
setBackendMsg('Conexión con servidor activa');
return json;
} catch (err) {
markApiFailure(err, context);
throw err;
}
};
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(); });
const id = setInterval(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(() => {});
}, []);
// ─ 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(() => {});
}, []);
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 (_) {}
};
// ─ 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(() => {});
}, []);
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 (_) {}
};
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(() => {});
};
// ─ 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]);
// ─ 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]);
// ─ 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 || !canEdit) 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 (_) {}
}
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 (_) {}
}
})();
}, [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, canEdit, 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 (_) {}
};
load();
}, []);
// ─ Cargar inventario de moliendas al inicio (esmalte) ─
useEffect(() => {
(async () => {
try {
const json = await callApi(`${API_URL}?action=moliendas_get`, {}, 'cargar moliendas');
if (json?.ok && Array.isArray(json.data)) {
setMoliendas(json.data);
try { localStorage.setItem(MOLIENDAS_STORAGE_KEY, JSON.stringify(json.data)); } catch (_) {}
}
} catch (_) {}
})();
}, []);
// ─ 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 (_) {}
};
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(() => {
if (!cpCloudReady || !canEditCP) 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)
);
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 }),
}, '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));
} else {
savedMachineData.current = { ...savedMachineData.current, [machine.id]: JSON.stringify(machine) };
}
} catch (_) {
// 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 (_) {}
}
// Actualizar timestamps para futuras operaciones sin descargar cp_machine_list.
try {
const chkJ = await callApi(`${API_URL}?action=cp_machine_check`, {}, 'confirmar guardado de máquinas');
if (chkJ?.ok) {
machineTimestamps.current = {};
(chkJ.data || []).forEach(({ machine_id, updated_at }) => {
machineTimestamps.current[machine_id] = updated_at;
});
}
} catch (_) {}
} catch (err) {
setSyncMsg(`⚠ No se pudieron sincronizar máquinas: ${err?.message || 'error desconocido'}`);
setSyncStatus('error');
}
}, 900);
return () => clearTimeout(t);
}, [cpMachines, cpCloudReady, canEditCP]);
// ─ Polling granular de planificación ─
useEffect(() => {
const poll = async () => {
if (planPollInFlight.current) return;
planPollInFlight.current = true;
try {
// ── Bases: una fecha (día) o las 7 de la semana ──
const datesToPoll = view === 'week'
? Array.from({ length: 7 }, (_, i) => shiftDate(startOfWeek(date), i))
: [date];
for (const d of datesToPoll) {
try {
const json = await callApi(`${API_URL}?action=plan_batch_check&fecha=${d}`, {}, 'polling de planificación');
if (!json?.ok) continue;
const serverList = json.data || []; // [{batch_id, updated_at, updated_by}]
const localTs = batchTimestamps.current[d] || {};
const serverIds = new Set(serverList.map(r => r.batch_id));
const localIds = new Set(Object.keys(localTs));
// 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])
|| [...localIds].some(id => !serverIds.has(id));
if (!hasChange) continue;
// Descarga la lista completa del día
const fullJ = await callApi(`${API_URL}?action=plan_batch_list&fecha=${d}`, {}, 'descargar planificación actualizada');
if (!fullJ?.ok || !Array.isArray(fullJ.data)) continue;
const batches = fullJ.data.map(r => r.batch);
// Captura tombstones y datos previos ANTES de sobreescribir refs
const prevSaved = savedBatchData.current[d] || {};
// Actualiza refs de timestamps y datos guardados
savedBatchData.current[d] = {};
batchTimestamps.current[d] = {};
fullJ.data.forEach(r => {
savedBatchData.current[d][r.batch_id] = JSON.stringify(r.batch);
batchTimestamps.current[d][r.batch_id] = r.updated_at;
});
// 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();
// Filtra batches que están siendo eliminados (pendingDeletes) o marcados como tombstone
const filtered = batches.filter(b => !pending.has(b.id) && prevSaved[b.id] !== null);
const next = { ...prev, [d]: filtered };
try { localStorage.setItem(PLAN_STORAGE_KEY, JSON.stringify(next)); } catch (_) {}
return next;
});
if (updaters) showThrottledSyncMsg(`↻ Bases actualizadas por ${updaters}`);
} catch (_) {}
}
} finally {
planPollInFlight.current = false;
}
};
const interval = view === 'week' ? PLAN_WEEK_POLL_INTERVAL_MS : PLAN_DAY_POLL_INTERVAL_MS;
const id = setInterval(poll, interval);
return () => clearInterval(id);
}, [date, view]);
// ─ Cargar máquinas desde la BD ─
useEffect(() => {
if (!currentUser) return;
setCpCloudReady(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 {
setCpCloudReady(true);
}
};
load();
}, [currentUser]);
// ─ Auto-guardar máquinas (solo las que cambiaron) ─
useEffect(() => {
if (!cpCloudReady || !canEditCP) return;
const t = setTimeout(async () => {
try {
const serverMachines = savedMachineData.current;
const currentIds = new Set(cpMachines.map(m => m.id));
const toSave = cpMachines.filter(m => JSON.stringify(m) !== serverMachines[m.id]);
const toDelete = Object.keys(serverMachines).filter(id => !currentIds.has(id));
for (const machine of toSave) {
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 }),
}, 'guardar máquina');
savedMachineData.current = { ...savedMachineData.current, [machine.id]: JSON.stringify(machine) };
}
for (const machineId of toDelete) {
await callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'cp_machine_delete', machine_id: machineId }),
}, 'eliminar máquina');
delete savedMachineData.current[machineId];
}
if (toSave.length > 0 || toDelete.length > 0) {
const chkJ = await callApi(`${API_URL}?action=cp_machine_check`, {}, 'confirmar timestamps');
if (chkJ?.ok) {
machineTimestamps.current = {};
(chkJ.data || []).forEach(({ machine_id, updated_at }) => {
machineTimestamps.current[machine_id] = updated_at;
});
}
}
} catch (_) {}
}, 1200);
return () => clearTimeout(t);
}, [cpMachines, cpCloudReady, canEditCP]);
// ─ Polling de máquinas cada 5s ─
useEffect(() => {
if (!currentUser) return;
const poll = async () => {
try {
const json = await callApi(`${API_URL}?action=cp_machine_check`, {}, 'polling máquinas');
if (!json?.ok) return;
const serverList = json.data || [];
const localTs = machineTimestamps.current;
const serverIds = new Set(serverList.map(r => r.machine_id));
const localIds = new Set(Object.keys(localTs));
const hasChange = serverList.some(r => r.updated_at !== localTs[r.machine_id])
|| [...localIds].some(id => !serverIds.has(id));
if (!hasChange) return;
const fullJ = await callApi(`${API_URL}?action=cp_machine_list`, {}, 'actualizar máquinas');
if (!fullJ?.ok || !Array.isArray(fullJ.data)) return;
savedMachineData.current = {};
machineTimestamps.current = {};
fullJ.data.forEach(r => {
savedMachineData.current[r.machine_id] = JSON.stringify(r.machine);
machineTimestamps.current[r.machine_id] = r.updated_at;
});
const updaters = [...new Set(
serverList.filter(r => r.updated_at !== localTs[r.machine_id]).map(r => r.updated_by)
)].filter(Boolean).join(', ');
setCpMachines(fullJ.data.map(r => r.machine).filter(Boolean));
if (updaters) showThrottledSyncMsg(`↻ Máquinas actualizadas por ${updaters}`);
} catch (_) {}
};
const id = setInterval(poll, 5000);
return () => clearInterval(id);
}, [currentUser]);
const deleteMachine = async (id) => {
if (!canEditCP) return;
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 (_) {}
};
// ─ Tick cada segundo para timers de fases ─
useEffect(() => {
const id = setInterval(() => setCpTick(t => t + 1), 1000);
return () => clearInterval(id);
}, []);
// ─ 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 ─
const openPendingModal = async () => {
if (!canEditSafe) return;
const yesterday = shiftDate(date, -1);
let yBases = plan[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[date] || [];
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. puntos por máquina).
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]);
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 q = search.toLowerCase();
out = out.filter(b =>
b.code.toLowerCase().includes(q) ||
b.nombre.toLowerCase().includes(q) ||
b.lote.toLowerCase().includes(q) ||
b.colors.some(c => c.nombre.toLowerCase().includes(q) || c.lote.toLowerCase().includes(q))
);
}
return out;
}, [bases, filter, search]);
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) => {
setPlan(prev => {
const dayBases = prev[date] || [];
return { ...prev, [date]: 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);
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) {
updatePlan(arr => arr.map(b => b.id === data.id ? { ...b, ...data } : b));
showToast('Base actualizada');
} else {
const dayArr = plan[date] || [];
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]));
// Consumo de molienda del inventario (esmalte: base molienda+color con molienda ya lista)
const mc = data.moliendaConsumo;
if (data.formulaTipo === 'ambas' && mc && mc.molienda_id) {
const kg = parseFloat(mc.kg) || 0;
if (kg > 0) {
handleMoliendasChange(moliendas.map(m => {
if (m.id !== mc.molienda_id) return m;
const disp = (parseFloat(m.cantidad) || 0) - (parseFloat(m.consumido) || 0);
const usado = Math.min(kg, disp);
const destino = [newBase.nombre || newBase.producto, newBase.lote ? 'lote ' + newBase.lote : '']
.filter(Boolean).join(' · ') || 'Base';
const mov = {
id: 'c_' + Date.now() + '_' + Math.random().toString(36).slice(2, 6),
fecha: newBase.fecha || cpCaracasDateStr(),
kg: usado,
destino,
nota: 'Consumo automático al crear la base',
responsable: currentUser?.name || currentUser?.email || '',
baseId: newBase.id,
createdAt: new Date().toISOString(),
};
return {
...m,
consumido: (parseFloat(m.consumido) || 0) + usado,
consumos: [...(Array.isArray(m.consumos) ? m.consumos : []), mov],
};
}));
}
}
showToast('Base creada');
}
setBaseModal(null);
};
const updateBase = (updated) => {
if (!canEditSafe) return;
updatePlan(arr => arr.map(b => b.id === updated.id ? updated : b));
};
// Actualiza campos de una base en cualquier fecha (para checks de control de proceso)
const onCpUpdateBase = (baseId, patch, dateStr) => {
if (!canEditSafe) return;
setPlan(prev => {
const dayBases = prev[dateStr] || [];
const updated = dayBases.map(b => b.id === baseId ? { ...b, ...patch } : b);
if (dateStr !== date) {
const totalGL = updated.reduce((a, b) => a + Number(b.cantidad || 0), 0);
callApi(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
action: 'plan_db_save', fecha: dateStr, batches: updated,
total_batches: updated.length, total_gl: totalGL,
total_unidades: updated.reduce((a, b) => a + (b.colors?.length || 0), 0),
}),
}, 'guardar actualización de control de proceso').catch(() => {});
}
return { ...prev, [dateStr]: updated };
});
};
const deleteBase = async (id) => {
if (!canDeleteSafe) return;
if (!window.verifyDeleteKey('¿Eliminar esta base y todos sus colores?')) return;
const previousDay = planRef.current[date] || [];
const nextDay = previousDay.filter(b => b.id !== id);
// Registra como pendiente ANTES de cualquier actualización de estado
if (!pendingBatchDeletes.current[date]) pendingBatchDeletes.current[date] = new Set();
pendingBatchDeletes.current[date].add(id);
// Pone tombstone ANTES del API call para que el polling lo filtre durante el in-flight
if (!savedBatchData.current[date]) savedBatchData.current[date] = {};
const prevEntry = savedBatchData.current[date][id]; // undefined = nunca guardado en servidor
savedBatchData.current[date][id] = null;
// Actualización optimista
setPlan(prev => {
const next = { ...prev, [date]: 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: date, 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[date][id] = prevEntry;
pendingBatchDeletes.current[date]?.delete(id); // permite que el polling vuelva a mostrar el batch
setPlan(prev => {
const rollback = { ...prev, [date]: 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=${date}`, {}, 'confirmar eliminación');
if (chkJ?.ok) {
batchTimestamps.current[date] = {};
(chkJ.data || []).forEach(({ batch_id, updated_at }) => {
batchTimestamps.current[date][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) };
}));
};
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(() => {
const onEditBase = (e) => {
if (!canEditSafe) return;
const b = bases.find(x => x.id === e.detail);
if (b) setBaseModal({ base: b });
};
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 b of bases) {
const c = b.colors.find(x => x.id === e.detail);
if (c) { setColorModalCtx({ baseId: b.id, color: c, baseNombre: b.nombre || '' }); break; }
}
};
window.addEventListener('edit-base', onEditBase);
window.addEventListener('edit-color', onEditColor);
return () => {
window.removeEventListener('edit-base', onEditBase);
window.removeEventListener('edit-color', onEditColor);
};
}, [bases, canEdit]);
// ─ Duplicar día anterior ─
const duplicateYesterday = () => {
if (!canDuplicate) return;
const yesterday = shiftDate(date, -1);
const yBases = plan[yesterday];
if (!yBases || !yBases.length) { showToast('Sin plan ayer', 'err'); return; }
if (bases.length && !window.verifyDeleteKey('Reemplazar el plan de hoy con el de ayer eliminará las bases actuales de hoy.')) return;
const cloned = yBases.map(b => ({
...b, id: uid('b'), status: 'planned', operador: '',
colors: b.colors.map(c => ({ ...c, id: uid('c'), status: 'pending', completedAt: null })),
}));
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) => {
const html = buildDailyPlanReport(basesToPrint, date, new Set(emphIds || []), includeColors);
const win = window.open('', '_blank', 'width=940,height=720');
if (!win) { showToast('Permita las ventanas emergentes para imprimir', 'err'); return; }
win.document.write(html);
win.document.close();
setTimeout(() => { win.focus(); win.print(); }, 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 === '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 (
);
}
// ─── PANTALLA DE LOGIN ─────────────────────────────────────────────────────────
function LoginForm({ onLogin, onPlantDenied }) {
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [error, setError] = useState('');
const [loading, setLoading] = useState(false);
const submit = async (e) => {
e.preventDefault();
setLoading(true);
setError('');
try {
const j = await readApiJson(await apiFetch(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'login', email: email.trim(), password }),
}));
if (j.user) {
onLogin(j.user);
} else {
setError(j.error || 'Credenciales inválidas');
}
} catch (err) {
if (err?.data?.plant_denied && onPlantDenied) {
onPlantDenied({ plant: err.data.plant, allowed: err.data.allowed_plants || [] });
return;
}
setError(err?.message || 'Error de conexión. Intenta de nuevo.');
} finally {
setLoading(false);
}
};
return (
VERONA COLOR PAINTS
{window.t('Sistema de Planificación de Producción')}
);
}
// ─── PANTALLA: SIN ACCESO A ESTA PLANTA ────────────────────────────────────────
function PlantAccessScreen({ plant, allowed, onLogout }) {
const PLANT_LABEL = { caucho: 'Caucho', esmalte: 'Esmalte' };
const cur = (plant || window.SP_PLANT || 'caucho').toLowerCase();
const list = (Array.isArray(allowed) ? allowed : []).filter(p => p && p !== cur);
return (
VERONA COLOR PAINTS
Sin acceso a la planta {PLANT_LABEL[cur] || cur.toUpperCase()}
Tu cuenta no está habilitada para esta planta. Pide al administrador que te dé acceso,
{list.length ? ' o entra a la planta que sí tienes asignada:' : ' o cierra sesión.'}
{list.length > 0 && (
)}
Cerrar sesión
);
}
// ─── RAÍZ CON AUTENTICACIÓN ────────────────────────────────────────────────────
function RootApp() {
const [currentUser, setCurrentUser] = useState(null);
const [authLoading, setAuthLoading] = useState(true);
const [plantDenied, setPlantDenied] = useState(null); // { plant, allowed } | null
useEffect(() => {
apiFetch(`${API_URL}?action=session`)
.then(readApiJson)
.then(j => { setCurrentUser(j.user || null); })
.catch(err => {
if (err?.data?.plant_denied) {
setPlantDenied({ plant: err.data.plant, allowed: err.data.allowed_plants || [] });
}
})
.finally(() => setAuthLoading(false));
}, []);
const handleLogout = async () => {
try {
await apiFetch(API_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action: 'logout' }),
});
} catch (_) {}
setCurrentUser(null);
setPlantDenied(null);
};
if (authLoading) {
return (
);
}
if (plantDenied) {
return ;
}
if (!currentUser) {
return ;
}
return ;
}
ReactDOM.createRoot(document.getElementById('root')).render( );