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

333 lines
16 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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);