informe-comercial-alfa/app/lib/agendaDia.js

183 lines
7.7 KiB
JavaScript
Raw Permalink Normal View History

// Vista cronológica del Plan del Día y del Plan de Actividades (rediseño 2026-11-13, solo pantalla; el PDF sigue por objetivo).
// Funciones PURAS: reagrupan lo que ya arma lib/plan.js (armarPlan / armarPlanPeriodo) en una lista plana de actividades,
// una por fila, ordenada por hora, y calculan cruces de horario y huecos libres. No tocan reglas de negocio ni Dynamics.
import { AGENDADOR, localDeIso, minAHora } from "./agendador";
import { diaDe, esHabil } from "./plan";
import { gcDe } from "./gerencia";
import { etiquetasGV } from "./planDia";
export const ROTULO_TIPO = { Llamada: "Llamada", Cita: "Visita", Tarea: "Tarea" };
export const ICONO_TIPO = { Llamada: "📞", Cita: "🤝", Tarea: "☑" };
const ORDEN_TIPO = { Llamada: 0, Cita: 1, Tarea: 2 };
// Instante con que se muestra la actividad: llamada/visita = inicio; tarea = vencimiento (igual que AccionesFila).
const instante = (a) => (a.tipo === "Tarea" ? a.scheduledend || a.scheduledstart : a.scheduledstart || a.scheduledend);
// Duración en minutos de una llamada o visita: la real (scheduledend - scheduledstart) si existe; si no, la del agendador.
function duracionDe(a) {
if (a.tipo === "Tarea") return null;
if (a.scheduledstart && a.scheduledend) {
const d = Math.round((Date.parse(a.scheduledend) - Date.parse(a.scheduledstart)) / 60000);
if (d > 0) return d;
}
return AGENDADOR.duracion[a.tipo] ?? 10;
}
// Una entrada por actividad de cada fila del plan. `secciones`: salida de armarPlan / armarPlanPeriodo.
// La sección (color, chip) es la de la FILA donde hoy aparece la actividad (la que ya decide lib/plan.js), así chips,
// barra del PDF y MRR por sección cuadran. `porHora`: una actividad abierta de HOY cuya hora ya pasó cuenta como vencida
// (Plan del Día); sin ella, solo vencen las de días anteriores a hoy (criterio del Plan de Actividades y de su filtro ?venc=1).
export function listaPlana(secciones, { hoy, ahoraMin = 0, porHora = false }) {
const out = [];
for (const s of secciones) {
for (const r of s.filas) {
const filaGC = r.acts.some((a) => gcDe(a));
for (const a of r.acts) {
const iso = instante(a);
const min = iso ? localDeIso(iso).min : null;
const dia = diaDe(a);
const abierta = a.estado !== "completada";
const vencida = abierta && !!dia && (dia < hoy || (porHora && dia === hoy && min != null && min < ahoraMin));
out.push({
id: a.id,
fila: r.key,
sec: s.key,
secTitulo: s.titulo,
owner: r.owner,
dia,
min,
dur: duracionDe(a),
tipo: a.tipo,
esTarea: a.tipo === "Tarea",
completada: a.estado === "completada",
vencida,
objetivo: a.objetivo || "(sin objetivo)",
valor: r.opp.valor ?? null,
opp: r.opp,
a,
gv: etiquetasGV([a]),
esGC: !!gcDe(a),
filaGC,
filaVencidas: r.vencidas || 0,
cruce: null,
});
}
}
}
return out.sort(comparar);
}
// Orden: día, tareas al final de su día, hora, tipo (llamada antes que visita), ejecutivo.
function comparar(x, y) {
return (
String(x.dia).localeCompare(String(y.dia)) ||
Number(x.esTarea) - Number(y.esTarea) ||
(x.min ?? 1e9) - (y.min ?? 1e9) ||
ORDEN_TIPO[x.tipo] - ORDEN_TIPO[y.tipo] ||
x.owner.localeCompare(y.owner)
);
}
// Marca las llamadas/visitas ABIERTAS de un mismo ejecutivo y día cuyos horarios se solapan: it.cruce = «visita 09:00» (+N).
// Muta y devuelve la misma lista.
export function marcarCruces(items) {
const grupos = new Map();
for (const it of items) {
if (it.esTarea || it.completada || it.min == null || !it.dur) continue;
const k = `${it.owner}|${it.dia}`;
if (!grupos.has(k)) grupos.set(k, []);
grupos.get(k).push(it);
}
for (const g of grupos.values()) {
for (const x of g) {
const otros = g.filter((y) => y !== x && x.min < y.min + y.dur && y.min < x.min + x.dur);
if (!otros.length) continue;
const o = otros[0];
x.cruce = `${ROTULO_TIPO[o.tipo].toLowerCase()} de ${minAHora(o.min)}${otros.length > 1 ? ` (+${otros.length - 1})` : ""}`;
}
}
return items;
}
// Huecos libres de ≥ 60 min dentro de las franjas del agendador, entre las llamadas/visitas con hora del día `dia`
// (de UN ejecutivo). Solo de hoy en adelante, en día hábil; en hoy, desde la hora actual (redondeada a 10 min).
// Devuelve [{ dia, desde, hasta, minutos, visitas, llamadas }].
export function huecosLibres(items, dia, hoy, ahoraMin) {
if (!dia || dia < hoy || !esHabil(dia)) return [];
const ocupados = items
.filter((it) => it.dia === dia && !it.esTarea && it.min != null && it.dur)
.map((it) => [it.min, it.min + it.dur])
.sort((p, q) => p[0] - q[0]);
const out = [];
const empuja = (desde, hasta) => {
const minutos = hasta - desde;
if (minutos >= 60) out.push({ dia, desde, hasta, minutos, visitas: Math.floor(minutos / 60), llamadas: Math.floor(minutos / AGENDADOR.duracion.Llamada) });
};
for (const [a0, b] of AGENDADOR.franjas) {
let cur = dia === hoy ? Math.max(a0, Math.ceil(ahoraMin / 10) * 10) : a0;
if (cur >= b) continue;
for (const [s, e] of ocupados) {
if (e <= cur) continue;
if (s >= b) break;
if (s > cur) empuja(cur, Math.min(s, b));
cur = Math.max(cur, e);
if (cur >= b) break;
}
if (cur < b) empuja(cur, b);
}
return out;
}
// Filas visibles de un grupo (ya ordenado): { k: "act", it } | { k: "hueco", h } | { k: "ahora", min } | { k: "tareas" }.
// Las llamadas/visitas y los huecos se intercalan por hora; la línea «Ahora» (si se pide) va antes de lo que viene;
// las tareas van al final, tras un separador si `conSeparadorTareas`.
export function intercalar(items, { huecos = [], ahoraMin = null, conSeparadorTareas = false } = {}) {
const conHora = items.filter((it) => !it.esTarea);
const tareas = items.filter((it) => it.esTarea);
const mezcla = [
...conHora.map((it) => ({ clave: it.min ?? 1e9, fila: { k: "act", it } })),
...huecos.map((h) => ({ clave: h.desde, fila: { k: "hueco", h } })),
];
if (ahoraMin != null) mezcla.push({ clave: ahoraMin - 0.5, fila: { k: "ahora", min: ahoraMin } });
mezcla.sort((p, q) => p.clave - q.clave);
const rows = mezcla.map((m) => m.fila);
if (tareas.length) {
if (conSeparadorTareas) rows.push({ k: "tareas" });
for (const it of tareas) rows.push({ k: "act", it });
}
return rows;
}
// Agrupa una lista ya ordenada por `owner` o por `dia`; grupos en orden de clave.
export function agrupar(items, por) {
const m = new Map();
for (const it of items) {
const k = it[por];
if (!m.has(k)) m.set(k, []);
m.get(k).push(it);
}
return [...m.entries()].sort((p, q) => String(p[0]).localeCompare(String(q[0]))).map(([key, its]) => ({ key, items: its }));
}
// Totales de una lista: actividades, hechas, vencidas y MRR SIN contar dos veces la misma oportunidad/caso/cuenta
// (una fila del plan con varias actividades suma su valor una sola vez, igual que los subtotales de lib/plan.js).
export function totales(items) {
const filas = new Map();
let hechas = 0;
let vencidas = 0;
for (const it of items) {
filas.set(it.fila, it.valor || 0);
if (it.completada) hechas++;
if (it.vencida) vencidas++;
}
let mrr = 0;
for (const v of filas.values()) mrr += v;
return { n: items.length, hechas, vencidas, mrr };
}
const DIAS_LARGOS = ["Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"];
// «Lunes 16/11» a partir de «2026-11-16».
export const etiquetaDia = (iso) => `${DIAS_LARGOS[new Date(`${iso}T12:00:00Z`).getUTCDay()]} ${iso.slice(8, 10)}/${iso.slice(5, 7)}`;
export const durTxt = (it) => (it.esTarea ? "tarea" : it.dur ? `${it.dur} min` : "");