182 lines
7.7 KiB
JavaScript
182 lines
7.7 KiB
JavaScript
// 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` : "");
|