// ════════════════════════════════════════════ // 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'); } function uid(prefix='id') { return prefix + '_' + Math.random().toString(36).slice(2, 9); } // ─── 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'); } 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 ─── function ThemeIcon({ id }) { if (id === 'light') { return ( ); } return ( ); } function ThemeToggle({ theme, onTheme }) { const themes = [ { id: 'light', title: 'Claro' }, { id: 'dark', title: 'Oscuro' }, ]; return (
{themes.map(t => ( ))}
); } // Botón "Inicio" — vuelve a la selección de planta. // Solo se muestra a usuarios con acceso a más de una planta (p. ej. admin). function PlantHomeButton({ currentUser }) { const plants = Array.isArray(currentUser?.plants) ? currentUser.plants : []; if (plants.length <= 1) return null; return ( Plantas ); } // 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()} ); } function Header({ currentDate, view, syncStatus, isOnline, theme, onTheme, currentUser, onLogout, lang, onLangToggle }) { 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 (
Verona Color Paints

Verona Color Paints

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

{window.t('Planificación')} / {view === 'week' ? window.t('Semanal') : view === 'control' ? window.t('Control de Proceso') : view === 'supervisor' ? window.t('Vista Supervisor') : window.t('Diaria')}
{currentUser && (
{currentUser.name || currentUser.email} {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.floor((Date.now() - 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 }) { const [search, setSearch] = useState(''); const [statusFilter, setStatusFilter] = useState('all'); // 'all' | 'progress' | 'done' const q = search.trim().toLowerCase(); 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 isBaseDone = (b) => { const cols = b.colors.filter(c => !c.cancelled); return cols.length > 0 && cols.every(c => c.checkEM); }; 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 matchBase = !q || (b.nombre || '').toLowerCase().includes(q) || (b.code || '').toLowerCase().includes(q) || (b.lote || '').toLowerCase().includes(q); const cols = b.colors.filter(c => !c.cancelled && ( !q || matchBase || (c.nombre || '').toLowerCase().includes(q) || (c.lote || '').toLowerCase().includes(q) ) ); return { ...b, cols }; }).filter(b => b.cols.length > 0); const allColors = activeBases.flatMap(b => b.colors.filter(c => !c.cancelled)); const envasadoDone = allColors.filter(c => c.checkEM).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 && ( )} {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

{q ? '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(c => c.checkEM).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 ─── function MatizacionView({ bases, date, onMark, canMark, machines = [], tick, onShowHistorial, onOpenPersonal }) { const [dismissing, setDismissing] = useState(new Set()); const [dismissed, setDismissed] = useState(() => { const s = new Set(); (bases || []).forEach(b => (b.colors || []).forEach(c => { if (c.checkMA) s.add(c.id); })); return s; }); const dismiss = (baseId, colorId) => { setDismissing(prev => new Set([...prev, colorId])); setTimeout(() => { setDismissed(prev => new Set([...prev, colorId])); setDismissing(prev => { const n = new Set(prev); n.delete(colorId); return n; }); if (onMark) onMark(baseId, colorId); }, 320); }; const resetAll = () => { setDismissed(new Set()); setDismissing(new Set()); }; const readyBases = (bases || []).filter(b => b.checkFN && b.status !== 'cancelled'); const allColors = readyBases.flatMap(b => b.colors.filter(c => !c.cancelled)); const doneCount = allColors.filter(c => dismissed.has(c.id)).length; const visibleBases = readyBases.map(b => ({ ...b, cols: b.colors.filter(c => !c.cancelled && !dismissed.has(c.id)) })).filter(b => b.cols.length > 0); const { dow, day, month } = fmtDate(date); const histCount = machines .filter(m => m.type === 'dispersor1') .reduce((s, m) => s + (m.history || []).length, 0); // Botón Personal del departamento (se muestra junto al de Historial). const personalBtn = onOpenPersonal ? ( ) : null; const histBtn = onShowHistorial ? ( ) : null; if (readyBases.length === 0) { return (
{dow} {day} {month}
{personalBtn} {histBtn}
🎨

Sin bases listas para matizar

Aparecerán aquí las bases marcadas como FN en Control de Proceso.

); } return (
{dow} {day} {month} {doneCount} / {allColors.length} colores
{doneCount > 0 && canMark && ( )} {personalBtn} {histBtn}
{visibleBases.length === 0 ? (
✓

¡Todos los colores matizados!

) : visibleBases.map(b => { const remGL = b.cols .filter(c => !dismissing.has(c.id)) .reduce((a, c) => a + (c.cantidad || 0), 0); return (
{b.tipo || 'BASE'} {b.nombre} {b.code} · Lote {b.lote} {remGL} {b.unit || 'GL'}
{b.cols.map(c => ( ))}
); })}
); } // ─── 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 [pwId, setPwId] = useState(null); // usuario con el cambio de clave abierto const [pwVal, setPwVal] = useState(''); const [pwMsg, setPwMsg] = useState(''); 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 }, 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_equipos_tab', 'Ver Equipos'], ['access_moliendas_tab', 'Ver/Registrar Moliendas'], ['access_backorden_tab', 'Pestaña Back Orden'], ['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'], ['personal_full', 'Personal y puntos (completo)'], ['personal_basic', 'Personal (solo agregar y mover)'], ['manage_users', 'Gestionar usuarios'], ]; const _f = (url, opts = {}) => fetch(url, { credentials:'include', ...opts }); const parseApi = async (r) => { const j = await r.json().catch(() => ({})); if (!r.ok) 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); useEffect(() => { loadUsers(); }, []); const loadUsers = async () => { setLoading(true); try { const j = await _f('./api.php?action=users').then(parseApi); if (j.users) setUsers(j.users); } catch (_) {} 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 (_) { setFormErr('Error de conexión'); } 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)); } catch (_) {} 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)); } catch (_) {} 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)); } catch (_) {} 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)); } catch (_) {} 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)); } catch (_) {} setSaving(null); }; const openPw = (user) => { setPwId(user.id); setPwVal(''); setPwMsg(''); }; const closePw = () => { setPwId(null); setPwVal(''); setPwMsg(''); }; const changePassword = async (user) => { if ((pwVal || '').length < 6) { setPwMsg('Mínimo 6 caracteres'); return; } setSaving(user.id); setPwMsg(''); try { const j = await post({ action:'update_user', user_id:user.id, password:pwVal }); if (j.user || j.success) { setPwMsg('✓ Clave actualizada'); setPwVal(''); setTimeout(() => { setPwId(null); setPwMsg(''); }, 1400); } else { setPwMsg(j.error || 'No se pudo cambiar'); } } catch (_) { setPwMsg('Error de conexión'); } setSaving(null); }; // Bloque reutilizable para cambiar la clave de un usuario (admin u operador) const pwBlock = (u) => (
🔑 Clave: {pwId === u.id ? ( <> setPwVal(e.target.value)} placeholder="Nueva clave (mín. 6)" style={{ maxWidth:190 }} autoFocus onKeyDown={e => { if (e.key === 'Enter') changePassword(u); }} /> {pwMsg && {pwMsg}} ) : ( )}
); const operadors = users.filter(u => u.role !== 'admin'); const admins = users.filter(u => u.role === 'admin'); return (
e.target === e.currentTarget && onClose()}>

