// ════════════════════════════════════════════ // COMPONENTS — Planificación Diaria // ════════════════════════════════════════════ const { useState, useEffect, useRef, useMemo } = React; // ─── ICONS ─── const Icon = { // Iconos existentes (sin cambios) Chevron: () => , Plus: () => , Check: () => , Edit: () => , Trash: () => , Copy: () => , Print: () => , Sliders: () => , Search: () => , Cal: () => , Grid: () => , Left: () => , Right: () => , Download: () => , X: () => , // Iconos nuevos para Control de Proceso (spreadan props para aceptar width/height dinámicos) Activity: (p) => , ChevronLeft: (p) => , ChevronRight: (p) => , Play: (p) => , Pause: (p) => , Stop: (p) => , GripVertical: (p) => , Printer: (p) => , Dispersor: (p) => {/* Motor/drive block */} {/* Vertical shaft */} {/* Serrated impeller disc (8-point star) */} {/* Tank vessel */} , Envasado: (p) => {/* Top rail */} {/* Left nozzle */} {/* Right nozzle */} {/* Containers on conveyor */} {/* Conveyor */} , Mezclador: (p) => {/* Motor */} {/* Shaft */} {/* Mixing tank (trapezoid) */} {/* Paddle blades */} , Molino: (p) => {/* Three-roll mill: 3 cylinders in row */} {/* Feed arrow top-left */} {/* Output arrow bottom-right */} , Empaquetadora: (p) => {/* Box body */} {/* Open-top flaps */} {/* Tape strip */} {/* Label lines */} , }; // ─── HELPERS ─── const DOW_ES = ['DOM','LUN','MAR','MIE','JUE','VIE','SAB']; const DOW_FULL = ['Domingo','Lunes','Martes','Miércoles','Jueves','Viernes','Sábado']; const MONTHS_ES = ['Enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto','Septiembre','Octubre','Noviembre','Diciembre']; function fmtDate(dStr) { const d = new Date(dStr + 'T12:00:00'); return { day: d.getDate(), dow: DOW_ES[d.getDay()], dowFull: DOW_FULL[d.getDay()], month: MONTHS_ES[d.getMonth()], year: d.getFullYear(), my: `${MONTHS_ES[d.getMonth()]} ${d.getFullYear()}` }; } function shiftDate(dStr, days) { const d = new Date(dStr + 'T12:00:00'); d.setDate(d.getDate() + days); return d.toISOString().split('T')[0]; } function startOfWeek(dStr) { const d = new Date(dStr + 'T12:00:00'); const dow = d.getDay(); const diff = (dow === 0 ? -6 : 1 - dow); // monday-start d.setDate(d.getDate() + diff); return d.toISOString().split('T')[0]; } function fmtNum(n) { return Number(n||0).toLocaleString('es-VE'); } // Escapa texto para insertarlo en HTML (contenido y atributos) de las ventanas de impresión. function escHtml(v) { return String(v == null ? '' : v).replace(/[&<>"']/g, c => ({ '&':'&', '<':'<', '>':'>', '"':'"', "'":''' }[c])); } function uid(prefix='id') { return prefix + '_' + Math.random().toString(36).slice(2, 9); } // Equivalencia de cada presentación de envasado en galones (GL). ÚNICA fuente: antes estaba // copiada en DayHeader, el editor de envasado, WeekView, el resumen del día y mobile.jsx. // TODO(producción): confirmar los factores con Producción antes de cambiarlos. En particular // 'cu7' vale 2 aquí aunque su etiqueta dice "Cuñete 7.2GL" (¿7.2 GL?); 'ku' = 0.25; 'pl'/'pm' // (1 L / 0.5 L) usan 0.264 / 0.132 GL. NO modificar sin esa confirmación. const ENV_GL_FACTOR = { gl: 1, cu4: 4, cu5: 5, cu7: 2, ku: 0.25, pl: 0.264, pm: 0.132 }; // ─── Reloj Interno VET (UTC-4, Venezuela Standard Time) ────────────────────── // Sincronización tipo NTP contra el servidor: independiente del reloj del SO. // Funciona igual en máquinas conectadas al servidor Windows y en las que no. const _VET_MS = -4 * 60 * 60 * 1000; const _clock = (() => { // Offset acumulado: cuántos ms hay que sumar a Date.now() para obtener la hora real del servidor let _offset = 0; let _synced = false; // true después de la primera sincronización exitosa let _samples = []; // últimas muestras para filtrar outliers const MAX_SAMPLES = 8; const ALPHA = 0.15; // suavizado exponencial: valores bajos = más estables, menos reactivos // Persistencia de sesión: si el usuario recarga antes del primer heartbeat // recuperamos el último offset conocido de sessionStorage. (() => { try { const saved = sessionStorage.getItem('_vet_offset'); if (saved !== null) { _offset = Number(saved) || 0; _synced = true; } } catch {} })(); function _persist() { try { sessionStorage.setItem('_vet_offset', String(_offset)); } catch {} } /** * Calibra el reloj con una respuesta del servidor. * Usa el algoritmo de Cristian con filtro de muestras para descartar * lecturas con latencia anómala (picos de red). * * @param {string} serverTimeISO - ISO 8601 devuelto por el servidor * @param {number} t0 - Date.now() justo antes de enviar la petición * @param {number} t1 - Date.now() justo después de recibir la respuesta */ function sync(serverTimeISO, t0, t1) { try { const serverMs = new Date(serverTimeISO).getTime(); if (isNaN(serverMs)) return; const rtt = t1 - t0; if (rtt < 0 || rtt > 10000) return; // descartar si el RTT es absurdo (>10 s) // Hora estimada del servidor en el momento exacto de recepción const serverAtT1 = serverMs + rtt / 2; const rawOffset = serverAtT1 - t1; // Acumular muestras y descartar outliers (fuera de 1.5× la mediana de RTTs) _samples.push({ rtt, offset: rawOffset }); if (_samples.length > MAX_SAMPLES) _samples.shift(); // Filtro: ignorar muestras con RTT muy alto respecto a la mediana const rtts = _samples.map(s => s.rtt).sort((a, b) => a - b); const medianRtt = rtts[Math.floor(rtts.length / 2)]; const valid = _samples.filter(s => s.rtt <= medianRtt * 2.0); if (!valid.length) return; // Promedio de offsets de las muestras válidas const avgOffset = valid.reduce((acc, s) => acc + s.offset, 0) / valid.length; if (!_synced) { // Primera sincronización: aplicar directamente sin suavizado _offset = avgOffset; _synced = true; } else { // Actualizaciones posteriores: suavizado exponencial para evitar saltos bruscos _offset = _offset * (1 - ALPHA) + avgOffset * ALPHA; } _persist(); } catch {} } function now() { return new Date(Date.now() + _offset + _VET_MS); } function isSynced() { return _synced; } return { sync, now, isSynced }; })(); // API pública — usada en components.jsx, app.jsx y control-proceso.jsx function calibrateFromServer(iso, t0, t1) { _clock.sync(iso, t0, t1); } function vetNow() { return _clock.now(); } function getVetOffset() { return 0; } // retrocompatibilidad — no-op function setVetOffset() {} // retrocompatibilidad — no-op function vetTimeStr(d) { return d.getUTCHours().toString().padStart(2,'0') + ':' + d.getUTCMinutes().toString().padStart(2,'0') + ':' + d.getUTCSeconds().toString().padStart(2,'0'); } // Hora actual (ms epoch) y ISO según el reloj calibrado con el servidor: usar esto en vez de // Date.now()/new Date() para marcas que se guardan (completedAt) o duraciones de fases. function syncedNowMs() { return _clock.now().getTime() - _VET_MS; } function syncedNowIso() { return new Date(syncedNowMs()).toISOString(); } function todayStr() { const d = vetNow(); return d.getUTCFullYear() + '-' + (d.getUTCMonth() + 1).toString().padStart(2,'0') + '-' + d.getUTCDate().toString().padStart(2,'0'); } // ─── HEADER ─── function CloudStatusBadge({ status, isOnline }) { if (!isOnline) return (
Sin conexión
); if (status === 'saving') return (
Guardando…
); if (status === 'saved') return (
Guardado
); if (status === 'error') return (
Error al guardar
); if (status === 'session') return (
Sesión expirada
); return null; } // ─── THEME TOGGLE ─── // Insignia visible de la planta actual (CAUCHO / ESMALTE) function PlantBadge() { const plant = (window.SP_PLANT || 'caucho').toLowerCase(); const isCaucho = plant === 'caucho'; const bg = isCaucho ? '#1e40af' : '#b45309'; return ( {plant.toUpperCase()} ); } // ─── SETTINGS MENU (⚙) ─── // Agrupa Usuarios/Config/Imprimir/Exportar + idioma + tema en un solo botón, // ubicado en el header junto al bloque de cuenta/cerrar sesión. function SettingsMenu({ onUsers, onConfig, onPrint, onExport, lang, onLangToggle, theme, onTheme }) { const [open, setOpen] = useState(false); const ref = useRef(null); useEffect(() => { if (!open) return; const onDocClick = (e) => { if (ref.current && !ref.current.contains(e.target)) setOpen(false); }; document.addEventListener('mousedown', onDocClick); return () => document.removeEventListener('mousedown', onDocClick); }, [open]); const isAr = (lang || window.SP_LANG) === 'ar'; const run = (fn) => { setOpen(false); fn && fn(); }; const hasAdmin = !!(onUsers || onConfig); const hasReport = !!(onPrint || onExport); return (
{open && (
{hasAdmin &&
{window.t('Administración')}
} {onUsers && } {onConfig && } {hasAdmin && hasReport &&
} {hasReport &&
{window.t('Reportes')}
} {onPrint && } {onExport && } {(hasAdmin || hasReport) &&
}
{window.t('Preferencias')}
{window.t('Idioma')}
{window.t('Tema')}
)}
); } // Etiqueta del breadcrumb para cada vista — cubre TODAS las vistas de la app // (antes solo distinguía 4 y el resto caía por defecto en "Diaria"). const HDR_BC_LABELS = { day: 'Diaria', week: 'Semanal', lista: 'Lista', matizacion: 'Matización', formulas: 'Fórmulas', bformulas: 'Fórmulas de base', consumo: 'Consumo MP', envasado: 'Envasado', envasado_facturacion: 'Facturación', control: 'Control de Proceso', supervisor: 'Vista Supervisor', personal: 'Personal', preparadores: 'Preparadores', historial: 'Historial', equipos: 'Equipos', backorden: 'Back Orden', mantenimiento: 'Mantenimiento', }; function Header({ currentDate, view, syncStatus, isOnline, theme, onTheme, currentUser, onLogout, lang, onLangToggle, onMenuToggle, onUsers, onConfig, onPrint, onExport }) { const [time, setTime] = useState(vetNow()); // El reloj se actualiza cada segundo mostrando la hora calibrada del servidor useEffect(() => { const t = setInterval(() => setTime(vetNow()), 1000); return () => clearInterval(t); }, []); const f = fmtDate(currentDate); return (
{onMenuToggle && ( )}
Verona Color Paints

