// ════════════════════════════════════════════
// 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 (
);
if (status === 'saving') return (
);
if (status === 'saved') return (
);
if (status === 'error') return (
Error al guardar
);
if (status === 'session') return (
);
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 (
setOpen(o => !o)} aria-label="Ajustes" title={window.t('Ajustes')}>
{open && (
{hasAdmin &&
{window.t('Administración')}
}
{onUsers &&
run(onUsers)}>
{window.t('Usuarios')}
}
{onConfig &&
run(onConfig)} title="Configuración de listas">
{window.t('Config')}
}
{hasAdmin && hasReport &&
}
{hasReport &&
{window.t('Reportes')}
}
{onPrint &&
run(onPrint)}> {window.t('Imprimir')} }
{onExport &&
run(onExport)}> {window.t('Exportar TXT')} }
{(hasAdmin || hasReport) &&
}
{window.t('Preferencias')}
{window.t('Idioma')}
{ if (isAr) onLangToggle(); }}>ES
{ if (!isAr) onLangToggle(); }}>AR
{window.t('Tema')}
onTheme('light')}>☀ {window.t('Claro')}
onTheme('dark')}>🌙 {window.t('Oscuro')}
)}
);
}
// 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 (
);
}
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 (
setCollapsed(v => !v)}
aria-expanded={!collapsed}
aria-controls={contentId}
>
Previsión de máquinas
{title}
{subtitle && {subtitle}
}
{total} equipos
setCollapsed(v => !v)}
aria-expanded={!collapsed}
aria-controls={contentId}
>
{collapsed ? 'Mostrar' : 'Ocultar'}
{total === 0 ? (
{emptyText || 'No hay máquinas configuradas para este segmento.'}
) : resolvedGroups.map(group => group.machines.length > 0 && (
{group.label}
{group.machines.length}
{group.machines.map(renderMachine)}
))}
);
}
// ─── 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(shiftDate(date, -1))} title="Día anterior">
onDate(shiftDate(date, 1))} title="Día siguiente">
)}
onDate && dateInputRef.current?.showPicker()}
title={onDate ? 'Cambiar fecha' : undefined}
>
{dow} {day} {month}
{onDate && (
e.target.value && onDate(e.target.value)}
/>
)}
{onDate && date !== todayStr() && (
onDate(todayStr())}>Hoy
)}
{envasadoDone}
/
{allColors.length}
envasados
setSearch(e.target.value)}
/>
{search && (
setSearch('')}>
)}
{onOpenPersonal && (
Personal
)}
{onOpenFacturacion && (
🧾 Facturación
)}
{onShowHistorial && (
Historial
{histCount > 0 && {histCount} }
)}
{/* Filtro por estado de la base */}
Estado:
setStatusFilter('all')}>
Todas {activeBases.length}
setStatusFilter('progress')}>
En curso {progressBasesCount}
setStatusFilter('done')}>
Completadas {doneBasesCount}
{/* 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(shiftDate(date, -1))} title="Día anterior">
onDate(shiftDate(date, 1))} title="Día siguiente">
)}
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() && (
onDate(todayStr())}>Hoy
)}
);
const histCount = machines
.filter(m => m.type === 'dispersor1')
.reduce((s, m) => s + (m.history || []).length, 0);
const histBtn = onShowHistorial ? (
Historial
{histCount > 0 && {histCount} }
) : null;
const fmlBtn = onOpenFormulas ? (
onOpenFormulas({ from: 'matizacion' })} title="Catálogo de fórmulas: evolución por producto y edición manual">
🧪 Fórmulas
{(formulas || []).length > 0 && {formulas.length} }
) : null;
const personalBtn = onOpenPersonal ? (
Personal
) : 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 && onOpenFormulas({ from: 'matizacion', producto: c.nombre, colorId: c.id, base: b.nombre, lote: c.lote || b.lote, gl: c.cantidad, unit: c.unit || b.unit })} title="Ver / colocar la fórmula de este color">
🧪 {hasF ? 'Ver fórmula' : 'Fórmula'}
}
canMark && onMark && onMark(b.id, c.id)}
disabled={!canMark}
title={done ? 'Desmarcar matizado' : 'Marcar como matizado'}
>
✓
);
})}
);
})}
);
}
// ─── 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()}>
{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.'}
setDk(d => ({ ...d, open:!d.open, msg:'' }))}>
{dk.open ? 'Cancelar' : (dk.configured ? 'Cambiar clave' : 'Crear clave')}
{dk.msg && !dk.open &&
{dk.msg}
}
{dk.open && (
)}
{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 && (
handleApprove(u)} disabled={saving===u.id}>Aprobar
)}
setEditId(editId===u.id ? null : u.id)}>
handleDelete(u)} disabled={saving===u.id}>
{editId === u.id && (
)}
))}
{creating ? (
Nuevo operador
{[['envasado','Envasado'],['matizacion','Matización'],['preparadores','Preparadores'],['mantenimiento','Mantenimiento'],['control','Control']].map(([k,l]) => (
setForm(f=>({...f,preset:k}))}>{l}
))}
Nombre
setForm(f=>({...f,name:e.target.value}))} placeholder="Nombre del operador" />
Email
setForm(f=>({...f,email:e.target.value}))} placeholder="correo@empresa.com" />
Contraseña
setForm(f=>({...f,password:e.target.value}))} placeholder="Mínimo 6 caracteres" />
{formErr &&
{formErr}
}
{setCreating(false);setFormErr('');}}>Cancelar
{saving==='new' ? 'Creando...' : 'Crear'}
) : (
setCreating(true)}>
Nuevo operador
)}
>
)}
);
}
// ─── 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]) => (
setTab(k)}>{l}
))}
{tab === 'marcas' && (
{marcas.map((m, i) => (
setMarcas(a => a.map((x, j) => j === i ? e.target.value : x))} />
setMarcas(a => a.filter((_, j) => j !== i))}>✕
))}
setMarcas(a => [...a, ''])}>+ Agregar marca
)}
{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} />
setLineas(a => a.filter((_, j) => j !== i))}>✕
))}
setLineas(a => [...a, { id: 'l' + Math.random().toString(36).slice(2, 6), nombre: '', color: '#3b6fd4' }])}>+ Agregar línea
)}
{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} />
setPhases(a => a.filter((_, j) => j !== i))}>✕
))}
setPhases(a => [...a, { id: '', label: '', bg: '#eef1f7', fg: '#535c78' }])}>+ Agregar estado
)}
{tab === 'maquinas' && (
{Object.keys(mtypes).map(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))}
/>
setProdOv(a => a.filter((_, j) => j !== i))}>✕
))}
setProdOv(a => [...a, ''])}>+ Agregar producto a Producción
{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
?
Abrir editor de Bases y Colores
:
Requiere conexión con el servidor.
}
)}
{saveErr && {saveErr} }
{exporting ? 'Exportando…' : '⬇ Exportar base de datos'}
Cerrar
{tab !== 'catalogo' && {saving ? 'Guardando…' : 'Guardar cambios'} }
);
}
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 &&
}
{window.t('Menú')}
×
{_day &&
select('day')}> {window.t('Diaria')} }
{showMatizacion && (
select('matizacion')}>
{window.t('Matización')}
)}
{showEnvasado && (
select('envasado')}>
{window.t('Envasado')}
)}
{showPreparadores && (
select('preparadores')}>
{window.t('Preparadores')}
)}
{_week &&
select('week')}> {window.t('Semanal')} }
{showLista &&
select('lista')}>
{window.t('Lista')}
}
{_ctrl &&
select('control')}> {window.t('Control')} }
{_sup &&
select('supervisor')}>
{window.t('Supervisor')}
}
{_eq &&
select('equipos')}>
{window.t('Equipos')}
}
{showMantenimiento &&
select('mantenimiento')}>
{window.t('Mantenimiento')}
}
{showBackorden &&
select('backorden')}>
{window.t('Back Orden')}
}
{Array.isArray(currentUser?.plants) && currentUser.plants.length > 1 && (
<>
{window.t('Plantas')}
>
)}
>
);
}
// ─── 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(shiftDate(date,-1))} title={window.t('Día anterior')}>
onDate(shiftDate(date,1))} title={window.t('Día siguiente')}>
)}
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() && (
onDate(todayStr())}>{window.t('Hoy')}
)}
{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 && 🧪 {window.t('Fórmulas de base')} }
{onConsumo && 🧪 {window.t('Consumo MP')} }
{onEnvasadoSummary && 📦 {window.t('Envasado')} }
{onPending && ↩ {window.t('Pendientes de ayer')} }
{onDuplicate && {window.t('Duplicar')} }
{onAddBase && {window.t('Nueva Base')} }
>
);
}
// ─── 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:')}
onFilter({...filter, tipo:'all'})}>
{window.t('Todas')} {counts.all}
{AppData.TIPOS.filter(t => counts[t] > 0).map(t => (
onFilter({...filter, tipo:t})}>
{t} {counts[t]}
))}
{window.t('Estado:')}
onFilter({...filter, status:'all'})}>{window.t('Todos')}
onFilter({...filter, status:'planned'})}>{window.t('Planificado')}
onFilter({...filter, status:'running'})}>{window.t('En producción')}
onFilter({...filter, status:'done'})}>{window.t('Completado')}
onFilter({...filter, status:'cancelled'})}>{window.t('Cancelado')}
{counts.carryover > 0 && (<>
{window.t('Planificado:')}
onFilter({...filter, origen:'all'})}>
{window.t('Todos')}
onFilter({...filter, origen:'today'})}>
{window.t('Hoy')} {counts.all - counts.carryover}
onFilter({...filter, origen:'past'})}>
{window.t('Pasadas')} {counts.carryover}
>)}
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.
Agregar presentación
{error &&
{error}
}
Cancelar
✓ Confirmar Empaquetado
);
}
// ─── 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 && window.dispatchEvent(new CustomEvent('edit-color',{detail:color.id}))}> }
{canEditColor && (
{isCancelled ? '↩' : '✕'}
)}
{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()}>
window.dispatchEvent(new CustomEvent('edit-base',{detail:base.id}))}>
{onCancelBase && base.status !== 'cancelled' && (
onCancelBase(base.id, false)}
style={{ color: 'var(--rd)' }}
>✕
)}
{onCancelBase && base.status === 'cancelled' && (
onCancelBase(base.id, true)}
style={{ color: 'var(--ac)' }}
>↩
)}
{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'}
Nombre de la Base *
set('nombre', v)}
options={AppData.BASES_UNICAS}
placeholder="Buscar base…"
allowCustom={false}
/>
Estado
set('status', e.target.value)}>
{AppData.ESTADOS_BASE.map(s => {s.l} )}
{!canSave && Completa Nombre y Lote }
Cancelar
{isNew?'Crear Base':'Guardar'}
);
}
// ─── 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 */}
Nombre del Color *
mainFieldsEditable && set('nombre', v)}
options={coloresDisponibles}
placeholder="Buscar o escribir nuevo color…"
allowCustom={true}
disabled={!mainFieldsEditable}
/>
{/* TIPO DE COLOR */}
Tipo de Color
mainFieldsEditable && set('tipoColor', e.target.value)}
disabled={!mainFieldsEditable}
>
Sin Matización — EC → EN → EM
Con Matización — EC → MA → EN → EM
{/* COLOR / CANTIDAD / LOTE */}
{/* ENVASADO PLANIFICADO */}
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 && updateEnv(e.id, {marca:ev.target.value})}>
{AppData.MARCAS.map(m => {m} )}
{canEdit && removeEnv(e.id)}> }
))}
{canEdit && (
setData(d => ({...d, envasado:[...(d.envasado||[]),{id:uid('e'),tipo:tipo.v,cantidad:0,marca:'ARADOS'}]}))}>
Agregar marca
)}
);
})}
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 }
Cancelar
onSave(data)}
disabled={!canSaveColor}
>
{isNew ? 'Agregar Color' : 'Guardar'}
);
}
// ─── 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
)}
);
})}
Cancelar
onBring([...selected])}
>
↩ Traer {selected.size > 0 ? selected.size : ''} base{selected.size !== 1 ? 's' : ''} al plan
);
}
// ─── 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()}>
Selecciona las bases; usa A para oscurecer la letra. Revisa el resultado en la vista previa.
×
{allSelected ? 'Deseleccionar todo' : 'Seleccionar todo'}
{anyPrinted && (
{ e.stopPropagation(); clearPrinted(); }}
title="Olvidar qué bases ya se imprimieron hoy"
>
Restablecer impresas
)}
{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
)}
{ e.stopPropagation(); toggleEmph(b.id); }}
title={isEmph ? 'Quitar oscurecido: imprimir con letra normal' : 'Oscurecer / resaltar la letra de esta base al imprimir'}
>
A
{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'}
setShowColors(v => !v)}
title={showColors ? 'Imprimir sin el detalle de colores (solo bases y galonaje)' : 'Incluir el detalle de colores en la impresión'}
>
{showColors ? 'Ocultar colores' : 'Mostrar colores'}
{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
)}
Cancelar
🖶 Imprimir {selected.size > 0 ? selected.size : ''} base{selected.size !== 1 ? 's' : ''}
);
}
// ─── 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()}>
Hora de cierre
setDayEnd(d, e.target.value)}/>
Descansos
{(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); }}/>
setDayBreaks(d, (sched.breaks||[]).filter((_,j)=>j!==i))}>
))}
setDayBreaks(d, [...(sched.breaks||[]), {start:'12:00',end:'13:00'}])}>
+ Agregar descanso
{ setDayEnd(d,'17:00'); setDayBreaks(d,[]); setEditingDay(null); }}>
Restablecer
)}
{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
? setSelectedDay(null)}>← Ver semana completa
: Haz clic en un día del calendario para ver métricas de ese día
}
Máquina
Tipo
Batches
GL asignados
Turno total
Tiempo activo
Tiempo inactivo
Eficiencia
{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 (
{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 }
);
})}
{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 (
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 }) => (
);
return (
e.stopPropagation()}>
Configurar Impresión
{/* Perfiles */}
{/* 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 }) => (
update(k, e.target.checked)}
className="ps-toggle-chk"
/>
{label}
))}
🏷 Campos de base
{[
{ k:'showBaseCode', label:'Código de base' },
{ k:'showPlanta', label:'Planta / línea de producción' },
].map(({ k, label }) => (
update(k, e.target.checked)}
className="ps-toggle-chk"
/>
{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 }) => (
update(k, e.target.checked)}
className="ps-toggle-chk"
/>
{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 (
<>
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)}
Presentación Cantidad Galones
${tipoRows}
TOTAL ${fmtNum(calcGL(byTipo))} GL
${brandRows ? `
Desglose por producto
Producto Envasado Galones
${brandRows}
` : ''}`;
};
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) : ''}