/* ════════════════════════════════════════════════════════════ PREPARADORES — Departamento con personal, grupos y puntos ──────────────────────────────────────────────────────────── Modelo de datos (clave): · Los puntos pertenecen a la PERSONA, no al grupo. · Cada registro (ledger) guarda una foto de los miembros del grupo en ese momento; CADA miembro suma el total de puntos. · Si una persona cambia de grupo, conserva su historial: los registros pasados siguen contando porque guardan el snapshot. Todo está particionado por `dept` para poder reutilizar el mismo motor en Matización / Envasado más adelante. ════════════════════════════════════════════════════════════ */ // ── Utilidades ────────────────────────────────────────────── const prepUid = () => Date.now().toString(36) + Math.random().toString(36).slice(2, 7); // Fecha de hoy con el reloj calibrado contra el servidor (todayStr de // components.jsx); solo si no existe se usa el reloj local. const prepTodayStr = () => { try { if (typeof window !== 'undefined' && typeof window.todayStr === 'function') return window.todayStr(); } catch (_) {} const d = new Date(); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`; }; // Instante actual ISO con el reloj calibrado (vetNow() = real + offset - 4 h, VET fijo). const prepNowIso = () => { try { if (typeof vetNow === 'function') return new Date(vetNow().getTime() + 4 * 3600 * 1000).toISOString(); } catch (_) {} return new Date().toISOString(); }; // Cédula: clave de comparación normalizada ("V-12.345.678" ≡ "v 12345678" ≡ "12345678"). // Se ignoran puntos, guiones y espacios, mayúsculas y la letra V (nacionalidad por // defecto); "E-…" (extranjero) sigue siendo distinta. Lo guardado es lo tecleado, con // espacios colapsados (prepCleanCedula) — solo la COMPARACIÓN usa la clave. const prepCedulaKey = (c) => String(c == null ? '' : c).toUpperCase().replace(/[^A-Z0-9]/g, '').replace(/^V(?=\d)/, ''); const prepCleanCedula = (c) => String(c == null ? '' : c).replace(/\s+/g, ' ').trim(); const prepCargoMap = (cargos) => { const m = {}; (cargos || []).forEach(c => { m[c.id] = c; }); return m; }; // ¿El cargo de esta persona es "deducible" (arranca con puntos completos y // solo se le descuenta, no gana por grupo)? function prepIsDeductible(person, cargoMap) { const c = person && cargoMap[person.cargoId]; return !!(c && c.mode === 'deductible'); } // Puntos por persona, considerando el cargo: // · Cargo normal → arranca en 0 y suma lo ganado por grupo/tareas. // · Cargo deducible → arranca en los puntos base del cargo, NO gana por // grupo, y solo baja con los descuentos manuales (source 'deduction'). function prepPersonTotals(ledger, people, cargos) { const cargoMap = prepCargoMap(cargos); const personById = {}; (people || []).forEach(p => { personById[p.id] = p; }); const map = {}; (people || []).forEach(p => { const c = cargoMap[p.cargoId]; map[p.id] = (c && c.mode === 'deductible') ? Number(c.basePoints || 0) : 0; }); // Solo cuentan las personas que AÚN existen: los registros de personas // borradas siguen en la bitácora pero no suman a ningún total. (ledger || []).forEach(e => { const pts = Number(e.points || 0); if (e.source === 'deduction') { const pid = e.personId; if (pid != null && personById[pid]) map[pid] = (map[pid] || 0) - pts; // descuento manual } else { (e.personIds || []).forEach(pid => { if (!personById[pid]) return; // persona borrada if (prepIsDeductible(personById[pid], cargoMap)) return; // no gana por grupo map[pid] = (map[pid] || 0) + pts; }); } }); return map; } // Resumen coherente con prepPersonTotals (mismas reglas): // · otorgados = lo ganado por personas vigentes NO deducibles − descuentos manuales. // · acumulados = suma de los totales de las personas vigentes // (= otorgados + puntos base de los cargos deducibles). function prepSummary(ledger, people, cargos) { const cargoMap = prepCargoMap(cargos); const personById = {}; (people || []).forEach(p => { personById[p.id] = p; }); let ganados = 0, descontados = 0; (ledger || []).forEach(e => { const pts = Number(e.points || 0); if (e.source === 'deduction') { if (e.personId != null && personById[e.personId]) descontados += pts; } else { (e.personIds || []).forEach(pid => { if (personById[pid] && !prepIsDeductible(personById[pid], cargoMap)) ganados += pts; }); } }); const totals = prepPersonTotals(ledger, people, cargos); const acumulados = Object.values(totals).reduce((a, b) => a + b, 0); return { ganados, descontados, otorgados: ganados - descontados, acumulados }; } // Puntos acumulados por grupo (histórico del grupo, según groupId del registro). function prepGroupTotals(ledger) { const map = {}; (ledger || []).forEach(e => { if (!e.groupId) return; map[e.groupId] = (map[e.groupId] || 0) + Number(e.points || 0); }); return map; } // Nombre a mostrar para un registro de la bitácora. El registro guarda el // nombre que tenía el grupo en ese momento, pero también su id: si el grupo // aún existe se muestra su nombre ACTUAL, así renombrarlo no deja el // historial con nombres viejos. Si el grupo ya no existe, queda el snapshot. function prepEntryGroupLabel(entry, groups) { if (!entry) return ''; if (entry.groupId) { const g = (groups || []).find(x => x.id === entry.groupId); if (g && g.name) return g.name; } return entry.groupName || entry.operario || ''; } const prepFmtNum = (n) => { const v = Number(n || 0); return Number.isInteger(v) ? String(v) : v.toFixed(2); }; // ══════════════════════════════════════════════════════════ // PESTAÑA PREPARADORES — vista de máquinas (igual que Matización/Envasado) // Solo muestra la previsión de dispersores y máquinas de pasta. // ══════════════════════════════════════════════════════════ function PreparadoresView({ date, machines = [], onOpenPersonal }) { const f = (typeof fmtDate === 'function') ? fmtDate(date) : { dow: '', day: '', month: '' }; return (
{f.dow} {f.day} {f.month}
{onOpenPersonal && ( )}
); } // ══════════════════════════════════════════════════════════ // PÁGINA PERSONAL — vista completa (como el Historial): personal, // grupos, puntos y análisis. Se abre desde el botón "Personal". // ══════════════════════════════════════════════════════════ const PREP_DEPT_LABELS = { matizacion: 'Matización', envasado: 'Envasado', preparadores: 'Preparadores' }; function PersonalPage({ dept: initialDept = 'preparadores', allowDeptSwitch = false, accessLevel = 'none', isAdmin = false, machines = [], showToast, onBack, backLabel = 'Volver', onRenameGroup }) { const toast = showToast || (() => {}); const [dept, setDept] = useState(initialDept); const [data, setData] = useState({ people: [], groups: [], labors: [], ledger: [], cargos: [], mpoints: [] }); const [loading, setLoading] = useState(true); const [section, setSection] = useState('personal'); // personal | maquinas | extras | puntos | cargos const [deductFor, setDeductFor] = useState(null); // persona a la que se le descuenta const deptLabel = PREP_DEPT_LABELS[dept] || 'Departamento'; const canEdit = accessLevel === 'full'; // completo: personas, grupos, puntos const canManage = canEdit; // crear/eliminar grupos, editar/eliminar personas const canAddMove = accessLevel === 'full' || accessLevel === 'basic'; // agregar personas y moverlas const basicOnly = accessLevel === 'basic'; const API = './api.php'; // Mensaje legible según el estado HTTP / el error del servidor. const httpMsg = (status, j, fallback) => { const code = String((j && (j.error || j.message)) || ''); if (/delete_key_invalid/i.test(code)) return 'Clave de eliminación incorrecta. No se eliminó nada.'; if (/delete_key_not_configured/i.test(code)) return 'No se eliminó: un administrador debe crear primero la clave de eliminación (Usuarios).'; if (status === 401) return 'La sesión expiró. Vuelve a iniciar sesión.'; if (status === 403) return 'No tienes permiso para esta operación.'; return code || fallback || `HTTP ${status}`; }; const _post = (body) => fetch(API, { method: 'POST', credentials: 'include', headers: { 'Content-Type': 'application/json', 'X-Requested-With': 'sp' }, body: JSON.stringify(body), }).then(async r => { const j = await r.json().catch(() => ({})); if (!r.ok || j.error) { const e = new Error(httpMsg(r.status, j)); e.status = r.status; throw e; } return j; }); const [loadError, setLoadError] = useState(''); const loadSeq = useRef(0); const loadAll = async () => { const my = ++loadSeq.current; // ignora respuestas viejas (cambio rápido de departamento) try { const r = await fetch(`${API}?action=prep_get&dept=${encodeURIComponent(dept)}`, { credentials: 'include', headers: { 'X-Requested-With': 'sp' }, cache: 'no-store', }); const j = await r.json().catch(() => null); if (my !== loadSeq.current) return; if (!r.ok || !j || j.error || !j.ok || !j.data) { throw new Error(httpMsg(r.status, j, 'respuesta inválida del servidor')); } setData({ people: j.data.people || [], groups: j.data.groups || [], labors: j.data.labors || [], ledger: j.data.ledger || [], cargos: j.data.cargos || [], mpoints: j.data.mpoints || [], }); setLoadError(''); } catch (err) { if (my !== loadSeq.current) return; // Sin datos nuevos NO se muestran listas vacías como si fueran reales: // se muestra el error en pantalla con opción de reintentar. setLoadError(`No se pudo cargar ${deptLabel.toLowerCase()}: ${err.message || 'error de red'}`); toast(`No se pudo cargar preparadores: ${err.message}`, 'err'); } finally { if (my === loadSeq.current) setLoading(false); } }; useEffect(() => { setLoading(true); setLoadError(''); loadAll(); /* eslint-disable-next-line */ }, [dept]); // ── Operaciones de datos (optimistas + persistencia) ── const saveItem = async (kind, item) => { const bucket = { person: 'people', group: 'groups', labor: 'labors', ledger: 'ledger', cargo: 'cargos', mpoint: 'mpoints' }[kind]; setData(prev => { const list = prev[bucket] || []; const exists = list.some(x => x.id === item.id); const next = exists ? list.map(x => x.id === item.id ? item : x) : [...list, item]; return { ...prev, [bucket]: next }; }); try { await _post({ action: 'prep_save', dept, kind, item_id: item.id, data: item }); return true; } catch (err) { toast(`No se pudo guardar: ${err.message}`, 'err'); loadAll(); // recarga: revierte lo optimista a lo que realmente hay en el servidor return false; } }; const deleteItem = async (kind, id) => { const bucket = { person: 'people', group: 'groups', labor: 'labors', ledger: 'ledger', cargo: 'cargos', mpoint: 'mpoints' }[kind]; // Toda eliminación exige la clave de seguridad (delete_key). Los flujos de la UI // ya la piden con verifyDeleteKey(); si llega aquí sin ella (p. ej. un tipo de // máquina que queda en 0 puntos) se pide ahora. if (!window.__spDeleteKey && !window.verifyDeleteKey(`¿Eliminar este elemento (${kind})?`)) return false; setData(prev => ({ ...prev, [bucket]: (prev[bucket] || []).filter(x => x.id !== id) })); try { await _post({ action: 'prep_delete', dept, kind, item_id: id, delete_key: window.__spDeleteKey }); return true; } catch (err) { toast(`No se pudo eliminar: ${err.message}`, 'err'); loadAll(); return false; } finally { window.__spDeleteKey = undefined; // la clave es de un solo uso } }; const personTotals = useMemo(() => prepPersonTotals(data.ledger, data.people, data.cargos), [data.ledger, data.people, data.cargos]); const groupTotals = useMemo(() => prepGroupTotals(data.ledger), [data.ledger]); // Registrar un descuento manual de puntos a una persona (con observación). const deductPoints = (person, amount, note) => { const pts = Number(amount); if (!person || !Number.isFinite(pts) || !Number.isInteger(pts) || pts <= 0) { toast('El descuento debe ser un número entero mayor a 0', 'err'); return; } const saldo = personTotals[person.id] || 0; if (pts > saldo) { toast(`No se puede descontar más que el saldo disponible (${prepFmtNum(saldo)} pts)`, 'err'); return; } if (!note || !note.trim()) { toast('La observación es obligatoria', 'err'); return; } saveItem('ledger', { id: prepUid(), source: 'deduction', personId: person.id, personName: person.nombre, personCedula: person.cedula, groupId: person.groupId || '', points: pts, note: note.trim(), fecha: prepTodayStr(), createdAt: prepNowIso(), }); setDeductFor(null); toast(`−${prepFmtNum(pts)} pts a ${person.nombre}`); }; const ALL_SECTIONS = [ { id: 'personal', label: 'Personal y Grupos', icon: '👥' }, { id: 'maquinas', label: 'Máquinas', icon: '⚙️' }, { id: 'extras', label: 'Tareas extras', icon: '🧩' }, { id: 'puntos', label: 'Puntos e Historial', icon: '🏆' }, { id: 'cargos', label: 'Cargos', icon: '🏷️' }, { id: 'mpuntos', label: 'Puntos por máquina', icon: '⚙️', adminOnly: true }, ]; const SECTIONS = basicOnly ? ALL_SECTIONS.filter(s => s.id === 'personal') : ALL_SECTIONS.filter(s => !s.adminOnly || isAdmin); const activeSection = SECTIONS.some(s => s.id === section) ? section : 'personal'; const summary = useMemo(() => prepSummary(data.ledger, data.people, data.cargos), [data.ledger, data.people, data.cargos]); const totalPuntos = summary.otorgados; const totalPeoplePts = summary.acumulados; return (
{/* ── Cabecera ── */}
{onBack && ( )}
{basicOnly ? 'Registro de personal' : 'Gestión de personal y puntos'}
{allowDeptSwitch ? 'Elige un departamento para gestionar su personal y puntos.' : `Departamento: ${deptLabel}`}
{allowDeptSwitch ? (
{Object.keys(PREP_DEPT_LABELS).map(d => ( ))}
) : ( {deptLabel} )}
{/* ── Estadísticas ── */}
{data.people.length}
Personal
{data.groups.length}
Grupos
{!basicOnly &&
{prepFmtNum(totalPeoplePts)}
Puntos acumulados
} {!basicOnly &&
{prepFmtNum(totalPuntos)}
Puntos otorgados
}
{/* ── Navegación de secciones (oculta en modo básico) ── */} {SECTIONS.length > 1 && (
{SECTIONS.map(s => ( ))}
)} {/* ── Cuerpo ── */}
{loading ? (
⏳

Cargando…

) : loadError ? (
⚠️

No se pudieron cargar los datos

{loadError}

) : (
{activeSection === 'personal' && ( setDeductFor(p) : null} onRenameGroup={onRenameGroup ? ((oldN, newN) => onRenameGroup(dept, oldN, newN)) : null} /> )} {activeSection === 'maquinas' && ( )} {activeSection === 'extras' && ( )} {activeSection === 'puntos' && ( )} {activeSection === 'cargos' && ( )} {activeSection === 'mpuntos' && ( )}
)}
{deductFor && ( deductPoints(deductFor, amount, note)} onClose={() => setDeductFor(null)} /> )}
); } // ── Fila de persona (nivel superior para no perder foco al editar) ── function PrepPersonRow({ p, groups, cargos, canAddMove, canManage, basicOnly, personTotals, editPerson, setEditPerson, onSaveEdit, onMove, onRemove, onDeduct }) { const editing = editPerson && editPerson.id === p.id; const cargo = (cargos || []).find(c => c.id === p.cargoId); const deductible = cargo && cargo.mode === 'deductible'; return (
{editing ? (
setEditPerson({ ...editPerson, nombre: e.target.value })} /> setEditPerson({ ...editPerson, cedula: e.target.value })} />
) : ( <>
{(p.nombre || '?').trim().charAt(0).toUpperCase()}
{p.nombre} CI {p.cedula}{cargo && {cargo.name}}
{!basicOnly && ( {prepFmtNum(personTotals[p.id] || 0)} pts )} {(canAddMove || canManage) && (
{canAddMove && ( )} {canManage && onDeduct && } {canManage && } {canManage && }
)} )}
); } // ── SECCIÓN: Personal y Grupos ────────────────────────────── function PrepPersonalSection({ data, personTotals, groupTotals, canAddMove, canManage, basicOnly, saveItem, deleteItem, toast, onDeduct, onRenameGroup }) { const { people, groups } = data; const cargos = data.cargos || []; const [pName, setPName] = useState(''); const [pCedula, setPCedula] = useState(''); const [pGroup, setPGroup] = useState(''); const [pCargo, setPCargo] = useState(''); const [gName, setGName] = useState(''); const [editPerson, setEditPerson] = useState(null); // {id,...} const [search, setSearch] = useState(''); const membersOf = (gid) => people.filter(p => p.groupId === gid); const unassigned = people.filter(p => !p.groupId || !groups.some(g => g.id === p.groupId)); const addGroup = () => { const name = gName.trim(); if (!name) return; saveItem('group', { id: prepUid(), name }); setGName(''); toast('Grupo creado'); }; const addPerson = () => { const nombre = pName.trim(); const cedula = prepCleanCedula(pCedula); if (!nombre) { toast('Ingresa el nombre', 'err'); return; } if (!cedula) { toast('Ingresa la cédula', 'err'); return; } // Unicidad por departamento, comparando la cédula normalizada (sin puntos/guiones/espacios). // No se valida contra otros departamentos: aquí solo hay datos del actual. if (people.some(p => prepCedulaKey(p.cedula) === prepCedulaKey(cedula))) { toast('Ya existe una persona con esa cédula', 'err'); return; } saveItem('person', { id: prepUid(), nombre, cedula, groupId: pGroup || '', cargoId: pCargo || '' }); setPName(''); setPCedula(''); // conserva el grupo y cargo elegidos para cargas rápidas toast('Persona agregada'); }; const movePerson = (person, newGroupId) => { // Cambiar de grupo NO afecta los puntos ya ganados (el historial guarda snapshot). saveItem('person', { ...person, groupId: newGroupId }); }; const saveEdit = () => { if (!editPerson) return; const nombre = (editPerson.nombre || '').trim(); const cedula = prepCleanCedula(editPerson.cedula); if (!nombre || !cedula) { toast('Nombre y cédula requeridos', 'err'); return; } if (people.some(p => p.id !== editPerson.id && prepCedulaKey(p.cedula) === prepCedulaKey(cedula))) { toast('Otra persona ya tiene esa cédula', 'err'); return; } saveItem('person', { ...editPerson, nombre, cedula }); setEditPerson(null); toast('Persona actualizada'); }; const removePerson = (p) => { if (!window.verifyDeleteKey(`¿Eliminar a ${p.nombre}? Sus puntos históricos permanecerán en la bitácora, pero ya no sumarán a ningún total.`)) return; deleteItem('person', p.id); }; // Renombrar un grupo. El grupo se identifica por su id, así que el historial // de puntos y la pertenencia del personal no se tocan. Lo único que guarda // el NOMBRE es el campo Operario de las máquinas de Control de Proceso, así // que se actualizan las que estén usando el nombre anterior — incluidas las // que estén en producción en ese momento. const renameGroup = (g) => { const actual = (g.name || '').trim(); const raw = window.prompt(`Nuevo nombre para el grupo "${actual}":`, actual); if (raw === null) return; const nuevo = raw.trim(); if (!nuevo || nuevo === actual) return; if (groups.some(x => x.id !== g.id && (x.name || '').trim().toUpperCase() === nuevo.toUpperCase())) { toast('Ya existe otro grupo con ese nombre', 'err'); return; } saveItem('group', { ...g, name: nuevo }); const afectadas = onRenameGroup ? onRenameGroup(actual, nuevo) : 0; toast(afectadas > 0 ? `Grupo renombrado. ${afectadas} máquina(s) en curso actualizadas.` : 'Grupo renombrado'); }; // Operación en dos pasos (liberar miembros → borrar grupo), SECUENCIAL: si un paso // falla se detiene, saveItem/deleteItem ya recargan desde el servidor (rollback // visual) y se avisa de qué quedó hecho. const busyRef = useRef(false); const removeGroup = async (g) => { if (busyRef.current) return; const mem = membersOf(g.id); const n = mem.length; const msg = n > 0 ? `El grupo "${g.name}" tiene ${n} persona(s). Se eliminará el grupo y esas personas quedarán "sin grupo" (conservan sus puntos). ¿Continuar?` : `¿Eliminar el grupo "${g.name}"?`; if (!window.verifyDeleteKey(msg)) return; busyRef.current = true; try { for (const p of mem) { const ok = await saveItem('person', { ...p, groupId: '' }); if (!ok) { toast(`No se pudo liberar a ${p.nombre}; el grupo NO se eliminó. Se recargaron los datos.`, 'err'); return; } } const ok = await deleteItem('group', g.id); if (!ok) toast(n > 0 ? `El grupo no se eliminó, pero sus ${n} persona(s) ya quedaron sin grupo.` : 'El grupo no se eliminó.', 'err'); } finally { window.__spDeleteKey = undefined; busyRef.current = false; } }; const qWords = search.trim().toLowerCase().split(/\s+/).filter(Boolean); const matchP = (p) => !qWords.length || qWords.every(w => `${p.nombre || ''} ${p.cedula || ''}`.toLowerCase().includes(w)); const rowProps = { groups, cargos, canAddMove, canManage, basicOnly, personTotals, editPerson, setEditPerson, onSaveEdit: saveEdit, onMove: movePerson, onRemove: removePerson, onDeduct, }; return (
{basicOnly && (
Tu acceso permite agregar personas y moverlas de grupo. Para más acciones, contacta al supervisor.
)} {(canManage || canAddMove) && (
{canManage && (

Nuevo grupo

setGName(e.target.value)} onKeyDown={e => e.key === 'Enter' && addGroup()} />
)} {canAddMove && (

Agregar personal

setPName(e.target.value)} onKeyDown={e => e.key === 'Enter' && addPerson()} /> setPCedula(e.target.value)} onKeyDown={e => e.key === 'Enter' && addPerson()} />
)}
)}
setSearch(e.target.value)} />
{groups.length === 0 && people.length === 0 ? (
👥

Sin personal ni grupos

{canAddMove ? 'Agrega personas con su nombre y cédula.' : 'Aún no hay datos cargados.'}

) : (
{groups.map(g => { const mem = membersOf(g.id).filter(matchP); const allMem = membersOf(g.id); return (
{g.name} {allMem.length} persona(s) · {prepFmtNum(groupTotals[g.id] || 0)} pts históricos
{canManage && } {canManage && }
{allMem.length === 0 &&
Sin miembros. {canAddMove && 'Asigna personas desde su selector de grupo.'}
} {mem.map(p => )}
); })} {unassigned.filter(matchP).length > 0 && (
Sin grupo {unassigned.length} persona(s)
{unassigned.filter(matchP).map(p => )}
)}
)}
); } // ── MODAL: descontar puntos (con observación obligatoria) ── function PrepDeductModal({ person, currentPts, onConfirm, onClose }) { const [amount, setAmount] = useState(''); const [note, setNote] = useState(''); // Tope = saldo disponible; solo enteros > 0 (nunca deja a nadie en negativo). const maxPts = Math.max(0, Math.floor(Number(currentPts) || 0)); const raw = String(amount).trim(); const amt = Number(raw); const amtErr = raw === '' ? '' : (!Number.isFinite(amt) || !Number.isInteger(amt)) ? 'Debe ser un número entero.' : amt <= 0 ? 'Debe ser mayor a 0.' : amt > maxPts ? `No puede superar el saldo disponible (${prepFmtNum(maxPts)} pts).` : ''; const canConfirm = raw !== '' && !amtErr && note.trim() !== '' && maxPts > 0; return (
e.target === e.currentTarget && onClose && onClose()}>

Descontar puntos

{person.nombre} · CI {person.cedula} Saldo actual: {prepFmtNum(currentPts)} pts