Verona Color Paints

{window.t('Sistema de Planificación')}

{window.t('Planificación')} / {window.t(HDR_BC_LABELS[view] || 'Diaria')}
{currentUser && (
{currentUser.name || currentUser.email} {currentUser.role === 'admin' ? 'Administrador' : (currentUser.roleLabel || currentUser.role || 'Operario')} {onLogout && ( )}
)}
{vetTimeStr(time)}
); } function miniMachineStatus(machine) { const phases = machine.phases || []; if (!phases.length) return 'idle'; if (phases.every(p => p.status === 'done')) return 'done'; if (phases.some(p => p.running)) return 'running'; if (phases.some(p => p.status === 'paused')) return 'paused'; return 'idle'; } function miniElapsed(phase) { if (!phase) return 0; const acc = phase.accumulated || 0; if (!phase.running || !phase.startedAt) return acc; return acc + Math.max(0, Math.floor((syncedNowMs() - phase.startedAt) / 1000)); } function miniMachineTotalSeconds(machine) { return (machine.phases || []).reduce((sum, phase) => sum + miniElapsed(phase), 0); } function miniFormatDuration(secs) { if (!secs || secs < 0) return '00:00'; const h = Math.floor(secs / 3600); const m = Math.floor((secs % 3600) / 60); const s = secs % 60; if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`; return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`; } function MachineForecastSegment({ title, subtitle, machines = [], date, groups, emptyText }) { const dayMachines = (machines || []).filter(m => !m.fecha || !date || m.fecha === date); const machineTypes = window.AppData?.MACHINE_TYPES || {}; const statusMeta = { running: { label: 'En proceso', icon: '●' }, paused: { label: 'Pausada', icon: 'Ⅱ' }, done: { label: 'Finalizada', icon: '✓' }, idle: { label: 'Inactiva', icon: '○' }, }; const renderMachine = (m) => { const status = miniMachineStatus(m); const currentPhase = (m.phases || []).find(p => p.running) || (m.phases || []).find(p => p.status === 'paused'); const donePhases = (m.phases || []).filter(p => p.status === 'done').length; const totalPhases = (m.phases || []).length; const assignment = (m.assignments || [])[0]; const elapsed = currentPhase ? miniElapsed(currentPhase) : miniMachineTotalSeconds(m); const meta = statusMeta[status] || statusMeta.idle; return (
{m.code || m.id} {m.name || machineTypes[m.type]?.name || 'Máquina'}
{meta.icon} {meta.label}
Tiempo {miniFormatDuration(elapsed)}
Fase {currentPhase?.name || (status === 'done' ? 'Completada' : 'Sin fase activa')}
Trabajo {assignment?.nombre || m.lote || 'Sin asignación'}
{totalPhases > 0 && (
)}
); }; const resolvedGroups = (groups || []).map(g => ({ ...g, machines: dayMachines .filter(m => g.types.includes(m.type)) .sort((a, b) => { const order = { running: 0, paused: 1, idle: 2, done: 3 }; return (order[miniMachineStatus(a)] ?? 9) - (order[miniMachineStatus(b)] ?? 9); }), })); const total = resolvedGroups.reduce((sum, g) => sum + g.machines.length, 0); const [collapsed, setCollapsed] = useState(false); const contentId = `machine-forecast-${String(title || 'segment').toLowerCase().replace(/[^a-z0-9]+/g, '-')}`; return (
{total} equipos
); } // ─── TABS ─── // ─── ENVASADO VIEW ─── function EnvasadoView({ bases, date, onDate, machines = [], tick, onShowHistorial, onOpenPersonal, onOpenFacturacion }) { const [search, setSearch] = useState(''); const [statusFilter, setStatusFilter] = useState('all'); // 'all' | 'progress' | 'done' const qWords = search.trim().toLowerCase().split(/\s+/).filter(Boolean); const dateInputRef = useRef(null); const histCount = machines .filter(m => ['envasado', 'empaquetadora'].includes(m.type)) .reduce((s, m) => s + (m.history || []).length, 0); const activeBases = (bases || []).filter(b => b.status !== 'cancelled'); const isColorDone = (c) => !!c.checkEM || c.status === 'ready'; const isBaseDone = (b) => { const cols = b.colors.filter(c => !c.cancelled); return cols.length > 0 && cols.every(isColorDone); }; const doneBasesCount = activeBases.filter(isBaseDone).length; const progressBasesCount = activeBases.length - doneBasesCount; const statusBases = activeBases.filter(b => statusFilter === 'all' ? true : statusFilter === 'done' ? isBaseDone(b) : !isBaseDone(b) ); const filtered = statusBases.map(b => { const baseHaystack = `${b.nombre || ''} ${b.code || ''} ${b.lote || ''}`.toLowerCase(); const matchBase = !qWords.length || qWords.every(w => baseHaystack.includes(w)); const cols = b.colors.filter(c => !c.cancelled && ( !qWords.length || matchBase || qWords.every(w => `${c.nombre || ''} ${c.lote || ''}`.toLowerCase().includes(w)) ) ); return { ...b, cols }; }).filter(b => b.cols.length > 0); const allColors = activeBases.flatMap(b => b.colors.filter(c => !c.cancelled)); const envasadoDone = allColors.filter(isColorDone).length; const { dow, day, month } = fmtDate(date); return (
{/* Barra superior */}
{onDate && (
)} onDate && dateInputRef.current?.showPicker()} title={onDate ? 'Cambiar fecha' : undefined} > {dow} {day} {month} {onDate && ( e.target.value && onDate(e.target.value)} /> )} {onDate && date !== todayStr() && ( )} {envasadoDone} / {allColors.length} envasados
setSearch(e.target.value)} />
{search && ( )} {onOpenPersonal && ( )} {onOpenFacturacion && ( )} {onShowHistorial && ( )}
{/* Filtro por estado de la base */}
Estado:
{/* Contenido */}
{activeBases.length === 0 ? (
📦

Sin bases planificadas

No hay producción planificada para este día.

) : filtered.length === 0 ? (
🔍

Sin resultados

{qWords.length ? 'No hay bases o colores que coincidan con la búsqueda.' : statusFilter === 'done' ? 'No hay bases completadas para este día.' : 'No hay bases en curso para este día.'}

) : filtered.map(b => { const totalGL = b.cols.reduce((a, c) => a + (c.cantidad || 0), 0); const doneCount = b.cols.filter(isColorDone).length; const allDone = doneCount === b.cols.length; return (
{/* Cabecera de base */}
{b.tipo || 'BASE'} {b.nombre} {b.code} · Lote {b.lote} {totalGL} {b.unit || 'GL'} {doneCount}/{b.cols.length} {allDone && ✓ Completo}
{/* Tabla de colores */}
COLOR
LOTE
GL PLAN
GL REAL
ENVASADO
ESTADO
{b.cols.map(c => { const st = c.checkEM ? 'ready' : c.checkEN ? 'running' : 'pending'; const label = c.checkEM ? 'ENVASADO' : c.checkEN ? 'EN PROCESO' : 'PENDIENTE'; return (
{c.nombre}
{c.lote || '—'}
{c.cantidad ?? '—'} {c.unit || b.unit}
{c.glReal != null ? `${c.glReal} ${c.unit || b.unit}` : '—'}
{label}
); })}
); })}
); } // ─── MATIZACIÓN VIEW ─── // Muestra TODA la información del día (todas las bases no canceladas, sin // exigir que estén marcadas FN) con navegación de fecha. Por color se // muestra solo el galonaje; el envasado se omite. Los colores ya matizados // (checkMA) se muestran marcados, no se ocultan. function MatizacionView({ bases, date, onDate, onMark, canMark, machines = [], tick, onShowHistorial, onOpenPersonal, formulas = [], canEditFormula, onOpenFormulas }) { const dateInputRef = useRef(null); const activeBases = (bases || []).filter(b => b.status !== 'cancelled'); const allColors = activeBases.flatMap(b => (b.colors || []).filter(c => !c.cancelled)); const doneCount = allColors.filter(c => c.checkMA).length; // Índice de fórmulas por colorId (última guardada por color) const formulaByColor = {}; (formulas || []).forEach(f => { if (f.colorId) formulaByColor[f.colorId] = f; }); const visibleBases = activeBases.map(b => ({ ...b, cols: (b.colors || []).filter(c => !c.cancelled), })).filter(b => b.cols.length > 0); const { dow, day, month } = fmtDate(date); const dateNav = (
{onDate && (
)} onDate && dateInputRef.current?.showPicker && dateInputRef.current.showPicker()} title={onDate ? 'Cambiar fecha' : undefined} > {dow} {day} {month} {onDate && ( e.target.value && onDate(e.target.value)} /> )} {onDate && date !== todayStr() && ( )}
); const histCount = machines .filter(m => m.type === 'dispersor1') .reduce((s, m) => s + (m.history || []).length, 0); const histBtn = onShowHistorial ? ( ) : null; const fmlBtn = onOpenFormulas ? ( ) : null; const personalBtn = onOpenPersonal ? ( ) : null; return (
{dateNav} {doneCount} / {allColors.length} colores
{fmlBtn} {personalBtn} {histBtn}
{visibleBases.length === 0 ? (
🎨

Sin producción para este día

Cambia de fecha o agrega bases desde la vista Diaria.

) : visibleBases.map(b => { const totalGL = b.cols.reduce((a, c) => a + (c.cantidad || 0), 0); return (
{b.tipo || 'BASE'} {b.nombre} {b.code} · Lote {b.lote} {totalGL} {b.unit || 'GL'}
{b.cols.map(c => { const done = !!c.checkMA; const hasF = !!formulaByColor[c.id]; return (
{c.nombre} {c.cantidad} {c.unit || b.unit}
{hasF && ✓ Fórmula} {onOpenFormulas && }
); })}
); })}
); } // ─── USERS PANEL ─── function UsersPanel({ onClose }) { const [users, setUsers] = useState([]); const [loading, setLoading] = useState(true); const [creating, setCreating] = useState(false); const [saving, setSaving] = useState(null); const [editId, setEditId] = useState(null); const [form, setForm] = useState({ name:'', email:'', password:'', preset:'envasado', plants:[(window.SP_PLANT || 'caucho')] }); const [formErr, setFormErr] = useState(''); const [panelErr, setPanelErr] = useState(''); // error de la última operación del panel (servidor / red) const PLANT_OPTS = [['caucho','Caucho'], ['esmalte','Esmalte']]; const PRESETS = { envasado: { access_envasado_tab:true, check_matizacion:false, edit_control_proceso:false, export:true, change_dates:true }, matizacion: { check_matizacion:true, access_envasado_tab:false, edit_control_proceso:false, export:true, change_dates:true }, preparadores: { access_preparadores_tab:true, export:true, change_dates:true }, mantenimiento: { access_mantenimiento_tab:true, access_equipos_tab:true, export:true, change_dates:true }, control: { edit_planning:true, delete_planning:true, export:true, duplicate:true, change_dates:true, edit_galonaje_real:true, edit_envasado_select:true, check_envasado:true, edit_historial:true, access_envasado_tab:true, check_matizacion:true, edit_control_proceso:true }, }; const PERM_LABELS = [ ['edit_control_proceso', 'Control de proceso'], ['access_envasado_tab', 'Pestaña Envasado'], ['access_envasado_only', 'Solo Envasado (acceso restringido)'], ['access_moliendas_tab', 'Pestaña Moliendas'], ['access_equipos_tab', 'Ver Equipos'], ['access_mantenimiento_tab', 'Mantenimiento (registrar equipos, fallas e informes)'], ['access_backorden_tab', 'Pestaña Back Orden'], ['access_facturacion_tab', 'Facturación (dentro de Envasado)'], ['access_preparadores_tab', 'Pestaña Preparadores'], ['personal_full', 'Personal (completo)'], ['personal_basic', 'Personal (solo agregar/mover)'], ['access_consumo', 'Consumo de materia prima'], ['check_matizacion', 'Marcar Matización'], ['edit_planning', 'Editar planificación'], ['delete_planning', 'Eliminar entradas'], ['export', 'Exportar'], ['duplicate', 'Duplicar día'], ['change_dates', 'Cambiar fecha'], ['edit_galonaje_real', 'Galonaje real'], ['edit_envasado_select', 'Selección envasado'], ['check_envasado', 'Marcar envasado'], ['access_diaria_empaque', 'Solo Diaria: marcar empaquetado'], ['fix_historial', 'Corregir registros guardados'], ['manage_users', 'Gestionar usuarios'], ]; // window.spFetch (app.jsx) añade la cabecera CSRF y delete_key; si no existe, fetch normal. const _f = (url, opts = {}) => (window.spFetch || fetch)(url, { credentials:'include', ...opts }); const parseApi = async (r) => { const j = await r.json().catch(() => ({})); if (!r.ok || j.error) throw new Error(j.error || `HTTP ${r.status}`); return j; }; const post = (body) => _f('./api.php', { method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(body) }).then(parseApi); const errMsg = (e, ctx) => { const m = (e && e.message) || ''; if (m === 'delete_key_invalid') return 'Clave de eliminación incorrecta'; if (m === 'delete_key_not_configured') return 'Primero crea la clave de eliminación (tarjeta de arriba)'; if (/^Failed to fetch|NetworkError|Load failed/i.test(m) || !m) return `${ctx}: error de conexión con el servidor`; return `${ctx}: ${m}`; }; useEffect(() => { loadUsers(); }, []); const loadUsers = async () => { setLoading(true); try { const j = await _f('./api.php?action=users').then(parseApi); if (j.users) setUsers(j.users); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo cargar la lista de usuarios')); } setLoading(false); }; const handleCreate = async () => { if (!form.name.trim()) { setFormErr('Nombre requerido'); return; } if (!form.email.trim()) { setFormErr('Email requerido'); return; } if (form.password.length < 6) { setFormErr('Contraseña mínimo 6 caracteres'); return; } if (!form.plants || form.plants.length === 0) { setFormErr('Selecciona al menos una planta'); return; } setFormErr(''); setSaving('new'); try { const j = await post({ action:'add_user', name:form.name.trim(), email:form.email.trim(), password:form.password, permissions:{ ...PRESETS[form.preset] }, plants:form.plants }); if (j.success) { setForm({ name:'', email:'', password:'', preset:'envasado', plants:[(window.SP_PLANT || 'caucho')] }); setCreating(false); await loadUsers(); } else { setFormErr(j.error || 'Error al crear'); } } catch (e) { setFormErr(errMsg(e, 'Error al crear')); } setSaving(null); }; const togglePerm = async (user, key) => { const perms = { ...user.permissions, [key]: !user.permissions?.[key] }; setSaving(user.id); try { const j = await post({ action:'update_user', user_id:user.id, permissions:perms }); if (j.user) setUsers(prev => prev.map(u => u.id === user.id ? j.user : u)); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo cambiar el permiso')); } setSaving(null); }; const togglePlant = async (user, plant) => { const cur = Array.isArray(user.plants) ? user.plants : []; const next = cur.includes(plant) ? cur.filter(p => p !== plant) : [...cur, plant]; if (next.length === 0) return; // no dejar al usuario sin ninguna planta setSaving(user.id); try { const j = await post({ action:'update_user', user_id:user.id, plants:next }); if (j.user) setUsers(prev => prev.map(u => u.id === user.id ? j.user : u)); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo cambiar el acceso a plantas')); } setSaving(null); }; const applyPreset = async (user, preset) => { const perms = { ...user.permissions, ...PRESETS[preset] }; setSaving(user.id); try { const j = await post({ action:'update_user', user_id:user.id, permissions:perms }); if (j.user) setUsers(prev => prev.map(u => u.id === user.id ? j.user : u)); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo aplicar el preset')); } setSaving(null); }; const handleApprove = async (user) => { setSaving(user.id); try { const j = await post({ action:'approve_user', user_id:user.id }); if (j.success) setUsers(prev => prev.map(u => u.id === user.id ? { ...u, approved:true } : u)); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo aprobar al usuario')); } setSaving(null); }; const handleDelete = async (user) => { if (!window.verifyDeleteKey(`¿Eliminar a ${user.name}?`)) return; setSaving(user.id); try { const j = await post({ action:'delete_user', user_id:user.id }); if (j.success) setUsers(prev => prev.filter(u => u.id !== user.id)); setPanelErr(''); } catch (e) { setPanelErr(errMsg(e, 'No se pudo eliminar al usuario')); } setSaving(null); }; // ── Clave de eliminación (se cambia aquí; el servidor guarda solo un hash) ── const [dk, setDk] = useState({ open:false, configured:null, key:'', key2:'', pass:'', busy:false, msg:'', ok:false }); const dkLoad = async () => { try { const j = await _f('./api.php?action=delete_key_status').then(parseApi); setDk(d => ({ ...d, configured: !!j.configured })); } catch (_) { /* el estado es informativo */ } }; useEffect(() => { dkLoad(); }, []); const dkSave = async () => { if (dk.key.length < 6) return setDk(d => ({ ...d, ok:false, msg:'La clave debe tener al menos 6 caracteres' })); if (dk.key !== dk.key2) return setDk(d => ({ ...d, ok:false, msg:'Las dos claves no coinciden' })); if (!dk.pass) return setDk(d => ({ ...d, ok:false, msg:'Escribe tu contraseña de administrador para confirmar' })); setDk(d => ({ ...d, busy:true, msg:'' })); try { await post({ action:'delete_key_set', new_key: dk.key, admin_password: dk.pass }); setDk({ open:false, configured:true, key:'', key2:'', pass:'', busy:false, ok:true, msg:'Clave de eliminación actualizada' }); } catch (e) { setDk(d => ({ ...d, busy:false, ok:false, msg: errMsg(e, 'No se pudo cambiar la clave') })); } }; const operadors = users.filter(u => u.role !== 'admin'); return (
e.target === e.currentTarget && onClose()}>