Usuarios

{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]) => ( ))}
{pwBlock(u)}
)}
))}
{admins.length > 0 && (
Administradores
{admins.map(u => (
{u.name} {u.email}
Admin
{pwBlock(u)}
))}
)} {creating ? (
Nuevo operador
{[['envasado','Envasado'],['matizacion','Matización'],['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}

}
) : ( )} )}
); } // ─── INVENTARIO DE MOLIENDAS (solo esmalte) ─────────────── // Registro directo de moliendas finalizadas: cada registro es un producto // con lote y cantidad que queda en inventario para consumo posterior. function MoliendasView({ moliendas, isAdmin, onChange, currentUser }) { const today = new Date().toLocaleDateString('en-CA'); // YYYY-MM-DD const emptyForm = () => ({ producto: '', lote: '', cantidad: '', unidad: 'Kg', estado: 'lista', fecha: today, responsable: (currentUser?.name || currentUser?.email || ''), molino: '', notas: '', }); const [form, setForm] = useState(emptyForm); const [err, setErr] = useState(''); const [query, setQuery] = useState(''); const [filtro, setFiltro] = useState('todas'); // todas | lista | en_proceso const [editId, setEditId] = useState(null); const [editVals, setEditVals] = useState({ cantidad: '', consumido: '' }); const [editErr, setEditErr] = useState(''); const [detailId, setDetailId] = useState(null); // molienda con panel de historial abierto const [consumoVals, setConsumoVals] = useState({ fecha: today, kg: '', destino: '', nota: '' }); const [consumoErr, setConsumoErr] = useState(''); const list = Array.isArray(moliendas) ? moliendas : []; const set = (k, v) => setForm(f => ({ ...f, [k]: v })); const disponibleDe = (m) => (parseFloat(m.cantidad) || 0) - (parseFloat(m.consumido) || 0); const esLista = (m) => (m.estado || 'lista') === 'lista'; const fmt = (n) => (Number(n) || 0).toLocaleString('es-AR', { maximumFractionDigits: 1 }); const register = () => { if (!form.producto.trim()) { setErr('El producto es obligatorio'); return; } if (!form.lote.trim()) { setErr('El lote es obligatorio'); return; } const cant = parseFloat(form.cantidad); if (!(cant > 0)) { setErr('La cantidad debe ser mayor a 0'); return; } setErr(''); const rec = { id: 'mol_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7), producto: form.producto.trim(), lote: form.lote.trim(), cantidad: cant, unidad: form.unidad, estado: form.estado || 'lista', consumido: 0, fecha: form.fecha || today, responsable: form.responsable.trim(), molino: form.molino.trim(), notas: form.notas.trim(), createdAt: new Date().toISOString(), }; onChange([rec, ...list]); setForm({ ...emptyForm(), responsable: form.responsable }); }; const marcarLista = (rec) => { onChange(list.map(m => m.id === rec.id ? { ...m, estado: 'lista' } : m)); }; const remove = (rec) => { if (!window.verifyDeleteKey(`¿Eliminar la molienda "${rec.producto}" (lote ${rec.lote})?`)) return; onChange(list.filter(m => m.id !== rec.id)); }; // ── Edición de cantidades (admin) ── const startEdit = (m) => { setEditErr(''); setEditId(m.id); setEditVals({ cantidad: String(m.cantidad ?? ''), consumido: String(m.consumido ?? 0) }); }; const cancelEdit = () => { setEditId(null); setEditErr(''); }; const saveEdit = (m) => { const cant = parseFloat(editVals.cantidad); let cons = parseFloat(editVals.consumido); if (!(cant >= 0) || Number.isNaN(cant)) { setEditErr('La cantidad debe ser un número ≥ 0'); return; } if (Number.isNaN(cons)) cons = 0; if (cons < 0) cons = 0; if (cons > cant) cons = cant; // el consumido no puede superar la cantidad onChange(list.map(x => x.id === m.id ? { ...x, cantidad: cant, consumido: cons, updatedAt: new Date().toISOString() } : x)); setEditId(null); setEditErr(''); }; // ── Historial de consumo (dónde y cuándo se consumió) ── const consumosDe = (m) => Array.isArray(m.consumos) ? m.consumos : []; const toggleDetail = (m) => { if (detailId === m.id) { setDetailId(null); return; } setDetailId(m.id); setConsumoVals({ fecha: today, kg: '', destino: '', nota: '' }); setConsumoErr(''); }; const registrarConsumo = (m) => { const kg = parseFloat(consumoVals.kg); const disp = disponibleDe(m); if (!(kg > 0)) { setConsumoErr('Los Kg consumidos deben ser mayores a 0'); return; } if (kg > disp + 1e-9) { setConsumoErr(`No hay disponible suficiente (quedan ${fmt(disp)} ${m.unidad || ''})`); return; } const mov = { id: 'c_' + Date.now() + '_' + Math.random().toString(36).slice(2, 6), fecha: consumoVals.fecha || today, kg, destino: (consumoVals.destino || '').trim(), nota: (consumoVals.nota || '').trim(), responsable: (currentUser?.name || currentUser?.email || ''), createdAt: new Date().toISOString(), }; onChange(list.map(x => x.id === m.id ? { ...x, consumido: (parseFloat(x.consumido) || 0) + kg, consumos: [...consumosDe(x), mov], updatedAt: new Date().toISOString() } : x)); setConsumoVals({ fecha: today, kg: '', destino: '', nota: '' }); setConsumoErr(''); }; const eliminarConsumo = (m, movId) => { const mov = consumosDe(m).find(c => c.id === movId); if (!mov) return; if (!window.verifyDeleteKey(`¿Eliminar el consumo de ${fmt(mov.kg)} ${m.unidad || ''} (${mov.destino || 'sin destino'})?`)) return; onChange(list.map(x => x.id === m.id ? { ...x, consumido: Math.max(0, (parseFloat(x.consumido) || 0) - (parseFloat(mov.kg) || 0)), consumos: consumosDe(x).filter(c => c.id !== movId), updatedAt: new Date().toISOString() } : x)); }; // Totales por unidad (solo moliendas listas) const totalsDisp = list.reduce((acc, m) => { if (!esLista(m)) return acc; const u = m.unidad || 'Kg'; acc[u] = (acc[u] || 0) + disponibleDe(m); return acc; }, {}); const totalCantidad = list.reduce((s, m) => s + (parseFloat(m.cantidad) || 0), 0); const nLista = list.filter(esLista).length; const nProceso = list.length - nLista; const esAgotada = (m) => (parseFloat(m.cantidad) || 0) > 0 && disponibleDe(m) <= 0; const nAgotadas = list.filter(esAgotada).length; // Filtrado + búsqueda const q = query.trim().toLowerCase(); const filtered = list.filter(m => { if (filtro === 'lista' && !esLista(m)) return false; if (filtro === 'en_proceso' && esLista(m)) return false; if (filtro === 'agotadas' && !esAgotada(m)) return false; if (!q) return true; return [m.producto, m.lote, m.responsable, m.molino, m.notas] .some(v => (v || '').toLowerCase().includes(q)); }); const fieldStyle = { display: 'flex', flexDirection: 'column', gap: 4 }; const labelStyle = { fontSize: 11, fontWeight: 600, color: 'var(--m1)' }; const inputStyle = { padding: '7px 9px', border: '1px solid var(--bd)', borderRadius: 8, background: 'var(--bg)', color: 'inherit', fontSize: 13, width: '100%' }; const th = { padding: '9px 10px', fontSize: 11, fontWeight: 700, color: 'var(--m1)', textAlign: 'left', whiteSpace: 'nowrap', textTransform: 'uppercase', letterSpacing: '.03em' }; const td = { padding: '9px 10px', verticalAlign: 'middle' }; const badge = (bg) => ({ display: 'inline-flex', alignItems: 'center', gap: 4, fontSize: 11, fontWeight: 700, color: '#fff', background: bg, borderRadius: 999, padding: '3px 10px', whiteSpace: 'nowrap' }); const editInput = { padding: '5px 7px', border: '1.5px solid var(--ac)', borderRadius: 6, background: 'var(--bg)', color: 'inherit', fontSize: 13, width: 90, textAlign: 'right' }; const statCard = (accent) => ({ flex: '1 1 130px', minWidth: 120, background: 'var(--bg)', border: '1px solid var(--bd)', borderRadius: 10, padding: '10px 14px', borderLeft: `3px solid ${accent}` }); const statLabel = { fontSize: 10.5, fontWeight: 700, color: 'var(--m1)', textTransform: 'uppercase', letterSpacing: '.04em' }; const statValue = { fontSize: 18, fontWeight: 800, marginTop: 2, color: 'var(--tx)' }; const chip = (active) => ({ fontSize: 12, fontWeight: 700, padding: '5px 12px', borderRadius: 999, cursor: 'pointer', border: '1px solid ' + (active ? 'var(--ac)' : 'var(--bd)'), background: active ? 'var(--ac)' : 'var(--bg)', color: active ? '#fff' : 'var(--m2)', transition: 'all .12s' }); return (
{/* ── Registrar molienda ── */}

