194 lines
8.6 KiB
JavaScript
194 lines
8.6 KiB
JavaScript
// Agendador sugerido de la semana — 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";
|
||
|
||
export const AGENDADOR = {
|
||
// PILOTO (2026-10-27): solo estos ejecutivos tienen agendador. Para ampliarlo, agregar correos aquí.
|
||
piloto: ["maria.marenco@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; el de tareas es un supuesto.
|
||
topes: { Llamada: 6, Cita: 3, Tarea: 6 },
|
||
// Horario (hora de Nicaragua, minutos desde las 00:00), de lunes a viernes: 9:00–12:00 y 14:00–16:00.
|
||
franjas: [[540, 720], [840, 960]],
|
||
duracion: { Llamada: 30, Cita: 60 }, // minutos
|
||
paso: 30, // las horas de inicio salen cada 30 min
|
||
horaTarea: 960, // las tareas vencen a las 16:00 del día elegido
|
||
};
|
||
|
||
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",
|
||
];
|
||
|
||
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 = [];
|
||
for (const [a, b] of AGENDADOR.franjas) for (let s = a; s + dur <= b; s += AGENDADOR.paso) out.push(s);
|
||
return out;
|
||
}
|
||
|
||
// 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((x, y) => (y.pct || 0) - (x.pct || 0) || (y.valor || 0) - (x.valor || 0));
|
||
const items = [];
|
||
for (const c of orden) {
|
||
const lugar = colocar({ tipo, dias, cuenta, ocup, hoy, ahoraMin, urgente: (c.pct || 0) >= 80 });
|
||
items.push({
|
||
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,
|
||
tipo,
|
||
objetivo: c.objetivoSugerido || "",
|
||
dia: lugar?.dia || null,
|
||
hora: lugar?.hora || null,
|
||
sinCupo: !lugar,
|
||
incluir: !!lugar,
|
||
});
|
||
}
|
||
return items;
|
||
}
|
||
|
||
// 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.
|
||
export function validar({ items, dias, existentes, bloques, hoy, ahoraMin }) {
|
||
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_AGENDADOR.includes(it.objetivo)) marca(it.key, "Objetivo no permitido.");
|
||
if (!dias.includes(it.dia)) { marca(it.key, "Elige un día hábil de la semana (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 (9:00–12:00 y 14:00–16:00)."); 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;
|
||
}
|
||
export function descripcionDe(it, creadoPor) {
|
||
const nota =
|
||
it.tipo === "Cita"
|
||
? " Completar en el CRM el lugar, los participantes y demás datos de la cita."
|
||
: "";
|
||
return `Creada por el agendador de la semana (${creadoPor}).${nota}`;
|
||
}
|
||
|
||
// «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);
|