Usuarios

{panelErr &&

{panelErr}

}
Clave de eliminación {dk.configured === null ? 'Comprobando…' : dk.configured ? 'Configurada. Se pide al eliminar máquinas, facturas, registros y similares.' : 'SIN CONFIGURAR: nadie puede eliminar hasta que crees la clave.'}
{dk.msg && !dk.open &&

{dk.msg}

} {dk.open && (
setDk(d => ({ ...d, key:e.target.value }))} /> setDk(d => ({ ...d, key2:e.target.value }))} /> setDk(d => ({ ...d, pass:e.target.value }))} onKeyDown={e => e.key === 'Enter' && dkSave()} /> {dk.msg &&

{dk.msg}

}
)}
{loading ? (

Cargando...

) : ( <> {operadors.length === 0 && !creating && (

Sin operadores registrados.

)}
{operadors.map(u => (
{u.name} {u.email}
{!u.approved && Pendiente} {Array.isArray(u.plants) && u.plants.includes('caucho') && Caucho} {Array.isArray(u.plants) && u.plants.includes('esmalte') && Esmalte} {u.permissions?.edit_control_proceso && Control} {u.permissions?.access_envasado_tab && Envasado} {u.permissions?.check_matizacion && Matización}
{!u.approved && ( )}
{editId === u.id && (
Acceso a plantas: {PLANT_OPTS.map(([pk, pl]) => ( ))}
Preset:
{PERM_LABELS.map(([key, label]) => ( ))}
)}
))}
{creating ? (
Nuevo operador
{[['envasado','Envasado'],['matizacion','Matización'],['preparadores','Preparadores'],['mantenimiento','Mantenimiento'],['control','Control']].map(([k,l]) => ( ))}
setForm(f=>({...f,name:e.target.value}))} placeholder="Nombre del operador" />
setForm(f=>({...f,email:e.target.value}))} placeholder="correo@empresa.com" />
setForm(f=>({...f,password:e.target.value}))} placeholder="Mínimo 6 caracteres" />
{PLANT_OPTS.map(([pk, pl]) => ( ))}
{formErr &&

{formErr}

}
) : ( )} )}
); } // ─── CONFIGURACIÓN EDITABLE (admin) ─────────────────────── // Edita las listas simples de data.jsx desde la página (marcas, líneas, // estados de fase, tipos de máquina) y las guarda en la nube por planta. function ConfigModal({ onSave, onOpenCatalog, onClose }) { const AD = window.AppData || {}; const [marcas, setMarcas] = useState(() => (AD.MARCAS || []).slice()); const [lineas, setLineas] = useState(() => (AD.LINEAS || []).map(l => ({ ...l }))); const [phases, setPhases] = useState(() => (AD.PHASE_STATUSES || []).map(p => ({ ...p }))); const [mtypes, setMtypes] = useState(() => { const mt = AD.MACHINE_TYPES || {}; const o = {}; Object.keys(mt).forEach(k => { o[k] = { name: mt[k].name || k, defaultPhases: (mt[k].defaultPhases || []).slice() }; }); return o; }); const [prodOv, setProdOv] = useState(() => (AD.PRODUCCION_OVERRIDES || []).slice()); // Texto crudo de "fases por defecto" por tipo de máquina: se parsea al salir del campo // (si se parseara en cada tecla, split/trim se comía las comas y los espacios al escribir). const [phasesRaw, setPhasesRaw] = useState(() => { const mt = AD.MACHINE_TYPES || {}; const o = {}; Object.keys(mt).forEach(k => { o[k] = (mt[k].defaultPhases || []).join(', '); }); return o; }); const parsePhases = (raw) => String(raw || '').split(',').map(x => x.trim()).filter(Boolean); const [tab, setTab] = useState('marcas'); const [saving, setSaving] = useState(false); const [saveErr, setSaveErr] = useState(''); const [exporting, setExporting] = useState(false); // Descarga un respaldo .sql con toda la base de datos (endpoint solo admin). const exportDb = async () => { setExporting(true); setSaveErr(''); try { const res = await (window.spFetch || fetch)('./api.php?action=db_export', { credentials: 'include' }); if (!res.ok) { let msg = 'HTTP ' + res.status; try { const j = await res.json(); if (j && j.error) msg = j.error; } catch (_) {} throw new Error(msg); } const blob = await res.blob(); const cd = res.headers.get('Content-Disposition') || ''; const m = /filename="?([^";]+)"?/.exec(cd); const a = document.createElement('a'); a.href = URL.createObjectURL(blob); a.download = m ? m[1] : 'respaldo_base_de_datos.sql'; document.body.appendChild(a); a.click(); a.remove(); setTimeout(() => URL.revokeObjectURL(a.href), 1000); } catch (err) { setSaveErr(`No se pudo exportar la base de datos: ${(err && err.message) || 'error desconocido'}.`); } setExporting(false); }; const save = async () => { setSaving(true); setSaveErr(''); const cfg = { marcas: marcas.map(m => (m || '').trim()).filter(Boolean), lineas: lineas.filter(l => (l.nombre || '').trim()).map(l => ({ id: l.id || ('l' + Math.random().toString(36).slice(2, 6)), nombre: l.nombre.trim(), color: l.color || '#3b6fd4' })), phaseStatuses: phases.filter(p => (p.label || '').trim()).map(p => ({ id: p.id || (p.label.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '')), label: p.label.trim(), bg: p.bg || '#eef1f7', fg: p.fg || '#535c78' })), machineTypes: Object.fromEntries(Object.entries(mtypes).map(([k, v]) => [k, { name: (v.name || '').trim() || k, defaultPhases: (k in phasesRaw) ? parsePhases(phasesRaw[k]) : (v.defaultPhases || []).map(x => (x || '').trim()).filter(Boolean) }])), produccionOverrides: prodOv.map(s => (s || '').trim().toUpperCase()).filter((v, i, a) => v && a.indexOf(v) === i), }; try { await onSave(cfg); } catch (err) { // No se cierra: el usuario conserva lo escrito y ve el motivo para reintentar. setSaveErr(`No se pudo guardar la configuración en el servidor: ${(err && err.message) || 'error desconocido'}. Revisa la conexión e inténtalo de nuevo.`); setSaving(false); return; } setSaving(false); onClose(); }; const inp = { padding: '6px 8px', border: '1px solid var(--bd)', borderRadius: 7, background: 'var(--bg)', color: 'inherit', fontSize: 13 }; const cbox = { width: 38, height: 32, border: '1px solid var(--bd)', borderRadius: 7, background: 'var(--bg)', padding: 0 }; const TABS = [['marcas', 'Marcas'], ['lineas', 'Líneas'], ['fases', 'Estados de fase'], ['maquinas', 'Tipos de máquina'], ['produccion', 'Producción / Matización'], ['catalogo', 'Bases y Colores']]; return (
e.target === e.currentTarget && onClose()}>
e.stopPropagation()} style={{ maxWidth: 720, width: '92%' }}>