Registrar molienda

{err &&
{err}
}
{/* ── Resumen ── */}
Registros
{list.length}
Listas
{nLista}
En proceso
{nProceso}
Agotadas / faltan
0 ? '#b91c1c' : 'var(--tx)' }}>{nAgotadas}
Cantidad total
{fmt(totalCantidad)} Kg*
Disponible (listas)
{Object.keys(totalsDisp).length === 0 ? '0' : Object.entries(totalsDisp).map(([u, v]) => ( {fmt(v)} {u} ))}
{/* ── Inventario ── */}

Inventario de moliendas ({filtered.length}{filtered.length !== list.length ? ` de ${list.length}` : ''})

setFiltro('todas')}>Todas setFiltro('lista')}>Listas setFiltro('en_proceso')}>En proceso setFiltro('agotadas')}>Agotadas{nAgotadas > 0 ? ` (${nAgotadas})` : ''}
setQuery(e.target.value)} placeholder="Buscar producto o lote…" style={{ ...inputStyle, width: 210, paddingLeft: 30 }} />
{editErr &&
{editErr}
} {list.length === 0 ? (

Aún no hay moliendas registradas.

) : filtered.length === 0 ? (

No hay moliendas que coincidan con la búsqueda.

) : (
{filtered.map(m => { const editing = editId === m.id; const dispLive = editing ? (parseFloat(editVals.cantidad) || 0) - (parseFloat(editVals.consumido) || 0) : disponibleDe(m); const lista = esLista(m); const movimientos = consumosDe(m); const open = detailId === m.id; return ( {open && ( )} ); })}
EstadoFechaProductoLote Cantidad Disponible ResponsableMolinoNotas Acciones
{lista ? 'Lista' : 'En proceso'} {m.fecha || '—'} {m.producto} {m.lote} {editing ? ( setEditVals(v => ({ ...v, cantidad: e.target.value }))} autoFocus /> ) : ( {fmt(m.cantidad)} {m.unidad || ''} )} {editing ? (
setEditVals(v => ({ ...v, consumido: e.target.value }))} title="Cantidad consumida" /> consumido · disp. {fmt(dispLive)}
) : ( {fmt(dispLive)} {m.unidad || ''} )}
{m.responsable || '—'} {m.molino || '—'} {m.notas || ''}
{editing ? ( <> ) : ( <> {!lista && } {isAdmin && } {isAdmin && } )}
{/* Registrar consumo */}
Registrar consumo — descuenta del disponible y queda en el historial
{consumoErr &&
{consumoErr}
}
Disponible actual: {fmt(disponibleDe(m))} {m.unidad || ''} {' · '}Consumido total: {fmt(m.consumido)} {m.unidad || ''}
{/* Historial de movimientos */}
Historial de consumo ({movimientos.length})
{movimientos.length === 0 ? (

Sin consumos registrados todavía.

) : (
{isAdmin && } {movimientos.slice().sort((a, b) => (b.fecha || '').localeCompare(a.fecha || '') || (b.createdAt || '').localeCompare(a.createdAt || '')).map(c => ( {isAdmin && ( )} ))}
Fecha Cantidad Destino Responsable Nota
{c.fecha || '—'} {fmt(c.kg)} {m.unidad || ''} {c.destino || '—'} {c.responsable || '—'} {c.nota || ''}
)}
)} {isAdmin && (

* Suma de todas las unidades. Usá el lápiz para corregir la cantidad o lo consumido de cada molienda.

)}
); } window.MoliendasView = MoliendasView; // ─── 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()); const [tab, setTab] = useState('marcas'); const [saving, setSaving] = useState(false); const save = async () => { setSaving(true); 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: (v.defaultPhases || []).map(s => (s || '').trim()).filter(Boolean) }])), produccionOverrides: prodOv.map(s => (s || '').trim().toUpperCase()).filter((v, i, a) => v && a.indexOf(v) === i), }; try { await onSave(cfg); } catch (_) {} 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 } }))} />
setMtypes(o => ({ ...o, [k]: { ...o[k], defaultPhases: e.target.value.split(',').map(s => s.trim()) } }))} />
))}

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.

