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

334 lines
16 KiB
JavaScript
Raw Permalink Normal View History

// Agendador de actividades — configuración y lógica PURA (sin Dynamics ni React), compartida
// por la pantalla (cliente) y las acciones de servidor, que vuelven a validar todo antes de crear.
// Diseño y decisiones: Proyectos/Análisis e Informes/Analitica de CRM/agendador-automatico-diseno.md
import { actAncla } from "./derive";
import { addDays, esHabil } from "./plan";
export const AGENDADOR = {
// Ejecutivos con agendador. Empezó como piloto de María (2026-10-27); desde 2026-11-06 va para los 5
// ejecutivos de venta (a pedido de Marco, para presentarlo al equipo). Para quitar a alguien, sacar su correo.
piloto: [
"mirna.obando@alfa.com.ni",
"maria.marenco@alfa.com.ni",
"denis.urroz@alfa.com.ni",
"daybellys.perez@alfa.com.ni",
"martha.somarriba@alfa.com.ni",
// Marco (administrador): para probar y presentar con sus oportunidades de prueba (EMPRESA ABC).
"marco.montenegro@alfa.com.ni",
],
// Asistente de ventas: puede ver y agendar para los ejecutivos del piloto (no es administrador).
asistentes: ["ashley.bermudez@alfa.com.ni"],
// Máximo por día, por tipo. Llamadas y visitas (citas) las fijó Marco (2026-11-11: 10 y 4); el de tareas es un supuesto.
topes: { Llamada: 10, Cita: 4, Tarea: 6 },
// Horario (hora de Nicaragua, minutos desde las 00:00), de lunes a viernes: 8:30–12:00 y 13:30–17:00 (2026-11-11).
// Cuadra: 4 visitas de 60 min + 10 llamadas de 10 min = 340 min de los 420 que tiene el día.
franjas: [[510, 720], [810, 1020]],
duracion: { Llamada: 10, Cita: 60 }, // minutos (llamada 30 → 10 el 2026-11-11)
paso: { Llamada: 10, Cita: 30 }, // las horas de inicio salen cada 10 min (llamadas) o cada 30 min (visitas)
// Las tareas no ocupan horario: vencen a las 16:00 del día elegido. Es una hora de vencimiento fija, NO está
// ligada al fin de la franja de la tarde (el 2026-11-11 la franja pasó a 17:00 y se dejó en 16:00 a propósito).
horaTarea: 960,
horizonteDias: 30, // se puede agendar desde hoy hasta hoy + 30 días (2026-11-06)
diasVentana: 5, // la propuesta reparte en 5 días hábiles a partir de la fecha elegida
};
// Días hábiles de agendado: los primeros 5 días hábiles desde la fecha elegida (nunca antes de hoy).
// Devuelve [] si la fecha pasa del horizonte (hoy + 30 días).
export function ventanaDe(fecha, hoy) {
const max = addDays(hoy, AGENDADOR.horizonteDias);
let d = fecha && fecha > hoy ? fecha : hoy;
if (d > max) return [];
const out = [];
for (let i = 0; i < 40 && out.length < AGENDADOR.diasVentana; i++, d = addDays(d, 1)) if (esHabil(d)) out.push(d);
return out;
}
export const fechaMaxima = (hoy) => addDays(hoy, AGENDADOR.horizonteDias);
// Prioridad sugerida (variante E, validada por Marco el 2026-11-06 tras compararla con Mirna, Daybellys
// y Denis). Reglas explicables, no un puntaje:
// Revisar fecha = vencida con forecast ≤40 % (probable fecha desactualizada: se corrige o se cierra)
// Alta = forecast ≥80 %, o valor en el tercio superior de SU cartera con forecast ≥50 %
// Baja = forecast ≤40 % con valor en el tercio inferior, o cierre a más de 60 días
// Media = el resto
// Los tercios de valor se miden sobre la cartera completa de ese ejecutivo (no hay montos fijos).
export const NIVELES_PRIO = ["Alta", "Media", "Baja", "Revisar fecha"];
export function calcularPrioridades(candidatos, hoy) {
const vals = candidatos.map((c) => c.valor || 0).sort((a, b) => a - b);
const q = (p) => (vals.length ? vals[Math.floor(p * (vals.length - 1))] : 0);
const lo = q(1 / 3);
const hi = q(2 / 3);
const limite60 = addDays(hoy, 60);
const out = new Map();
for (const c of candidatos) {
const pct = c.pct || 0;
const v = c.valor || 0;
const vencida = !!c.cierre && c.cierre < hoy;
const alto = v > 0 && v >= hi;
let nivel;
const motivos = [];
if (vencida && pct <= 40) {
nivel = "Revisar fecha";
motivos.push("Vencida con forecast bajo");
} else if (pct >= 80 || (alto && pct >= 50)) {
nivel = "Alta";
if (pct >= 80) motivos.push("Etapa avanzada");
if (alto && pct >= 50) motivos.push("Valor alto");
if (vencida) motivos.push("Cierre vencido");
} else if ((pct <= 40 && v <= lo) || (c.cierre && c.cierre > limite60)) {
nivel = "Baja";
motivos.push(c.cierre && c.cierre > limite60 ? "Cierre lejano" : "Etapa temprana y valor bajo");
} else {
nivel = "Media";
motivos.push(pct >= 50 ? "Etapa intermedia" : "Etapa temprana");
if (vencida) motivos.push("Cierre vencido");
}
out.set(c.id, { prioNivel: nivel, prioRank: NIVELES_PRIO.indexOf(nivel), prioMotivos: motivos.slice(0, 2) });
}
return out;
}
// Orden para repartir la agenda: prioridad (Alta primero), luego mayor valor.
export const porPrioridadSugerida = (x, y) => (x.prioRank ?? 1) - (y.prioRank ?? 1) || (y.valor || 0) - (x.valor || 0) || (y.pct || 0) - (x.pct || 0);
export const TIPOS_AGENDADOR = ["Llamada", "Cita", "Tarea"];
export const ENTIDAD_TIPO = { Llamada: "phonecalls", Cita: "appointments", Tarea: "tasks" };
// Objetivos que ofrece el agendador (nombres del catálogo `alfa_objetivosdeactividades`).
export const OBJETIVOS_AGENDADOR = [
"Calificar Oportunidad",
"Diagnosticar Necesidades",
"Presentación de Servicio",
"Presentar Oferta",
"Negociación",
"Firma Contrato-Adendum",
"Renovación",
];
// Objetivos al crear una actividad a mano (calendario, ficha de cuenta, seguimiento): los del Agendador más
// «Prospección» (catálogo `alfa_objetivosdeactividades`), para programar prospección sobre cuentas sin oportunidad,
// y los 4 que Marco agregó el 2026-11-19 (no entran al Agendador masivo). Los nombres deben coincidir EXACTO con
// Dynamics: el servidor busca el GUID por nombre (`objetivosPorNombre`). Catálogo completo y decisiones:
// Proyectos/Análisis e Informes/Analitica de CRM/referencia-objetivos-de-actividad.md
export const OBJETIVOS_LIBRES = [
"Prospección",
...OBJETIVOS_AGENDADOR,
"Reunión Técnica",
"Recopilación Proyecto SW",
"Retención",
"Cobro Factura",
];
const OFFSET_MS = 6 * 3600 * 1000; // Nicaragua = UTC-6 todo el año
export const minAHora = (m) => `${String(Math.floor(m / 60)).padStart(2, "0")}:${String(m % 60).padStart(2, "0")}`;
export const horaAMin = (h) => {
const m = /^(\d{2}):(\d{2})$/.exec(h || "");
return m ? Number(m[1]) * 60 + Number(m[2]) : null;
};
// Hora local (Nicaragua) de un instante ISO: { dia: "YYYY-MM-DD", min }.
export function localDeIso(iso) {
const d = new Date(new Date(iso).getTime() - OFFSET_MS);
return { dia: d.toISOString().slice(0, 10), min: d.getUTCHours() * 60 + d.getUTCMinutes() };
}
// Fecha y hora de Nicaragua → instante ISO en UTC (lo que espera Dynamics).
export const aUtc = (dia, hora) => new Date(`${dia}T${hora}:00-06:00`).toISOString();
// Horas de inicio posibles de un tipo (Tarea no tiene hora: vence a las 16:00).
export function horasDe(tipo) {
if (tipo === "Tarea") return [];
const dur = AGENDADOR.duracion[tipo];
const out = [];
const paso = AGENDADOR.paso[tipo];
for (const [a, b] of AGENDADOR.franjas) for (let s = a; s + dur <= b; s += paso) out.push(s);
return out;
}
// Horas (HH:MM) que de verdad se pueden ofrecer para `tipo` en `dia`: si es hoy, solo las futuras (con un margen de
// 5 min por lo que tarda el clic) y sin las que choquen con los bloques ya ocupados (`bloques`: [[ini, fin], …] en
// minutos). Para otros días devuelve el horario completo. El servidor (`validar`) vuelve a comprobar todo.
export function horasLibres({ tipo, dia, hoy, ahoraMin, bloques }) {
const dur = AGENDADOR.duracion[tipo];
return horasDe(tipo)
.filter((s) => dia !== hoy || (s >= ahoraMin + 5 && libre(bloques, s, dur)))
.map(minAHora);
}
// «8:30–12:00 y 13:30–17:00», para los textos de ayuda y avisos (siempre sale de AGENDADOR.franjas).
export const textoHorario = () =>
AGENDADOR.franjas.map(([a, b]) => `${minAHora(a).replace(/^0/, "")}–${minAHora(b).replace(/^0/, "")}`).join(" y ");
// De las actividades del ejecutivo (no canceladas) saca, por día: cuántas hay de cada tipo (para los
// topes) y los bloques de tiempo ocupados por llamadas y citas (para no encimar horarios).
// `acts`: [{ tipo, estado, scheduledstart, scheduledend }].
export function resumenExistentes(acts) {
const existentes = {};
const bloques = {};
for (const a of acts || []) {
if (a.estado === "cancelada" || !TIPOS_AGENDADOR.includes(a.tipo)) continue;
const anc = actAncla(a);
if (!anc) continue;
const { dia } = localDeIso(anc);
(existentes[dia] ||= { Llamada: 0, Cita: 0, Tarea: 0 })[a.tipo]++;
if (a.tipo !== "Tarea" && a.scheduledstart && a.scheduledend) {
const i = localDeIso(a.scheduledstart);
const f = localDeIso(a.scheduledend);
if (i.dia === f.dia && f.min > i.min) (bloques[i.dia] ||= []).push([i.min, f.min]);
}
}
return { existentes, bloques };
}
const cuentaVacia = () => ({ Llamada: 0, Cita: 0, Tarea: 0 });
const total = (c) => c.Llamada + c.Cita + c.Tarea;
const libre = (bl, s, dur) => !(bl || []).some(([a, b]) => s < b && s + dur > a);
// Reparte los candidatos en los días de la semana. Los más prioritarios (forecast 80/90, luego mayor
// valor) se colocan primero y caen en los días más tempranos y con menos carga; las llamadas y citas
// se acomodan en la primera hora libre del horario permitido. Los que no caben quedan sin día
// (`sinCupo`). `dias`: días hábiles permitidos; `ahoraMin`: hora actual (si `hoy` está en `dias`, no
// se agenda antes de ahora + 30 min).
export function proponer({ candidatos, dias, existentes, bloques, hoy, ahoraMin, tipo = "Llamada" }) {
const cuenta = {};
const ocup = {};
dias.forEach((d) => {
cuenta[d] = { ...cuentaVacia(), ...(existentes?.[d] || {}) };
ocup[d] = [...(bloques?.[d] || [])];
});
const orden = [...candidatos].sort(porPrioridadSugerida);
const items = [];
for (const c of orden) {
const lugar = colocar({ tipo, dias, cuenta, ocup, hoy, ahoraMin, urgente: (c.pct || 0) >= 80 || c.prioRank === 0 });
items.push({ ...baseItem(c, tipo), dia: lugar?.dia || null, hora: lugar?.hora || null, sinCupo: !lugar, incluir: !!lugar });
}
return items;
}
// Prioridad: forecast más alto primero; a igual forecast, el cierre estimado más próximo primero
// (las ya vencidas, antes que todas); luego mayor valor.
export const porPrioridad = (x, y) =>
(y.pct || 0) - (x.pct || 0) ||
(x.cierre || "9999-12-31").localeCompare(y.cierre || "9999-12-31") ||
(y.valor || 0) - (x.valor || 0);
// Fila del agendador a partir de una oportunidad candidata (sin día/hora todavía).
export function baseItem(c, tipo) {
return {
key: c.id,
oppId: c.id,
nombre: c.nombre,
cliente: c.cliente,
valor: c.valor,
pct: c.pct,
esRenovacion: !!c.esRenovacion,
tipoCodigo: c.tipoCodigo ?? null,
tipoOpp: c.tipo || null,
plan: c.plan || null,
forecast: c.forecast || null,
env: c.env ?? null,
dsa: c.dsa ?? null,
cierre: c.cierre || null,
prioNivel: c.prioNivel || null,
prioRank: c.prioRank ?? null,
prioMotivos: c.prioMotivos || [],
tipo,
objetivo: c.objetivoSugerido || "",
gv: false, // «Con GV»: participa Gerencia Comercial (solo llamadas y visitas)
};
}
// Suma lo ya decidido (filas marcadas, con día/hora fijos) a lo existente, para que la propuesta del
// resto se acomode ALREDEDOR sin pisarlo ni pasarse de los máximos por día.
export function sumarFijos(existentes, bloques, items) {
const ex = {};
Object.entries(existentes || {}).forEach(([d, c]) => { ex[d] = { ...c }; });
const bl = {};
Object.entries(bloques || {}).forEach(([d, b]) => { bl[d] = [...b]; });
for (const it of items) {
if (!it.dia) continue;
(ex[it.dia] ||= cuentaVacia())[it.tipo]++;
if (it.tipo !== "Tarea" && it.hora) {
const s = horaAMin(it.hora);
if (s != null) (bl[it.dia] ||= []).push([s, s + AGENDADOR.duracion[it.tipo]]);
}
}
return { existentes: ex, bloques: bl };
}
// Las de forecast 80/90 % (`urgente`) van al día más temprano con cupo; el resto se reparte por carga
// (el día con menos actividades primero) para que la semana quede pareja.
function colocar({ tipo, dias, cuenta, ocup, hoy, ahoraMin, urgente }) {
const tope = AGENDADOR.topes[tipo];
const candidatos = dias
.filter((d) => cuenta[d][tipo] < tope)
.sort((a, b) => (urgente ? 0 : total(cuenta[a]) - total(cuenta[b])) || a.localeCompare(b));
for (const d of candidatos) {
if (tipo === "Tarea") {
if (d === hoy && ahoraMin != null && AGENDADOR.horaTarea <= ahoraMin) continue;
cuenta[d].Tarea++;
return { dia: d, hora: minAHora(AGENDADOR.horaTarea) };
}
const dur = AGENDADOR.duracion[tipo];
for (const s of horasDe(tipo)) {
if (d === hoy && ahoraMin != null && s < ahoraMin + 30) continue;
if (!libre(ocup[d], s, dur)) continue;
ocup[d].push([s, s + dur]);
cuenta[d][tipo]++;
return { dia: d, hora: minAHora(s) };
}
}
return null;
}
// Valida lo que se va a crear (items ya filtrados a los marcados). Devuelve los problemas por fila y
// el conteo por día. La pantalla lo usa para avisar; el servidor lo vuelve a correr y NO crea nada si
// hay algún problema.
// `objetivos`: catálogo permitido (el Agendador masivo usa OBJETIVOS_AGENDADOR; el seguimiento, OBJETIVOS_LIBRES).
export function validar({ items, dias, existentes, bloques, hoy, ahoraMin, objetivos = OBJETIVOS_AGENDADOR }) {
const porItem = {};
const marca = (k, m) => (porItem[k] ||= []).push(m);
const cuenta = {};
const ocup = {};
const dia = (d) => {
cuenta[d] ||= { ...cuentaVacia(), ...(existentes?.[d] || {}) };
ocup[d] ||= [...(bloques?.[d] || [])];
};
for (const it of items) {
if (!TIPOS_AGENDADOR.includes(it.tipo)) { marca(it.key, "Tipo no válido."); continue; }
if (!it.objetivo) marca(it.key, "Elige un objetivo.");
else if (!objetivos.includes(it.objetivo)) marca(it.key, "Objetivo no permitido.");
if (it.gv && it.tipo === "Tarea") marca(it.key, "Las tareas no llevan participación de Gerencia (GV).");
if (!dias.includes(it.dia)) { marca(it.key, "Elige un día hábil dentro de los días de agendado (desde hoy)."); continue; }
dia(it.dia);
cuenta[it.dia][it.tipo]++;
if (cuenta[it.dia][it.tipo] > AGENDADOR.topes[it.tipo]) {
marca(it.key, `Supera el máximo de ${AGENDADOR.topes[it.tipo]} ${it.tipo === "Tarea" ? "tareas" : it.tipo === "Cita" ? "visitas" : "llamadas"} por día.`);
}
if (it.tipo === "Tarea") continue;
const s = horaAMin(it.hora);
if (s == null || !horasDe(it.tipo).includes(s)) { marca(it.key, `Elige una hora dentro del horario (${textoHorario()}).`); continue; }
if (it.dia === hoy && ahoraMin != null && s < ahoraMin) marca(it.key, "Esa hora ya pasó.");
const dur = AGENDADOR.duracion[it.tipo];
if (!libre(ocup[it.dia], s, dur)) marca(it.key, "Se encima con otra actividad.");
ocup[it.dia].push([s, s + dur]);
}
return { porItem, porDia: cuenta, ok: Object.keys(porItem).length === 0 };
}
// Asunto y descripción de lo que se crea en Dynamics.
export function asuntoDe(it) {
const quien = (it.cliente || it.nombre || "").slice(0, 80);
const base = `${it.objetivo}${quien ? `: ${quien}` : ""}`;
return it.tipo === "Cita" ? `Visita – ${base}` : base;
}
// La descripción de una CITA es la invitación que Outlook/Teams envía al contacto: se deja vacía para que
// ningún comentario interno llegue por accidente a un cliente (solicitado por el equipo, 2026-11-07).
// Llamadas y tareas son internas: conservan la marca de origen.
export function descripcionDe(it, creadoPor) {
if (it.tipo === "Cita") return undefined;
return `Creada por el agendador de actividades (${creadoPor}).`;
}
// «Actividad para» (picklist de las actividades): Venta - Cliente Nuevo (100000000) → Cliente Nuevo
// (100000001); el resto → Cliente Activo (100000000).
export const actividadParaDe = (tipoCodigo) => (tipoCodigo === 100000000 ? 100000001 : 100000000);