⚙ Configuración

{TABS.map(([k, l]) => ( ))}
{tab === 'marcas' && (
{marcas.map((m, i) => (
setMarcas(a => a.map((x, j) => j === i ? e.target.value : x))} />
))}
)} {tab === 'lineas' && (
{lineas.map((l, i) => (
setLineas(a => a.map((x, j) => j === i ? { ...x, nombre: e.target.value } : x))} /> setLineas(a => a.map((x, j) => j === i ? { ...x, color: e.target.value } : x))} style={cbox} />
))}
)} {tab === 'fases' && (
{phases.map((p, i) => (
setPhases(a => a.map((x, j) => j === i ? { ...x, label: e.target.value } : x))} /> fondo setPhases(a => a.map((x, j) => j === i ? { ...x, bg: e.target.value } : x))} style={cbox} /> texto setPhases(a => a.map((x, j) => j === i ? { ...x, fg: e.target.value } : x))} style={cbox} />
))}
)} {tab === 'maquinas' && (
{Object.keys(mtypes).map(k => (
{k} setMtypes(o => ({ ...o, [k]: { ...o[k], name: e.target.value } }))} />
setPhasesRaw(o => ({ ...o, [k]: e.target.value }))} onBlur={() => setMtypes(o => ({ ...o, [k]: { ...o[k], defaultPhases: parsePhases(phasesRaw[k]) } }))} />
))}

Nota: el icono y qué acepta cada máquina se mantienen desde el código.

)} {tab === 'produccion' && (

Productos que en el reporte diario deben contarse como Producción (base) y NO como Matización, aunque estén catalogados como color. Escribe el nombre exacto del producto (ej: FONDO ANTIALCALINO).

{[...new Set((AD.CATALOGO || []).map(c => c.producto).filter(Boolean))].sort().map((p, i) => ( {prodOv.map((name, i) => (
setProdOv(a => a.map((x, j) => j === i ? e.target.value : x))} />
))} {prodOv.length === 0 && (

Sin excepciones: todos los colores se cuentan como Matización.

)}
)} {tab === 'catalogo' && (

Las bases y colores se editan en el editor de Catálogo.

{onOpenCatalog ? :

Requiere conexión con el servidor.

}
)}
{saveErr && {saveErr}} {tab !== 'catalogo' && }
); } window.ConfigModal = ConfigModal; // ─── NAV DRAWER ─── // Panel de navegación deslizante (overlay) — única forma de navegar entre // secciones. Recibe props de visibilidad por permisos (showX) más // open/onClose para controlarlo desde App. Al elegir una sección se // cierra automáticamente y dispara onView(...). function NavDrawer({ view, onView, open, onClose, currentUser, showMatizacion, showEnvasado, showDay, showWeek, showLista, showControl, showSupervisor, showEquipos, showMantenimiento, showBackorden, showPreparadores }) { const _day = showDay !== false; const _week = showWeek !== false; const _ctrl = showControl !== false; const _sup = showSupervisor !== false; const _eq = !!showEquipos; const select = (v) => { onView(v); if (onClose) onClose(); }; return ( <> {open &&
} ); } // ─── DAY HEADER ─── function DayHeader({ date, onDate, bases, onAddBase, onDuplicate, onPending, onEnvasadoSummary, onConsumo, onBaseFormulas }) { const f = fmtDate(date); const totalGL = bases.reduce((a,b) => b.status === 'cancelled' ? a : a + (b.cantidad||0), 0); const totalColors = bases.reduce((a,b) => a + b.colors.filter(c => !c.cancelled).length, 0); const doneColors = bases.reduce((a,b) => a + b.colors.filter(c => (!!c.checkEM || c.status==='ready') && !c.cancelled).length, 0); const progress = totalColors ? Math.round(doneColors/totalColors*100) : 0; const TIPO_GL_EQUIV = ENV_GL_FACTOR; const calcEnvGL = (arr) => (arr||[]).reduce((s,e) => s + Number(e.cantidad||0)*(TIPO_GL_EQUIV[e.tipo]||0), 0); const matizGL = bases.reduce((a,b) => { if (b.status === 'cancelled') return a; return a + b.colors.reduce((ca,c) => (!c.cancelled && c.checkMA) ? ca+(c.cantidad||0) : ca, 0); }, 0); const envasadoGL = bases.reduce((a,b) => { if (b.status === 'cancelled') return a; return a + b.colors.reduce((ca,c) => { if (c.cancelled || !c.checkEM) return ca; const src = (c.envasadoReal && c.envasadoReal.length > 0) ? c.envasadoReal : (c.envasado||[]); return ca + calcEnvGL(src); }, 0); }, 0); const dateInputRef = useRef(null); return ( <>
{onDate && (
)}
onDate && dateInputRef.current?.showPicker()} style={!onDate?{cursor:'default'}:{}}>
{String(f.day).padStart(2,'0')}
{f.dowFull} {f.my}
{onDate && onDate(e.target.value)}/>}
{onDate && date !== todayStr() && ( )}
{bases.length}
{window.t('Bases')}
{totalColors}
{window.t('Colores')}
{doneColors}
{window.t('Listos')}
{fmtNum(totalGL)}
{window.t('Galones')}
{matizGL > 0 &&
{fmtNum(matizGL)}
{window.t('Matización')}
} {envasadoGL > 0 &&
{fmtNum(envasadoGL)}
{window.t('Envasado')}
}
{progress}%
{window.t('Avance')}
{onBaseFormulas && } {onConsumo && } {onEnvasadoSummary && } {onPending && } {onDuplicate && } {onAddBase && }
); } // ─── FILTERS ─── function Filters({ filter, onFilter, search, onSearch, bases }) { const counts = useMemo(() => { const c = { all: bases.length, carryover: bases.filter(b => !!b.carryoverFrom).length }; AppData.TIPOS.forEach(t => c[t] = bases.filter(b => b.tipo === t).length); return c; }, [bases]); return (
{window.t('Tipo:')} {AppData.TIPOS.filter(t => counts[t] > 0).map(t => ( ))} {window.t('Estado:')} {counts.carryover > 0 && (<> {window.t('Planificado:')} )}
onSearch(e.target.value)}/>
); } // ─── INLINE EDIT ─── function InlineNumber({ value, onChange, suffix='GL', className='', nullable=false, placeholder='—' }) { const [v, setV] = useState(value); const [editing, setEditing] = useState(false); useEffect(() => { setV(value); }, [value]); // nullable: un campo vacío se entrega como null (no como 0), para que 0 sea un valor válido // (p. ej. GL real = 0) distinto de "sin dato". const commit = () => onChange(nullable && (v === '' || v == null) ? null : (Number(v) || 0)); if (!editing) { const empty = nullable && (v === '' || v == null); return ( setEditing(true)} title="Click para editar"> {empty ? placeholder : fmtNum(v)}{empty ? '' : suffix} ); } return ( setV(e.target.value)} onBlur={() => { commit(); setEditing(false); }} onKeyDown={e => { if(e.key==='Enter'){ commit(); setEditing(false); } if(e.key==='Escape'){setV(value);setEditing(false);} }} style={{width:80,textAlign:'right',fontWeight:700}} /> ); } function InlineText({ value, onChange, placeholder='', className='' }) { const [v, setV] = useState(value); const [editing, setEditing] = useState(false); useEffect(() => { setV(value); }, [value]); if (!editing) { return ( { e.stopPropagation(); setEditing(true); }} style={{cursor:'text'}}> {value || {placeholder}} ); } return ( e.stopPropagation()} onChange={e => setV(e.target.value)} onBlur={() => { onChange(v); setEditing(false); }} onKeyDown={e => { if(e.key==='Enter'){ onChange(v); setEditing(false); } if(e.key==='Escape'){setV(value);setEditing(false);} }} /> ); } // ─── ENVASADO PILLS ─── const TIPOS_ENV = [ { v: 'cu4', l: 'Cuñete 4GL' }, { v: 'cu5', l: 'Cuñete 5GL' }, { v: 'cu7', l: 'Cuñete 7.2GL' }, { v: 'gl', l: 'Galón (1GL)' }, { v: 'ku', l: '1/4 (1/4)' }, { v: 'pl', l: 'L (1L)' }, { v: 'pm', l: '0.5L (0.5L)' }, ]; const TIPO_ENV_LABEL = { cu4:'CU·4', cu5:'CU·5', cu7:'CU·7', gl:'GL', ku:'1/4', pl:'1L', pm:'0.5L' }; const TIPO_ENV_CLS = { cu4:'cu', cu5:'cu', cu7:'cu', gl:'gl', ku:'1/4', pl:'1L', pm:'0.5L' }; function EnvasadoPills({ color }) { const buildRows = (arr) => { const byBrand = {}; (arr || []).forEach(e => { const brand = e.marca || 'SIN MARCA'; if (!byBrand[brand]) byBrand[brand] = {}; byBrand[brand][e.tipo] = (byBrand[brand][e.tipo] || 0) + (e.cantidad || 0); }); return Object.entries(byBrand); }; const planRows = buildRows(color.envasado); const realRows = buildRows(color.envasadoReal); if (planRows.length === 0 && realRows.length === 0) return —; const renderBrandRows = (rows) => (
{rows.map(([brand, totals]) => (
{brand}
{['cu4','cu5','cu7','gl','ku','pl','pm'].filter(t => totals[t] > 0).map(t => ( {totals[t]} {TIPO_ENV_LABEL[t]} ))}
))}
); return (
Plan {planRows.length === 0 ? — : renderBrandRows(planRows)}
{realRows.length > 0 && (
Real {renderBrandRows(realRows)}
)}
); } // ─── ENVASADO REAL MODAL ─── const TIPO_REAL_OPTS = [ { value: 'cu4', label: 'CU·4 (4 GL)' }, { value: 'cu5', label: 'CU·5 (5 GL)' }, { value: 'cu7', label: 'CU·7 (7.2 GL)' }, { value: 'gl', label: 'GL (1 GL)' }, { value: 'ku', label: 'CUÑ/1/4 (0.25 GL)' }, { value: 'pl', label: 'L (1L)' }, { value: 'pm', label: '0.5L (0.5L)' }, ]; function EnvasadoRealModal({ entries, onChange, onConfirm, onCancel, colorName, error }) { const addEntry = () => onChange([...entries, { id: uid('re'), tipo: 'gl', cantidad: 0, marca: '' }]); const upd = (id, field, val) => onChange(entries.map(e => e.id === id ? { ...e, [field]: val } : e)); const del = (id) => onChange(entries.filter(e => e.id !== id)); return (
e.stopPropagation()}>