{[...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.

}
)}
{tab !== 'catalogo' && }
); } window.ConfigModal = ConfigModal; function TabBar({ view, onView, onPrint, onExport, onPrintSettings, onCatalog, onUsers, onConfig, onClearDb, onRefresh, refreshing, showMatizacion, showEnvasado, showDay, showWeek, showControl, showSupervisor, showEquipos, showMoliendas, showBackorden }) { const _day = showDay !== false; const _week = showWeek !== false; const _ctrl = showControl !== false; const _sup = showSupervisor !== false; const _eq = !!showEquipos; return (
{_day && } {showMatizacion && ( )} {showEnvasado && ( )} {_week && } {_ctrl && } {_sup && } {_eq && } {showMoliendas && } {showBackorden && }
{onUsers && } {onConfig && } {onPrint && } {onExport && }
); } // ─── DAY HEADER ─── function DayHeader({ date, onDate, bases, onAddBase, onDuplicate, onPending, onEnvasadoSummary }) { 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 = { gl:1, cu4:4, cu7:2, ku:0.25, p4:1.056, pl:0.264, pm:0.132 }; 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}
Bases
{totalColors}
Colores
{doneColors}
Listos
{fmtNum(totalGL)}
Galones
{matizGL > 0 &&
{fmtNum(matizGL)}
Matización
} {envasadoGL > 0 &&
{fmtNum(envasadoGL)}
Envasado
}
{progress}%
Avance
{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 (
Tipo: {AppData.TIPOS.filter(t => counts[t] > 0).map(t => ( ))} Estado: {counts.carryover > 0 && (<> Planificado: )}
onSearch(e.target.value)}/>
); } // ─── INLINE EDIT ─── function InlineNumber({ value, onChange, suffix='GL', className='' }) { const [v, setV] = useState(value); const [editing, setEditing] = useState(false); useEffect(() => { setV(value); }, [value]); if (!editing) { return ( setEditing(true)} title="Click para editar"> {fmtNum(v)}{suffix} ); } return ( setV(e.target.value)} onBlur={() => { onChange(Number(v)||0); setEditing(false); }} onKeyDown={e => { if(e.key==='Enter'){ onChange(Number(v)||0); 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: 'cu7', l: 'Cuñete 7.2GL' }, { v: 'gl', l: 'Galón (1GL)' }, { v: 'ku', l: 'Cuña (1/4)' }, { v: 'p4', l: '4 Litros (4L)' }, { v: 'pl', l: 'L (1L)' }, { v: 'pm', l: '0.5L (0.5L)' }, ]; const TIPO_ENV_LABEL = { cu4:'CU·4', cu7:'CU·7', gl:'GL', ku:'CUÑ', p4:'4L', pl:'1L', pm:'0.5L' }; const TIPO_ENV_CLS = { cu4:'cu', cu7:'cu', gl:'gl', ku:'ku', p4:'p4', pl:'pl', pm:'pm' }; 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','cu7','gl','ku','p4','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: 'cu7', label: 'CU·7 (7.2 GL)' }, { value: 'gl', label: 'GL (1 GL)' }, { value: 'ku', label: 'CUÑ/1/4 (0.25 GL)' }, { value: 'p4', label: '4 Litros (4L)' }, { value: 'pl', label: 'L (1L)' }, { value: 'pm', label: '0.5L (0.5L)' }, ]; function EnvasadoRealModal({ entries, onChange, onConfirm, onCancel, colorName }) { 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"/>
))}
); } // ─── COLOR ROW ─── function colorDeriveStatus(c) { if (c.checkEM) return 'ready'; if (c.checkEN || c.checkMA || c.checkEC) return 'running'; return 'pending'; } function ColorRow({ color, onUpdate, onDelete, canToggleEnvasado, canEditColor = true, singleColor }) { const [showRealModal, setShowRealModal] = useState(false); const [realEntries, setRealEntries] = useState([]); 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 = () => { 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: '' }]); setShowRealModal(true); } else { const status = chkEN || chkMA || chkEC ? 'running' : 'pending'; onUpdate({ ...color, checkEM: false, envasadoReal: [], status, completedAt: null }); } }; const confirmReal = () => { const valid = realEntries.filter(e => Number(e.cantidad) > 0); onUpdate({ ...color, checkEM: true, envasadoReal: valid, status: 'ready', completedAt: new Date().toISOString() }); setShowRealModal(false); }; 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 || null})} suffix={color.unit} placeholder="—"/> : {color.glReal != null ? `${color.glReal} ${color.unit}` : '—'}}
{statusLabel}
{canEditColor && } {canEditColor && ( )} {onDelete && }
{showRealModal && ( setShowRealModal(false)} colorName={color.nombre} /> )} ); } // ─── BASE CARD ─── function BaseCard({ base, expanded, onToggle, onUpdate, onDelete, onAddColor, onUpdateColor, onDeleteColor, onEditColor, canToggleEnvasado, canEditColor = true, onCancelBase, onMoliendaTerminada, reorderable = false, isDragging = false, isDragOver = false, onBaseDragStart, onBaseDragEnter, onBaseDrop, onBaseDragEnd }) { const totalGL = base.colors.reduce((a,c) => a + (c.cantidad||0), 0); const doneCount = base.colors.filter(c => c.checkEnvasado || c.status === 'ready').length; const pct = base.colors.length ? doneCount/base.colors.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); }, } : {}; // Bloque de molienda de la base (solo esmalte, cuando la fórmula produce molienda) const esEsmalte = (typeof window !== 'undefined' && window.SP_PLANT === 'esmalte'); const ftBase = base.formulaTipo || 'color'; const modoBase = base.moliendaModo || 'lista'; const showMolBlock = esEsmalte && (ftBase === 'molienda' || (ftBase === 'ambas' && modoBase === 'simultanea')); const mol = base.molienda || {}; const setMol = (k, v) => onUpdate({ ...base, molienda: { ...mol, [k]: v } }); 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' ? 'CANCELADO' : base.tipo}
Lote {base.lote} {base.linea && · {base.linea}} {base.operador && · {base.operador}} · {base.colors.length} color{base.colors.length!==1?'es':''} {base.carryoverFrom && ( ↩ pendiente del {new Date(base.carryoverFrom + 'T12:00:00').toLocaleDateString('es', { day:'2-digit', month:'short' })} )}
{base.checkEC && EC} {base.checkFN && FN}
{doneCount}/{base.colors.length}
onUpdate({...base, cantidad:v})} suffix={base.unit}/>
e.stopPropagation()}> {onCancelBase && base.status !== 'cancelled' && ( )} {onCancelBase && base.status === 'cancelled' && ( )} {onDelete && }
Checks
Color
Lote
GL Plan
GL Real
Envasado
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'} · {base.colors.length} color{base.colors.length !== 1 ? 'es' : ''}
{showMolBlock && (
🧪 Molienda de la base {mol.terminada ? ✓ Terminada · en inventario : Pendiente}
{!mol.terminada && onMoliendaTerminada && (
)}
)}
); } // ─── 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 q = (query || '').toLowerCase().trim(); if (!q) return options.slice(0, 60); return options.filter(o => o.toLowerCase().includes(q)).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, moliendas, 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 esEsmalte = (typeof window !== 'undefined' && window.SP_PLANT === 'esmalte'); const dispMol = (m) => (parseFloat(m.cantidad) || 0) - (parseFloat(m.consumido) || 0); const moliendasListas = (Array.isArray(moliendas) ? moliendas : []).filter(m => (m.estado || 'lista') === 'lista' && dispMol(m) > 0); const mc = data.moliendaConsumo; const dispSel = mc?.molienda_id ? dispMol((moliendas || []).find(x => x.id === mc.molienda_id) || {}) : 0; const canSave = !!(data.nombre && data.nombre.trim()) && !!(data.lote && data.lote.trim()); 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' : ''} />
{esEsmalte && (
{data.formulaTipo === 'ambas' && (
{(data.moliendaModo || 'lista') === 'lista' ? ( <> {moliendasListas.length === 0 && (

No hay moliendas listas en el inventario. Usa "En simultáneo" o registra una en la sección Moliendas.

)} {mc?.molienda_id && (
set('moliendaConsumo', { ...mc, kg: e.target.value })} placeholder="0" /> {parseFloat(mc.kg) > dispSel &&

Excede lo disponible; se descontará solo {dispSel} {mc.unidad}.

}
)} ) : (

Se produce la molienda a la par del color. Regístrala en la sección Moliendas (puede quedar "En proceso").

)}
)}
)}
{!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); if (e.tipo === 'gl') return acc + q * 1; if (e.tipo === 'cu4') return acc + q * 4; if (e.tipo === 'cu7') return acc + q * 2; if (e.tipo === 'ku') return acc + q * 0.25; if (e.tipo === 'p4') return acc + q * 1.056; if (e.tipo === 'pl') return acc + q * 0.264; if (e.tipo === 'pm') return acc + q * 0.132; return acc; }, 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 · 7,2 = x2 · 1/4 = x0.25 · 4L = x1.056 · 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; 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 = {gl:1, cu4:4, cu7:2, ku:0.25, p4:1.056, pl:0.264, pm:0.132}; 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 || []; const totalGL = allBases.reduce((a, b) => a + (b.cantidad || 0), 0); const totalColors = allBases.reduce((a, b) => a + b.colors.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, onClose }) { const TIPO_ORDER = ['cu4', 'cu7', 'gl', 'ku', 'p4', 'pl', 'pm']; const TIPO_GL = { gl: 1, cu4: 4, cu7: 2, ku: 0.25, p4: 1.056, pl: 0.264, pm: 0.132 }; 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 TipoGrid = ({ byTipo }) => (
{TIPO_ORDER.filter(t => byTipo[t] > 0).map(t => (
{fmtNum(byTipo[t])}
{TIPO_ENV_LABEL[t]}
= {fmtNum(byTipo[t] * TIPO_GL[t])} GL
))}
); const BrandBreakdown = ({ byBrand }) => (
{Object.entries(byBrand).sort(([a],[b]) => a.localeCompare(b)).map(([brand, bt]) => (
{brand}
{TIPO_ORDER.filter(t => bt[t] > 0).map(t => ( {bt[t]} {TIPO_ENV_LABEL[t]} ))}
{fmtNum(calcGL(bt))} GL
))}
); return (
e.stopPropagation()}>

📦 Envasado Total del Día

📋 Planificado
{!hasPlan ?
Sin envasado planificado
: <>
{fmtNum(calcGL(planByTipo))} GL planificados
{Object.keys(planByBrand).length > 0 && } }
✓ Real
{!hasReal ?
Sin empaquetados confirmados
: <>
{fmtNum(calcGL(realByTipo))} GL reales
{Object.keys(realByBrand).length > 0 && } }
); } function defaultCatalogTipo() { return window.location.pathname.toLowerCase().includes('/esmalte') ? 'ESMALTE' : 'CAUCHO'; } function buildCatalogEntriesFromAppData(savedEntries) { const withIds = entries => (entries || []).map(entry => ({ id: entry.id || uid('cbl'), tipo: entry.tipo || defaultCatalogTipo(), nombre: String(entry.nombre || '').trim().toUpperCase(), colores: [...new Set((entry.colores || []).map(c => String(c || '').trim().toUpperCase()).filter(Boolean))], })).filter(entry => entry.nombre && entry.colores.length > 0); const saved = withIds(savedEntries); if (saved.length > 0) return saved; const byBase = new Map(); (AppData.CATALOGO || []).forEach(item => { const nombre = String(item.base || '').trim().toUpperCase(); const color = String(item.producto || '').trim().toUpperCase(); if (!nombre || !color) return; if (!byBase.has(nombre)) { byBase.set(nombre, { id: uid('cat'), tipo: item.tipo || defaultCatalogTipo(), nombre, colores: [] }); } const entry = byBase.get(nombre); if (!entry.colores.includes(color)) entry.colores.push(color); }); return [...byBase.values()]; } // ─── CATALOG ENTRY EDITOR ─── function CatalogEntryEditor({ data, onChange, onSave, onCancel }) { const setColor = (idx, val) => onChange(d => ({ ...d, colores: d.colores.map((c, i) => i === idx ? val.toUpperCase() : c) })); const addColor = () => onChange(d => ({ ...d, colores: [...d.colores, ''] })); const removeColor = (idx) => onChange(d => ({ ...d, colores: d.colores.filter((_, i) => i !== idx) })); return (
onChange(d => ({...d, nombre: e.target.value.toUpperCase()}))} placeholder="Ej: BASE ESPECIAL" style={{width:'100%'}} autoFocus />
{data.colores.map((c, i) => (
setColor(i, e.target.value)} placeholder={`Color ${i + 1}`} style={{flex:1}} /> {data.colores.length > 1 && ( )}
))}
); } // ─── CATALOG MODAL ─── function CatalogModal({ customCatalog, onSave, onClose }) { const [entries, setEntries] = useState(() => buildCatalogEntriesFromAppData(customCatalog)); const [editingId, setEditingId] = useState(null); const [editData, setEditData] = useState(null); const [showBulkImport, setShowBulkImport] = useState(false); const [bulkText, setBulkText] = useState(''); const [bulkMsg, setBulkMsg] = useState(''); const startAdd = () => { setEditData({ id: uid('cbl'), tipo: defaultCatalogTipo(), nombre: '', colores: [''] }); setEditingId('new'); }; const startEdit = (entry) => { setEditData({ ...entry, colores: [...(entry.colores || []), ''] }); setEditingId(entry.id); }; const cancelEdit = () => { setEditingId(null); setEditData(null); }; const saveEntry = () => { if (!editData.nombre.trim()) return; const cleanColores = editData.colores.map(c => c.trim()).filter(Boolean); if (cleanColores.length === 0) return; const entry = { ...editData, nombre: editData.nombre.trim(), colores: cleanColores }; const next = editingId === 'new' ? [...entries, entry] : entries.map(e => e.id === editingId ? entry : e); setEntries(next); onSave(next); setEditingId(null); setEditData(null); }; const deleteEntry = (id) => { if (!window.verifyDeleteKey('¿Eliminar esta línea del catálogo personalizado?')) return; const next = entries.filter(e => e.id !== id); setEntries(next); onSave(next); }; const importBulkEntries = () => { const lines = bulkText.split(/\r?\n/).map(line => line.trim()).filter(Boolean); if (lines.length === 0) { setBulkMsg('Pega una línea por cada registro usando: TIPO_BASE | COLOR'); return; } const byName = new Map(entries.map(entry => [entry.nombre.toUpperCase(), { ...entry, colores: [...(entry.colores || [])] }])); let imported = 0; let skipped = 0; lines.forEach(line => { const parts = line.split('|').map(part => part.trim()).filter(Boolean); if (parts.length < 2) { skipped += 1; return; } const nombre = parts[0].toUpperCase(); const color = parts.slice(1).join(' | ').toUpperCase(); if (!nombre || !color) { skipped += 1; return; } if (!byName.has(nombre)) { byName.set(nombre, { id: uid('cbl'), tipo: defaultCatalogTipo(), nombre, colores: [] }); } const entry = byName.get(nombre); if (!entry.colores.includes(color)) { entry.colores.push(color); imported += 1; } else { skipped += 1; } }); const next = [...byName.values()].sort((a, b) => a.nombre.localeCompare(b.nombre)); setEntries(next); onSave(next); setBulkText(''); setBulkMsg(`${imported} color${imported !== 1 ? 'es' : ''} importado${imported !== 1 ? 's' : ''}${skipped ? ` · ${skipped} omitido${skipped !== 1 ? 's' : ''}` : ''}`); }; return (
e.stopPropagation()} >

📋 Bases y Colores

Consulta y edita las bases y colores cargados para esta planta. Los cambios se guardan de forma independiente para Caucho y Esmalte.

{showBulkImport && editingId === null && (
Carga masiva
Pega una línea por registro con el formato TIPO_BASE | COLOR.