📦 Envasado Real — {colorName}

Confirma o ajusta las cantidades reales empaquetadas.

{entries.map(e => (
upd(e.id, 'cantidad', Number(ev.target.value))} className="inp" style={{width:72}} placeholder="Cant."/> upd(e.id, 'marca', ev.target.value)} className="inp" style={{flex:1}} placeholder="Marca"/>
))}
{error &&

{error}

}
); } // ─── COLOR ROW ─── function colorDeriveStatus(c) { if (c.checkEM) return 'ready'; if (c.checkEN || c.checkMA || c.checkEC) return 'running'; return 'pending'; } // Lógica compartida (escritorio y móvil) del check EM: marcar abre el modal de envasado real; // desmarcar pide confirmación antes de borrar lo registrado. Devuelve el handler y el modal. function useEnvasadoRealToggle(color, onUpdate, canToggle = true) { const [showRealModal, setShowRealModal] = useState(false); const [realEntries, setRealEntries] = useState([]); const [realError, setRealError] = useState(''); const chkEM = !!color.checkEM; const toggleEM = () => { if (!canToggle) return; if (!chkEM) { const prefill = (color.envasadoReal && color.envasadoReal.length > 0) ? color.envasadoReal.map(e => ({ ...e, id: e.id || uid('re') })) : (color.envasado || []).map(e => ({ ...e, id: uid('re') })); setRealEntries(prefill.length > 0 ? prefill : [{ id: uid('re'), tipo: 'gl', cantidad: 0, marca: '' }]); setRealError(''); setShowRealModal(true); } else { const hasReal = (color.envasadoReal && color.envasadoReal.length > 0) || !!color.completedAt; if (hasReal && !window.confirm('¿Desmarcar el empaquetado de este color?\n\nSe borrará el envasado real registrado.')) return; const status = color.checkEN || color.checkMA || color.checkEC ? 'running' : 'pending'; onUpdate({ ...color, checkEM: false, envasadoReal: [], status, completedAt: null }); } }; const confirmReal = () => { const valid = realEntries.filter(e => Number(e.cantidad) > 0); if (valid.length === 0) { // No se permite confirmar el empaquetado sin al menos una presentación con cantidad. setRealError('Agrega al menos una presentación con cantidad mayor a 0.'); return; } onUpdate({ ...color, checkEM: true, envasadoReal: valid, status: 'ready', completedAt: syncedNowIso() }); setShowRealModal(false); setRealError(''); }; const modal = showRealModal ? ( { setRealEntries(v); setRealError(''); }} onConfirm={confirmReal} onCancel={() => { setShowRealModal(false); setRealError(''); }} colorName={color.nombre} error={realError} /> ) : null; return { toggleEM, modal }; } function ColorRow({ color, onUpdate, onDelete, canToggleEnvasado, canEditColor = true, singleColor }) { const chkEC = !!color.checkEC; const chkMA = !!color.checkMA; const chkEN = !!color.checkEN; const chkEM = !!color.checkEM; const isCancelled = !!color.cancelled; const isDone = chkEM; const showMA = color.tipoColor === 'con_matizacion'; const canToggle = canToggleEnvasado !== false; const { toggleEM, modal: realModal } = useEnvasadoRealToggle(color, onUpdate, canToggle); const toggleCancelled = () => { onUpdate({ ...color, cancelled: !isCancelled }); }; const statusLabel = isCancelled ? '✕ Cancelado' : chkEM ? '✓ Completo' : chkEN ? 'Listo p/Env.' : chkMA ? 'Matización' : chkEC ? 'En máquina' : 'Pendiente'; const statusCls = isCancelled ? 'cancelled' : chkEM ? 'ready' : (chkEN || chkMA || chkEC) ? 'running' : 'pending'; return ( <>
EC {showMA && MA} EN EM
{canEditColor ? onUpdate({...color, nombre:v})}/> : color.nombre} {color.tipoColor === 'con_matizacion' && C/Mat} {color.catalogoRef && {color.catalogoRef}} {color.notas &&
{color.notas}
}
{canEditColor ? onUpdate({...color, lote:v})} placeholder="—"/> : (color.lote || '—')}
{canEditColor ? onUpdate({...color, cantidad:v})} suffix={color.unit}/> : {color.cantidad} {color.unit}}
{canEditColor ? onUpdate({...color, glReal: v})} suffix={color.unit} placeholder="—"/> : {color.glReal != null ? `${color.glReal} ${color.unit}` : '—'}}
{statusLabel}
{canEditColor && } {canEditColor && ( )} {onDelete && }
{realModal} ); } // ─── BASE CARD ─── function BaseCard({ base, inMachine = false, finishedInMachine = false, expanded, onToggle, onUpdate, onDelete, onAddColor, onUpdateColor, onDeleteColor, onEditColor, canToggleEnvasado, canEditColor = true, onCancelBase, reorderable = false, isDragging = false, isDragOver = false, onBaseDragStart, onBaseDragEnter, onBaseDrop, onBaseDragEnd }) { // Contadores: solo colores activos (los cancelados no cuentan) y "listo" = checkEM o status ready. const activeColors = base.colors.filter(c => !c.cancelled); const totalGL = activeColors.reduce((a,c) => a + (c.cantidad||0), 0); const doneCount = activeColors.filter(c => c.checkEM || c.status === 'ready').length; const pct = activeColors.length ? doneCount/activeColors.length*100 : 0; const singleColor = base.colors.length === 1; const cardRef = useRef(null); const dragProps = reorderable ? { onDragOver: (e) => { e.preventDefault(); if (e.dataTransfer) e.dataTransfer.dropEffect = 'move'; }, onDragEnter: (e) => { e.preventDefault(); onBaseDragEnter && onBaseDragEnter(base.id); }, onDrop: (e) => { e.preventDefault(); onBaseDrop && onBaseDrop(base.id); }, } : {}; return (
{reorderable && (
e.stopPropagation()} onDragStart={e => { e.stopPropagation(); if (e.dataTransfer) { e.dataTransfer.effectAllowed = 'move'; try { e.dataTransfer.setData('text/plain', base.id); } catch (_) {} if (cardRef.current) { try { e.dataTransfer.setDragImage(cardRef.current, 24, 24); } catch (_) {} } } onBaseDragStart && onBaseDragStart(base.id); }} onDragEnd={e => { e.stopPropagation(); onBaseDragEnd && onBaseDragEnd(); }} title="Arrastra para reordenar esta base" >
)}
{base.code} onUpdate({...base, nombre:v})}/> {base.descripcion && — {base.descripcion}} {base.status === 'cancelled' ? window.t('CANCELADO') : base.tipo}
{window.t('Lote')} {base.lote} {base.linea && · {base.linea}} {base.operador && · {base.operador}} · {activeColors.length} {activeColors.length!==1 ? window.t('colores') : window.t('color')} {base.carryoverFrom && ( ↩ {window.t('pendiente del')} {new Date(base.carryoverFrom + 'T12:00:00').toLocaleDateString('es', { day:'2-digit', month:'short' })} )}
{(base.checkEC || inMachine || finishedInMachine) && EC} {(base.checkFN || finishedInMachine) && FN}
{doneCount}/{activeColors.length}
onUpdate({...base, cantidad:v})} suffix={base.unit}/>
e.stopPropagation()}> {onCancelBase && base.status !== 'cancelled' && ( )} {onCancelBase && base.status === 'cancelled' && ( )} {onDelete && }
{window.t('Checks')}
{window.t('Color')}
{window.t('Lote')}
{window.t('GL Plan')}
{window.t('GL Real')}
{window.t('Envasado')}
{window.t('Estado')}
{base.colors.map(c => ( onUpdateColor(base.id, cu)} onDelete={onDeleteColor ? (() => onDeleteColor(base.id, c.id)) : null} singleColor={singleColor} canToggleEnvasado={canToggleEnvasado} canEditColor={canEditColor} /> ))} {onAddColor && (
onAddColor(base.id)}> Agregar color a esta base
)}
Total base {base.code} {totalGL} {base.unit || 'GL'} · {activeColors.length} color{activeColors.length !== 1 ? 'es' : ''}
); } // ─── SEARCH SELECT (combobox con búsqueda) ─── function SearchSelect({ value, onChange, options, placeholder, allowCustom, disabled }) { const [query, setQuery] = useState(value || ''); const [open, setOpen] = useState(false); const wrapRef = useRef(null); useEffect(() => { setQuery(value || ''); }, [value]); const filtered = useMemo(() => { const words = (query || '').toLowerCase().trim().split(/\s+/).filter(Boolean); if (!words.length) return options.slice(0, 60); return options.filter(o => { const haystack = o.toLowerCase(); return words.every(w => haystack.includes(w)); }).slice(0, 60); }, [options, query]); const exactMatch = options.some(o => o.toLowerCase() === (query || '').toLowerCase().trim()); const showCustom = allowCustom && (query || '').trim() && !exactMatch; useEffect(() => { const handler = (e) => { if (wrapRef.current && !wrapRef.current.contains(e.target)) { setOpen(false); if (!allowCustom && !options.includes(query)) setQuery(value || ''); } }; document.addEventListener('mousedown', handler); return () => document.removeEventListener('mousedown', handler); }, [query, value, allowCustom, options]); const select = (opt) => { onChange(opt); setQuery(opt); setOpen(false); }; if (disabled) return ; return (
{ setQuery(e.target.value); setOpen(true); if (allowCustom) onChange(e.target.value); }} onFocus={() => setOpen(true)} placeholder={placeholder || 'Buscar…'} style={{width:'100%'}} autoComplete="off" /> {open && (filtered.length > 0 || showCustom) && (
{filtered.map(o => (
{ e.preventDefault(); select(o); }} > {o}
))} {showCustom && (
{ e.preventDefault(); select((query || '').trim()); }} > ➕ Crear: "{(query || '').trim()}"
)}
)}
); } // ─── BASE MODAL ─── function BaseModal({ base, onSave, onClose }) { const isNew = !base; const [data, setData] = useState(base || { code: '', nombre: 'BLANCO', descripcion: '', tipo: 'CAUCHO', cantidad: 100, unit: 'GL', lote: '', status: 'planned', operador: '', linea: '', colors: [] }); const set = (k,v) => setData(d => ({...d, [k]:v})); const canSave = !!(data.nombre && data.nombre.trim()) && !!(data.lote && data.lote.trim()); // Al EDITAR solo se entregan los campos que el usuario realmente cambió del formulario // (más el id). El llamador los fusiona sobre la base ACTUAL del plan: así no se pisan // colors ni campos de avance (checks, estado puesto por Control...) con la copia vieja // con la que se abrió el modal mientras otros usuarios/Control seguían trabajando. const BASE_FORM_FIELDS = ['code', 'tipo', 'nombre', 'cantidad', 'unit', 'lote', 'status']; const submit = () => { if (isNew) { onSave(data); return; } const patch = { id: base.id }; BASE_FORM_FIELDS.forEach(k => { if (data[k] !== base[k]) patch[k] = data[k]; }); onSave(patch); }; return (
e.stopPropagation()}>

{isNew ? '➕ Nueva Base' : '✏ Editar Base'}

set('code', e.target.value)} placeholder="458-1, 459-1"/>
set('nombre', v)} options={AppData.BASES_UNICAS} placeholder="Buscar base…" allowCustom={false} />
set('cantidad', Number(e.target.value)||0)}/>
set('lote', e.target.value)} placeholder="4494" className={!data.lote?.trim() ? 'field-required-empty' : ''} />
{!canSave && Completa Nombre y Lote}
); } // ─── COLOR MODAL ─── function ColorModal({ color, baseNombre, onSave, onClose, canEditEnvasado, canEditGalonaje, canCheckEnvasado }) { const isNew = !color; const coloresDisponibles = React.useMemo(() => { if (!baseNombre) return AppData.COLOR_BASES; const productos = AppData.CATALOGO .filter(e => e.base === baseNombre) .map(e => e.producto); return productos.length > 0 ? productos : AppData.COLOR_BASES; }, [baseNombre]); const [data, setData] = useState(() => { const initial = color ? { ...color } : { id: uid('c'), nombre: '', cantidad: 0, unit: 'GL', lote: '', status: 'pending', envasado: [], notas: '', hex: '#cccccc', catalogoRef: null, tipoColor: 'sin_matizacion', checkEC: false, checkMA: false, checkEN: false, checkEM: false, cancelled: false }; if (!initial.nombre && coloresDisponibles.length > 0) { initial.nombre = coloresDisponibles[0]; } if (!initial.tipoColor) initial.tipoColor = 'sin_matizacion'; return initial; }); const set = (k,v) => setData(d => ({...d, [k]:v})); const canSaveColor = !!(data.nombre && data.nombre.trim()); const addEnv = () => setData(d => ({ ...d, envasado: [...(d.envasado||[]), {id: uid('e'), tipo:'cu4', cantidad:0, marca:'ARADOS'}] })); const updateEnv = (id, patch) => setData(d => ({ ...d, envasado: d.envasado.map(e => e.id===id ? {...e,...patch} : e) })); const removeEnv = (id) => setData(d => ({ ...d, envasado: d.envasado.filter(e => e.id!==id) })); const calcGL = (arr) => (arr||[]).reduce((acc, e) => { const q = Number(e.cantidad || 0); return acc + q * (ENV_GL_FACTOR[e.tipo] || 0); }, 0); const totalEqGL = calcGL(data.envasado); // En modo restringido (envasado), los campos principales son de solo lectura const restrictedMode = canEditEnvasado !== undefined || canEditGalonaje !== undefined; const mainFieldsEditable = !restrictedMode; return (
e.stopPropagation()}>

{isNew ? '➕ Nuevo Color' : '✏ Editar Color'}

{restrictedMode && Envasado}
{/* NOMBRE */}
mainFieldsEditable && set('nombre', v)} options={coloresDisponibles} placeholder="Buscar o escribir nuevo color…" allowCustom={true} disabled={!mainFieldsEditable} />
{/* TIPO DE COLOR */}
{/* COLOR / CANTIDAD / LOTE */}
mainFieldsEditable && set('hex', e.target.value)} disabled={!mainFieldsEditable} style={{height:36,padding:2}} />
mainFieldsEditable && set('cantidad', Number(e.target.value)||0)} />
mainFieldsEditable && set('lote', e.target.value)} placeholder="4534" />
{/* ENVASADO PLANIFICADO */}
{TIPOS_ENV.map(tipo => { const rows = (data.envasado || []).filter(e => e.tipo === tipo.v); const canEdit = canEditEnvasado !== false; return (
{tipo.l}
{rows.length === 0 &&
Sin marcas agregadas
} {rows.map(e => (
canEdit && updateEnv(e.id, {cantidad:Number(ev.target.value)||0})} placeholder="0"/> {canEdit && }
))} {canEdit && ( )}
); })}
GL = x1 · CUÑ(4GL) = x4 · 5GL = x5 · 7,2 = x2 · 1/4 = x0.25 · 1L = x0.264 · 0.5L = x0.132 {' '}| Total planificado: {fmtNum(totalEqGL)} GL
{/* FOOTER */}
{!canSaveColor && Ingresa el nombre del color}
); } // ─── PENDING YESTERDAY MODAL ─── function PendingYesterdayModal({ yesterday, pendingBases, onBring, onClose }) { const [selected, setSelected] = useState(new Set(pendingBases.map(b => b.id))); const f = fmtDate(yesterday); const toggle = (id) => setSelected(prev => { const next = new Set(prev); if (next.has(id)) next.delete(id); else next.add(id); return next; }); const toggleAll = () => { if (selected.size === pendingBases.length) setSelected(new Set()); else setSelected(new Set(pendingBases.map(b => b.id))); }; return (
e.stopPropagation()}>
Pendientes del {f.dowFull} {f.day} de {f.month}
Selecciona las bases que deseas traer al plan de hoy
{selected.size === pendingBases.length ? 'Deseleccionar todo' : 'Seleccionar todo'}
{pendingBases.map(b => { const colors = b.colors || []; const doneColors = colors.filter(c => c.checkEM || c.status === 'ready'); const pendingColors = colors.filter(c => !c.checkEM && c.status !== 'ready' && !c.cancelled); const pendingGL = pendingColors.reduce((sum, c) => sum + (c.cantidad || 0), 0); const isSelected = selected.has(b.id); const isCancelled = b.status === 'cancelled'; return (
toggle(b.id)} > { e.stopPropagation(); toggle(b.id); }} />
{b.tipo || 'BASE'} {b.nombre} {isCancelled && ( CANCELADA )} {b.carryoverFrom && ( ↩ del {fmtDate(b.carryoverFrom).day} {fmtDate(b.carryoverFrom).month.toLowerCase().slice(0,3)} )}
{b.code} Lote {b.lote} {pendingGL} {b.unit} pendientes {pendingColors.length > 0 && ( {pendingColors.length} color{pendingColors.length !== 1 ? 'es' : ''} sin empaquetado )} {doneColors.length > 0 && ( {doneColors.length} ya completado{doneColors.length !== 1 ? 's' : ''} )}
{doneColors.length > 0 && (
Solo se traerán los {pendingColors.length} colores sin empaquetado
)}
); })}
); } // ─── SELECCIÓN DE BASES PARA IMPRIMIR ─── const PRINTED_BASES_KEY = 'sp_printed_bases_v1'; function loadPrintedBases(date) { try { const raw = localStorage.getItem(PRINTED_BASES_KEY); if (raw) { const all = JSON.parse(raw); return new Set(all[date] || []); } } catch (_) {} return new Set(); } function savePrintedBases(date, ids) { try { const raw = localStorage.getItem(PRINTED_BASES_KEY); const all = raw ? JSON.parse(raw) : {}; all[date] = ids; // Poda: conserva solo las 200 fechas más recientes (las claves son YYYY-MM-DD) para que // el historial de "ya impresas" no crezca sin límite en localStorage. const keys = Object.keys(all).sort(); if (keys.length > 200) keys.slice(0, keys.length - 200).forEach(k => { delete all[k]; }); localStorage.setItem(PRINTED_BASES_KEY, JSON.stringify(all)); } catch (_) {} } function PrintSelectModal({ bases, date, onPrint, onClose }) { // Bases que ya se imprimieron hoy (memoria local por fecha). const printedRef = useRef(loadPrintedBases(date)); const printed = printedRef.current; // Por defecto se marcan solo las bases que aún NO se han impreso hoy. // Si todas ya se imprimieron, se marcan todas para que imprimir siga funcionando. const [selected, setSelected] = useState(() => { const notPrinted = bases.filter(b => !printed.has(b.id)).map(b => b.id); return new Set(notPrinted.length ? notPrinted : bases.map(b => b.id)); }); const toggle = (id) => setSelected(prev => { const next = new Set(prev); if (next.has(id)) next.delete(id); else next.add(id); return next; }); // Mostrar/ocultar el detalle de colores de cada base en la vista previa. const [showColors, setShowColors] = useState(false); // Bases marcadas manualmente para imprimir con la letra oscurecida / resaltada. const [emphasized, setEmphasized] = useState(() => new Set()); const toggleEmph = (id) => setEmphasized(prev => { const next = new Set(prev); if (next.has(id)) next.delete(id); else next.add(id); return next; }); // Total de galonaje (colores activos) de una base. const baseGL = (b) => (b.colors || []) .filter(c => !c.cancelled) .reduce((s, c) => s + (c.cantidad || 0), 0); // Bases seleccionadas (en el mismo orden) para la vista previa en vivo. const selectedBases = bases.filter(b => selected.has(b.id)); const previewTotalGL = selectedBases.reduce((s, b) => s + baseGL(b), 0); const allSelected = selected.size === bases.length; const toggleAll = () => { if (allSelected) setSelected(new Set()); else setSelected(new Set(bases.map(b => b.id))); }; const clearPrinted = () => { printedRef.current = new Set(); savePrintedBases(date, []); setSelected(new Set(bases.map(b => b.id))); }; const doPrint = () => { const ids = [...selected]; if (!ids.length) return; // Acumular las impresas para no volver a marcarlas por defecto la próxima vez. const merged = new Set([...printed, ...ids]); savePrintedBases(date, [...merged]); // Solo enviamos como oscurecidas las bases que además están seleccionadas. const emphIds = ids.filter(id => emphasized.has(id)); // showColors controla también si la impresión incluye el detalle de colores. onPrint(ids, emphIds, showColors); }; const anyPrinted = bases.some(b => printed.has(b.id)); return (
e.stopPropagation()}>
Imprimir plan diario
Selecciona las bases; usa A para oscurecer la letra. Revisa el resultado en la vista previa.
{allSelected ? 'Deseleccionar todo' : 'Seleccionar todo'} {anyPrinted && ( )}
{bases.map(b => { const colors = b.colors || []; const activeCols = colors.filter(c => !c.cancelled); const totalGL = activeCols.reduce((s, c) => s + (c.cantidad || 0), 0); const isSelected = selected.has(b.id); const isCancelled = b.status === 'cancelled'; const wasPrinted = printed.has(b.id); const isEmph = emphasized.has(b.id); return (
toggle(b.id)} > { e.stopPropagation(); toggle(b.id); }} />
{b.tipo || 'BASE'} {b.nombre} {isCancelled && ( CANCELADA )} {wasPrinted && ( ✓ Impresa )}
{b.code} Lote {b.lote} {activeCols.length} color{activeCols.length !== 1 ? 'es' : ''} {totalGL} {b.unit || 'GL'}
); })}
Vista previa {selectedBases.length} base{selectedBases.length !== 1 ? 's' : ''} · {previewTotalGL} GL
{showColors ? 'Se imprimirá con los colores' : 'Se imprimirá solo bases + galonaje'}
{selectedBases.length === 0 ? (
Selecciona una o más bases para ver aquí lo que se imprimirá.
) : ( selectedBases.map(b => { const isEmph = emphasized.has(b.id); const activeCols = (b.colors || []).filter(c => !c.cancelled); const nCols = activeCols.length; return (
{b.code} {b.nombre} {nCols} col. {baseGL(b)} {b.unit || 'GL'}
{showColors && (
{nCols === 0 ? (
Sin colores
) : ( activeCols.map(c => (
{c.nombre || '—'} {c.cantidad > 0 ? c.cantidad : '—'} {b.unit || 'GL'}
)) )}
)}
); }) )}
{selectedBases.length > 0 && (
Total {previewTotalGL} GL
)}
); } // ─── WEEK VIEW ─── function WeekView(props) { const { allPlan, currentDate, onDate, onView, machines = [] } = props; const start = startOfWeek(currentDate); const days = Array.from({length:7}, (_,i) => shiftDate(start, i)); const today = todayStr(); const { schedules = {}, onScheduleChange } = props; const [editingDay, setEditingDay] = useState(null); const [selectedDay, setSelectedDay] = useState(null); const getSchedule = (d) => ({ start: '08:00', end: schedules[d]?.end || '17:00', breaks: schedules[d]?.breaks || [] }); const setDayEnd = (d, end) => { const cur = schedules[d] || {}; const next = { ...schedules, [d]: { ...cur, end } }; if (onScheduleChange) onScheduleChange(next); }; const setDayBreaks = (d, breaks) => { const cur = schedules[d] || {}; const next = { ...schedules, [d]: { ...cur, breaks } }; if (onScheduleChange) onScheduleChange(next); }; const toMins = (t) => { if (!t) return null; const [h, m] = t.split(':').map(Number); if (isNaN(h) || isNaN(m)) return null; return h * 60 + m; }; const fmtMins = (m) => { if (m === null || m === undefined) return '—'; const h = Math.floor(m / 60), min = m % 60; if (h === 0) return `${min}m`; return min > 0 ? `${h}h ${min}m` : `${h}h`; }; const GL_FACTOR_W = ENV_GL_FACTOR; let totalBases = 0, totalColors = 0, totalGLDone = 0, totalDone = 0, totalPending = 0; let totalEnvasadoGL = 0, totalEmpaquetados = 0; days.forEach(d => { const bases = (allPlan[d] || []).filter(b => b.status !== 'cancelled'); totalBases += bases.length; bases.forEach(b => { const activeCols = b.colors.filter(c => !c.cancelled); totalColors += activeCols.length; const done = activeCols.filter(c => c.checkEM || c.status === 'ready').length; totalDone += done; totalPending += activeCols.length - done; if (activeCols.length > 0) totalGLDone += (b.cantidad || 0) * done / activeCols.length; activeCols.forEach(c => { (c.envasado || []).forEach(e => { totalEnvasadoGL += Number(e.cantidad || 0) * (GL_FACTOR_W[e.tipo] || 0); }); if (c.checkEM) totalEmpaquetados++; }); }); }); const progress = totalColors ? Math.round(totalDone/totalColors*100) : 0; const calcMachineStats = (dateSet) => { const byCode = {}; const turnAdded = new Set(); const addEntry = (key, mName, mType, entry) => { if (!byCode[key]) byCode[key] = { code: key, name: mName, type: mType, batches: 0, gl: 0, activeMins: 0, turnMins: 0, hasTimeData: false }; const s = byCode[key]; s.batches += 1; (entry.assignments || []).forEach(a => { s.gl += Number(a.cantidad || 0); }); const entryDate = entry.fecha; const turnKey = `${key}|${entryDate}`; if (entryDate && !turnAdded.has(turnKey)) { const sched = getSchedule(entryDate); const breakMins = (sched.breaks || []).reduce((a, b) => { const bs = toMins(b.start), be = toMins(b.end); return (bs !== null && be !== null) ? a + Math.max(0, be - bs) : a; }, 0); s.turnMins += Math.max(0, (toMins(sched.end) || 17*60) - (toMins(sched.start) || 8*60) - breakMins); turnAdded.add(turnKey); } (entry.phases || []).forEach(p => { const pDate = p.phaseDate || entryDate; if (!dateSet.has(pDate)) return; // Esta fase pertenece a otro día if (p.startTime && p.endTime) { const st = toMins(p.startTime), en = toMins(p.endTime); if (st !== null && en !== null) { let diff = en - st; if (diff < 0) diff += 1440; s.activeMins += diff; s.hasTimeData = true; } } else if (p.computedMins > 0) { s.activeMins += p.computedMins; s.hasTimeData = true; } }); }; machines.forEach(m => { const key = m.code || m.id; // Garantizar que la máquina siempre aparezca, aunque no tenga actividad en el período if (!byCode[key]) byCode[key] = { code: key, name: m.name, type: m.type, batches: 0, gl: 0, activeMins: 0, turnMins: 0, hasTimeData: false }; if (dateSet.has(m.fecha)) addEntry(key, m.name, m.type, m); (m.history || []).forEach(snap => { const snapDate = snap.fecha || snap.timestamp?.slice(0,10); if (snapDate && dateSet.has(snapDate)) addEntry(key, m.name, m.type, snap); }); // Barrer fases con phaseDate de entries cuyo fecha principal no está en dateSet (vista diaria) const allEntries = [m, ...(m.history || [])]; allEntries.forEach(entry => { if (entry.fecha && dateSet.has(entry.fecha)) return; // Ya procesado por addEntry (entry.phases || []).forEach(p => { const pDate = p.phaseDate; if (!pDate || !dateSet.has(pDate) || !p.startTime || !p.endTime) return; const st = toMins(p.startTime), en = toMins(p.endTime); if (st !== null && en !== null) { let diff = en - st; if (diff < 0) diff += 1440; byCode[key].activeMins += diff; byCode[key].hasTimeData = true; } }); }); }); return Object.values(byCode).sort((a,b) => b.gl - a.gl || b.batches - a.batches); }; const machineStats = useMemo(() => { const dateSet = selectedDay ? new Set([selectedDay]) : new Set(days); return calcMachineStats(dateSet); }, [machines, selectedDay, days.join(','), schedules]); const machineTotals = machineStats.reduce((acc, s) => ({ batches: acc.batches + s.batches, gl: acc.gl + s.gl, turnMins: acc.turnMins + s.turnMins, activeMins: acc.activeMins + s.activeMins, hasTimeData: acc.hasTimeData || s.hasTimeData, }), { batches:0, gl:0, turnMins:0, activeMins:0, hasTimeData:false }); const TYPE_SHORT = { dispersor:'Dispersor', dispersor1:'Disp. Mat.', dispersorp:'Disp. Pasta', envasado:'Envasado', mezclador:'Mezclador', molino:'Molino', empaquetadora:'Empaquetadora' }; return (
{/* ── RESUMEN ── */}
{totalBases}
Bases planificadas
{totalColors}
Colores totales
{fmtNum(Math.round(totalGLDone))}
GL producidos
{progress}%
Avance semanal
{days.map(d => { const cols = (allPlan[d] || []).flatMap(b => b.colors.filter(c => !c.cancelled)); const pct = cols.length ? Math.round(cols.filter(c => c.checkEM || c.status==='ready').length/cols.length*100) : null; return (
0?'var(--or)':'var(--bd)'}}/> {fmtDate(d).dow}
); })}
{totalPending}
Colores pendientes
{fmtNum(Math.round(totalEnvasadoGL))}
GL envasado
{totalEmpaquetados}
Empaquetados
{/* ── CALENDARIO ── */}
{days.map(d => { const bases = allPlan[d] || []; const activeBases = bases.filter(b => b.status !== 'cancelled'); const f = fmtDate(d); const isToday = d === today; const isEmpty = bases.length === 0; const totalDayGL = activeBases.reduce((a,b) => a + (b.cantidad||0), 0); const sched = getSchedule(d); const hasBreaks = (sched.breaks || []).length > 0; const isExtended = sched.end !== '17:00' || hasBreaks; const isSelected = selectedDay === d; return (
setSelectedDay(isSelected ? null : d)}> {f.dow} {f.day}
{ e.stopPropagation(); setEditingDay(editingDay===d?null:d); }} title="Clic para ajustar horario del día"> ⏱ {sched.start}–{sched.end} {hasBreaks && · {sched.breaks.length} desc.}
{editingDay === d && (
e.stopPropagation()}> setDayEnd(d, e.target.value)}/>
{(sched.breaks || []).map((brk, i) => (
{ const b=[...(sched.breaks||[])]; b[i]={...b[i],start:ev.target.value}; setDayBreaks(d,b); }}/> – { const b=[...(sched.breaks||[])]; b[i]={...b[i],end:ev.target.value}; setDayBreaks(d,b); }}/>
))}
)}
{bases.slice(0,5).map(b => (
{b.code} · {b.nombre} {b.status !== 'cancelled' && {fmtNum(b.cantidad)}}
))} {bases.length > 5 &&
+{bases.length-5} más
} {isEmpty &&
Sin planificación
}
Total {fmtNum(totalDayGL)} GL {onDate && { e.stopPropagation(); onDate(d); onView('day'); }} title="Ir al día">→}
); })}
{/* ── RENDIMIENTO DE MÁQUINAS ── */} {(machineStats.length > 0 || selectedDay) && (
{selectedDay ? 'Rendimiento de Máquinas — ' + fmtDate(selectedDay).dowFull + ' ' + fmtDate(selectedDay).day : 'Rendimiento de Máquinas — Semana completa' } {selectedDay ? : Haz clic en un día del calendario para ver métricas de ese día }
{machineStats.map(s => { const inactive = s.hasTimeData ? Math.max(0, s.turnMins - s.activeMins) : null; const eff = s.hasTimeData && s.turnMins > 0 ? Math.min(100, Math.round(s.activeMins/s.turnMins*100)) : null; const effCls = eff === null ? '' : eff >= 70 ? 'eff-good' : eff >= 40 ? 'eff-warn' : 'eff-bad'; return ( ); })} {machineStats.length > 1 && (() => { const tTurn = machineTotals.turnMins; const tActive = machineTotals.activeMins; const tIdle = machineTotals.hasTimeData ? Math.max(0, tTurn - tActive) : null; const tEff = machineTotals.hasTimeData && tTurn > 0 ? Math.min(100, Math.round(tActive/tTurn*100)) : null; const effCls = tEff === null ? '' : tEff >= 70 ? 'eff-good' : tEff >= 40 ? 'eff-warn' : 'eff-bad'; return ( ); })()}
Máquina Tipo Batches GL asignados Turno total Tiempo activo Tiempo inactivo Eficiencia
{s.code} {TYPE_SHORT[s.type] || s.type} {s.batches} {fmtNum(s.gl)} GL {fmtMins(s.turnMins)} {s.hasTimeData ? fmtMins(s.activeMins) : Sin datos} {inactive !== null ? fmtMins(inactive) : Sin datos} {eff !== null ? {eff}% : Sin datos}
TOTAL {machineTotals.batches} {fmtNum(machineTotals.gl)} GL {fmtMins(tTurn)} {machineTotals.hasTimeData ? {fmtMins(tActive)} : Sin datos} {tIdle !== null ? {fmtMins(tIdle)} : Sin datos} {tEff !== null ? {tEff}% : Sin datos}
)}
); } // ─── PRINT SETTINGS PANEL ─── function PrintSettingsPanel({ settings, profiles, defaultSettings, onSettings, onSave, onLoad, onDelete, onClose }) { const [profileName, setProfileName] = useState(''); const [selectedProfile, setSelectedProfile] = useState(''); const update = (key, val) => onSettings(prev => ({ ...prev, [key]: val })); const handleLoad = (name) => { setSelectedProfile(name); if (name) onLoad(name); }; const handleSave = () => { const name = profileName.trim(); if (!name) return; onSave(name); setSelectedProfile(name); setProfileName(''); }; const handleDelete = () => { if (!window.verifyDeleteKey(`¿Eliminar el perfil "${selectedProfile}"?`)) return; onDelete(selectedProfile); setSelectedProfile(''); }; const Ctrl = ({ k, label, min, max, step, unit }) => (
{label} {settings[k]}{unit}
update(k, Number(e.target.value))} />
); return (
e.stopPropagation()}>
Configurar Impresión
{/* Perfiles */}
setProfileName(e.target.value)} onKeyDown={e => e.key === 'Enter' && handleSave()} /> {selectedProfile && ( )}
{/* Controles */}
📄 Página
🔤 Tipografía — Bases
🎨 Tipografía — Colores
📐 Espaciado
👁 Columnas visibles
{[ { k:'showColor', label:'Nombre del color' }, { k:'showLote', label:'Lote' }, { k:'showCantidad', label:'Cantidad (GL Plan + GL Real)' }, { k:'showEnvasado', label:'Envasado' }, { k:'showEstado', label:'Estado' }, { k:'showNotas', label:'Notas / observaciones' }, ].map(({ k, label }) => ( ))}
🏷 Campos de base
{[ { k:'showBaseCode', label:'Código de base' }, { k:'showPlanta', label:'Planta / línea de producción' }, ].map(({ k, label }) => ( ))}
✨ Extras de impresión
{[ { k:'showLogo', label:'Logo / membrete de empresa' }, { k:'showBaseTotal', label:'Total por base (GL + colores)' }, { k:'showDayTotal', label:'Total general del día' }, ].map(({ k, label }) => ( ))}
); } // ─── PRINT FOOTER ─── function PrintFooter({ date, bases }) { const f = fmtDate(date); const allBases = (bases || []).filter(b => b.status !== 'cancelled'); // los cancelados no cuentan const totalGL = allBases.reduce((a, b) => a + (b.cantidad || 0), 0); const totalColors = allBases.reduce((a, b) => a + b.colors.filter(c => !c.cancelled).length, 0); const unit = allBases[0]?.unit || 'GL'; return ( <>
Verona Color Paints
Planificación de Producción Diaria
{f.dowFull}
{f.day} de {f.month} · {f.year}
Verona Color Paints · Plan {f.dowFull} {f.day} de {f.month} {f.year} Generado {new Date().toLocaleString('es-VE')}
Total del día
{allBases.length} base{allBases.length !== 1 ? 's' : ''} {totalColors} colores {totalGL} {unit}
); } // ─── ENVASADO DAY SUMMARY MODAL ─── function EnvasadoDaySummaryModal({ bases, date, onClose }) { const TIPO_ORDER = ['cu4', 'cu5', 'cu7', 'gl', 'ku', 'pl', 'pm']; const TIPO_GL = ENV_GL_FACTOR; const planByTipo = {}; const planByBrand = {}; const realByTipo = {}; const realByBrand = {}; (bases || []).forEach(b => { if (b.status === 'cancelled') return; (b.colors || []).forEach(c => { if (c.cancelled) return; (c.envasado || []).forEach(e => { const qty = Number(e.cantidad || 0); if (!qty) return; const tipo = e.tipo; const brand = e.marca || 'SIN MARCA'; planByTipo[tipo] = (planByTipo[tipo] || 0) + qty; if (!planByBrand[brand]) planByBrand[brand] = {}; planByBrand[brand][tipo] = (planByBrand[brand][tipo] || 0) + qty; }); if (c.checkEM) { (c.envasadoReal || []).forEach(e => { const qty = Number(e.cantidad || 0); if (!qty) return; const tipo = e.tipo; const brand = e.marca || 'SIN MARCA'; realByTipo[tipo] = (realByTipo[tipo] || 0) + qty; if (!realByBrand[brand]) realByBrand[brand] = {}; realByBrand[brand][tipo] = (realByBrand[brand][tipo] || 0) + qty; }); } }); }); const calcGL = (obj) => TIPO_ORDER.reduce((s, t) => s + (obj[t] || 0) * TIPO_GL[t], 0); const hasPlan = Object.keys(planByTipo).length > 0; const hasReal = Object.keys(realByTipo).length > 0; const printSummary = () => { const section = (title, byTipo, byBrand) => { const tipoRows = TIPO_ORDER.filter(t => byTipo[t] > 0) .map(t => `${escHtml(TIPO_ENV_LABEL[t])}${fmtNum(byTipo[t])}${fmtNum(byTipo[t] * TIPO_GL[t])} GL`).join(''); const brandRows = Object.entries(byBrand).sort(([a], [b]) => a.localeCompare(b)) .map(([brand, bt]) => `${escHtml(brand)}${TIPO_ORDER.filter(t => bt[t] > 0).map(t => `${fmtNum(bt[t])} ${escHtml(TIPO_ENV_LABEL[t])}`).join(' · ')}${fmtNum(calcGL(bt))} GL`).join(''); return `

${escHtml(title)}

${tipoRows}
PresentaciónCantidadGalones
TOTAL${fmtNum(calcGL(byTipo))} GL
${brandRows ? `

Desglose por producto

${brandRows}
ProductoEnvasadoGalones
` : ''}`; }; const win = window.open('', '_blank', 'width=900,height=700'); if (!win) { (window.showToast || window.alert)('Permita las ventanas emergentes para imprimir', 'err'); return; } win.document.write(`Envasado del día — ${escHtml(date)}

Envasado Total del Día

Planificación del ${escHtml(date)}
${hasPlan ? section('📋 Planificado', planByTipo, planByBrand) : '

Sin envasado planificado.

'} ${hasReal ? section('✓ Real (confirmado)', realByTipo, realByBrand) : ''}