397 lines
18 KiB
JavaScript
397 lines
18 KiB
JavaScript
import { dv, fv, lookupType, odataString } from "./dataverse";
|
|
import { derivePipelineRow, segmentoDe, normComp, EJECUTIVOS_VENTA, OBJETIVO_A_ETAPA } from "./derive";
|
|
|
|
const OPP_SELECT = [
|
|
"opportunityid",
|
|
"name",
|
|
"_ownerid_value",
|
|
"alfa_typeopportunity",
|
|
"alfa_tipodeventa",
|
|
"_alfa_lineadenegocioid_value",
|
|
"_alfa_servicioproductoid_value",
|
|
"estimatedvalue",
|
|
"actualvalue",
|
|
"alfa_plandecierre",
|
|
"alfa_envejecimiento",
|
|
"alfa_diassinactividad",
|
|
"estimatedclosedate",
|
|
"actualclosedate",
|
|
"stepname",
|
|
"alfa_estadodelanegociacion",
|
|
"_customerid_value",
|
|
"_campaignid_value",
|
|
"_alfa_competidorid_value",
|
|
"alfa_puntuaciondelaoportunidad",
|
|
"alfa_niveldeoportunidadestrellas",
|
|
"alfa_clasificaciondeoportunidad",
|
|
"alfa_luzamarilla",
|
|
"msdyn_forecastcategory",
|
|
].join(",");
|
|
|
|
// Tubería: 5 tipos de la cartera "en pipeline" (ver ALFA_Estructura_Oportunidades_CRM.md).
|
|
const PIPE_TYPE_FILTER =
|
|
"(alfa_typeopportunity eq 100000000 or alfa_typeopportunity eq 100000003 or " +
|
|
"alfa_typeopportunity eq 100000004 or alfa_typeopportunity eq 100000007 or alfa_typeopportunity eq 100000009)";
|
|
|
|
// Renovaciones: Contrato Vencido (100000002) y Próximo a Vencer 30/60/90 (100000001) — universo
|
|
// aparte de Ventas, no cuenta para cumplimiento de meta (ver CLAUDE.md).
|
|
const REN_TYPE_FILTER = "(alfa_typeopportunity eq 100000001 or alfa_typeopportunity eq 100000002)";
|
|
|
|
function chunk(arr, size) {
|
|
const out = [];
|
|
for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
|
|
return out;
|
|
}
|
|
|
|
export async function getSystemUsers(accessToken) {
|
|
const data = await dv(
|
|
"systemusers?$select=systemuserid,fullname,internalemailaddress&$filter=isdisabled eq false",
|
|
accessToken
|
|
);
|
|
return (data.value || []).map((u) => ({
|
|
id: u.systemuserid,
|
|
name: u.fullname,
|
|
email: (u.internalemailaddress || "").toLowerCase(),
|
|
}));
|
|
}
|
|
|
|
export async function resolveOwnerId(email, accessToken) {
|
|
if (!email) return null;
|
|
const data = await dv(
|
|
`systemusers?$select=systemuserid&$filter=${encodeURIComponent(
|
|
`internalemailaddress eq '${odataString(email)}'`
|
|
)}`,
|
|
accessToken
|
|
);
|
|
return data.value?.[0]?.systemuserid || null;
|
|
}
|
|
|
|
function mapOpportunityRow(o) {
|
|
const tipo = fv(o, "alfa_typeopportunity");
|
|
return {
|
|
id: o.opportunityid,
|
|
name: o.name,
|
|
owner: fv(o, "_ownerid_value"),
|
|
tipo,
|
|
segmento: segmentoDe(tipo),
|
|
origen: fv(o, "alfa_tipodeventa"),
|
|
linea: fv(o, "_alfa_lineadenegocioid_value"),
|
|
servicio: fv(o, "_alfa_servicioproductoid_value"),
|
|
est: o.estimatedvalue || 0,
|
|
actual: o.actualvalue || 0,
|
|
plan: fv(o, "alfa_plandecierre"),
|
|
env: o.alfa_envejecimiento ?? null,
|
|
dsa: o.alfa_diassinactividad ?? null,
|
|
close: o.estimatedclosedate ? o.estimatedclosedate.slice(0, 10) : null,
|
|
actualClose: o.actualclosedate ? o.actualclosedate.slice(0, 10) : null,
|
|
step: o.stepname,
|
|
estado: o.alfa_estadodelanegociacion || null,
|
|
cliente: fv(o, "_customerid_value"),
|
|
campaign: fv(o, "_campaignid_value"),
|
|
score: o.alfa_puntuaciondelaoportunidad ?? null,
|
|
estrellas: o.alfa_niveldeoportunidadestrellas ?? null,
|
|
clasif: fv(o, "alfa_clasificaciondeoportunidad") || "Sin clasificar",
|
|
luz: fv(o, "alfa_luzamarilla") || "Sin registrar",
|
|
competidor: normComp(fv(o, "_alfa_competidorid_value")),
|
|
// Escala propia de ALFA+ (NO el forecastcategory estándar de Dynamics — ver CLAUDE.md):
|
|
// la etiqueta ya trae el % adelante ("20% Calificada" … "90% Firma de contrato"), de ahí se
|
|
// deriva el orden sin mantener un mapa aparte.
|
|
prev: fv(o, "msdyn_forecastcategory") || "Sin categoría",
|
|
prevPct: parseInt(fv(o, "msdyn_forecastcategory") || "", 10) || 0,
|
|
};
|
|
}
|
|
|
|
async function getFaseActual(oppIds, accessToken) {
|
|
const fase = {};
|
|
for (const batch of chunk(oppIds, 150)) {
|
|
if (!batch.length) continue;
|
|
const conditions = batch.map((id) => `<value>${id}</value>`).join("");
|
|
const fetchXml =
|
|
`<fetch><entity name="alfa_stageduration">` +
|
|
`<attribute name="alfa_subject"/><attribute name="alfa_started"/><attribute name="alfa_opportunity"/>` +
|
|
`<filter><condition attribute="statuscode" operator="eq" value="1"/>` +
|
|
`<condition attribute="alfa_opportunity" operator="in">${conditions}</condition></filter>` +
|
|
`</entity></fetch>`;
|
|
const data = await dv(`alfa_stagedurations?fetchXml=${encodeURIComponent(fetchXml)}`, accessToken);
|
|
for (const r of data.value || []) {
|
|
const oid = r["_alfa_opportunity_value"] || r.alfa_opportunity;
|
|
const started = r.alfa_started;
|
|
const subj = (r.alfa_subject || "").replace("Fase: ", "");
|
|
if (!fase[oid] || (started && started > fase[oid].started)) {
|
|
fase[oid] = { fase: subj, started };
|
|
}
|
|
}
|
|
}
|
|
return fase;
|
|
}
|
|
|
|
// Historial completo de fases COMPLETADAS por oportunidad (a diferencia de getFaseActual(), que
|
|
// solo trae la fase en curso) — para Velocidad de movimiento (pipeVelFor(), derive.js). statuscode
|
|
// eq 100000000 = "Completado" en este tenant (confirmado en herramientas/build_pipevel.js del
|
|
// sitio HTML) — excluye la fase activa, aún sin cerrar, de cada oportunidad.
|
|
export async function getStageDurations(oppIds, accessToken) {
|
|
const out = [];
|
|
for (const batch of chunk(oppIds, 150)) {
|
|
if (!batch.length) continue;
|
|
const conditions = batch.map((id) => `<value>${id}</value>`).join("");
|
|
const fetchXml =
|
|
`<fetch><entity name="alfa_stageduration">` +
|
|
`<attribute name="alfa_subject"/><attribute name="alfa_duration"/><attribute name="alfa_opportunity"/>` +
|
|
`<filter><condition attribute="statuscode" operator="eq" value="100000000"/>` +
|
|
`<condition attribute="alfa_opportunity" operator="in">${conditions}</condition></filter>` +
|
|
`</entity></fetch>`;
|
|
const data = await dv(`alfa_stagedurations?fetchXml=${encodeURIComponent(fetchXml)}`, accessToken);
|
|
for (const r of data.value || []) {
|
|
const oppId = r["_alfa_opportunity_value"] || r.alfa_opportunity;
|
|
if (!oppId || r.alfa_duration == null) continue;
|
|
const subj = (r.alfa_subject || "").replace("Fase: ", "");
|
|
if (!subj || subj === "Ganada") continue; // no es un tramo de velocidad
|
|
out.push({ oppId, fase: subj === "Proponer" ? "Negociación" : subj, dur: r.alfa_duration });
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Motivo/competidor de cierre — viven en opportunityclose, no en opportunity (ver
|
|
// contexto_tabla_cierre_oportunidad.md). alfa_motivodecierre es el campo principal (Alfa);
|
|
// opportunitystatuscode es el respaldo estándar — en la práctica muchos cierres recientes
|
|
// solo llenan el estándar. Nos quedamos con el cierre más reciente por oportunidad.
|
|
export async function getMotivosCierre(oppIds, accessToken) {
|
|
const motivos = {};
|
|
for (const batch of chunk(oppIds, 150)) {
|
|
if (!batch.length) continue;
|
|
const conditions = batch.map((id) => `<value>${id}</value>`).join("");
|
|
const fetchXml =
|
|
`<fetch><entity name="opportunityclose">` +
|
|
`<attribute name="opportunityid"/><attribute name="alfa_motivodecierre"/>` +
|
|
`<attribute name="opportunitystatuscode"/><attribute name="alfa_competitor"/>` +
|
|
`<attribute name="createdon"/>` +
|
|
`<filter><condition attribute="opportunityid" operator="in">${conditions}</condition></filter>` +
|
|
`</entity></fetch>`;
|
|
const data = await dv(`opportunitycloses?fetchXml=${encodeURIComponent(fetchXml)}`, accessToken);
|
|
for (const r of data.value || []) {
|
|
const oid = r["_opportunityid_value"];
|
|
const created = r.createdon;
|
|
if (motivos[oid] && motivos[oid].createdon >= created) continue;
|
|
motivos[oid] = {
|
|
createdon: created,
|
|
motivo: fv(r, "alfa_motivodecierre") || fv(r, "opportunitystatuscode") || null,
|
|
competidor: fv(r, "_alfa_competitor_value"),
|
|
};
|
|
}
|
|
}
|
|
return motivos;
|
|
}
|
|
|
|
// Resuelve una lista de emails a systemuserids (en paralelo) y arma la cláusula OR
|
|
// `(_ownerid_value eq id1 or _ownerid_value eq id2 ...)` — multi-propietario, ver CLAUDE.md/authz.js.
|
|
async function resolveOwnerIds(emails, accessToken) {
|
|
const ids = await Promise.all(emails.map((e) => resolveOwnerId(e, accessToken)));
|
|
return ids.filter(Boolean);
|
|
}
|
|
function ownerOrClause(ids) {
|
|
return `(${ids.map((id) => `_ownerid_value eq ${id}`).join(" or ")})`;
|
|
}
|
|
|
|
// scope: { emails, locked } de ownerFilter(). emails=[] (admin, "todos") no filtra por propietario.
|
|
// typeFilter: PIPE_TYPE_FILTER (ventas, default) o REN_TYPE_FILTER (renovaciones).
|
|
async function getPipelineOfType(accessToken, scope, typeFilter) {
|
|
let filter = `statecode eq 0 and estimatedclosedate ne null and msdyn_forecastcategory ne 100000001 and ${typeFilter}`;
|
|
if (scope.emails?.length) {
|
|
const ownerIds = await resolveOwnerIds(scope.emails, accessToken);
|
|
if (!ownerIds.length) return [];
|
|
filter += ` and ${ownerOrClause(ownerIds)}`;
|
|
}
|
|
const data = await dv(
|
|
`opportunities?$select=${OPP_SELECT}&$filter=${encodeURIComponent(filter)}&$top=1000`,
|
|
accessToken
|
|
);
|
|
const rows = (data.value || []).map(mapOpportunityRow);
|
|
const faseMap = await getFaseActual(rows.map((r) => r.id), accessToken);
|
|
const today = new Date();
|
|
return rows.map((r) => derivePipelineRow(r, faseMap[r.id], today));
|
|
}
|
|
|
|
export async function getPipeline(accessToken, scope) {
|
|
return getPipelineOfType(accessToken, scope, PIPE_TYPE_FILTER);
|
|
}
|
|
|
|
export async function getRenovPipeline(accessToken, scope) {
|
|
return getPipelineOfType(accessToken, scope, REN_TYPE_FILTER);
|
|
}
|
|
|
|
// Resuelve una sola vez los systemuserids del scope (o [] si no aplica) — para reusar en varias
|
|
// llamadas a getClosed sin repetir la consulta a systemusers cada vez (ej. Tendencia, 6 meses).
|
|
export async function resolveScopeOwnerIds(scope, accessToken) {
|
|
if (!scope.emails?.length) return { none: true, ownerIds: [] };
|
|
const ownerIds = await resolveOwnerIds(scope.emails, accessToken);
|
|
return { none: false, ownerIds };
|
|
}
|
|
|
|
// statecode: 1 = ganadas, 2 = perdidas. month: "YYYY-MM", filtra por el mes de cierre real.
|
|
// resolvedOwnerIds: opcional, ya resuelto vía resolveScopeOwnerIds — evita resolver los emails en
|
|
// cada llamada. typeFilter: opcional — sin él, trae cualquier tipo (Ventas ganadas/perdidas ya
|
|
// filtran por owner de rol 'ventas' en la página; Renovaciones pasa REN_TYPE_FILTER explícito).
|
|
export async function getClosed(accessToken, scope, statecode, month, resolvedOwnerIds, typeFilter) {
|
|
const monthStart = `${month}-01`;
|
|
const [y, m] = month.split("-").map(Number);
|
|
const nextMonth = new Date(y, m, 1).toISOString().slice(0, 10);
|
|
|
|
let filter =
|
|
`statecode eq ${statecode} and actualclosedate ge ${monthStart} and actualclosedate lt ${nextMonth}`;
|
|
if (typeFilter) filter += ` and ${typeFilter}`;
|
|
if (scope.emails?.length) {
|
|
const ownerIds = resolvedOwnerIds !== undefined ? resolvedOwnerIds : await resolveOwnerIds(scope.emails, accessToken);
|
|
if (!ownerIds.length) return [];
|
|
filter += ` and ${ownerOrClause(ownerIds)}`;
|
|
}
|
|
const data = await dv(
|
|
`opportunities?$select=${OPP_SELECT}&$filter=${encodeURIComponent(filter)}&$top=1000`,
|
|
accessToken
|
|
);
|
|
return (data.value || []).map(mapOpportunityRow);
|
|
}
|
|
|
|
export async function getRenovClosed(accessToken, scope, statecode, month, resolvedOwnerIds) {
|
|
return getClosed(accessToken, scope, statecode, month, resolvedOwnerIds, REN_TYPE_FILTER);
|
|
}
|
|
|
|
// Ventana de historia para Actividades: statecode eq 0 (abierta, sin tope — es un plan de trabajo
|
|
// vivo) trae todo lo pendiente; scheduledend ge <cutoff> acota lo cerrado/cancelado a los últimos
|
|
// 90 días para no traer años de historial en cada carga (mismo patrón que build_actividades.js del
|
|
// sitio HTML, que usa un corte de fecha fijo en vez de "siempre todo").
|
|
const ACTIVIDADES_DIAS_HISTORIA = 90;
|
|
|
|
const ACTIVIDAD_ENTIDADES = [
|
|
{ entity: "tasks", tipo: "Tarea", navProp: "regardingobjectid_opportunity_task", propioField: "prioritycode", propioLabel: "Prioridad" },
|
|
{ entity: "appointments", tipo: "Cita", navProp: "regardingobjectid_opportunity_appointment", propioField: "location", propioLabel: "Ubicación" },
|
|
{ entity: "phonecalls", tipo: "Llamada", navProp: "regardingobjectid_opportunity_phonecall", propioField: "directioncode", propioLabel: "Dirección" },
|
|
];
|
|
|
|
function estadoBase(statecode) {
|
|
if (statecode === 1) return "completada";
|
|
if (statecode === 2) return "cancelada";
|
|
return "abierta"; // 0=Abierto, 3=Programado (Cita) — ambas "no cerradas" a efectos de negocio
|
|
}
|
|
|
|
function mapActividadRow(r, tipo, navProp, propioField, propioLabel) {
|
|
const tipoRef = lookupType(r, "_regardingobjectid_value");
|
|
const nombreRef = fv(r, "_regardingobjectid_value");
|
|
const objetivo = fv(r, "_alfa_objetivodeactividad_value");
|
|
const opp = r[navProp];
|
|
const propioValor = propioField === "location" ? r.location || null : fv(r, propioField);
|
|
return {
|
|
id: r.activityid,
|
|
tipo,
|
|
owner: fv(r, "_ownerid_value"),
|
|
asunto: r.subject || "(sin asunto)",
|
|
scheduledstart: r.scheduledstart || null,
|
|
scheduledend: r.scheduledend || null,
|
|
scheduledstartFmt: fv(r, "scheduledstart"),
|
|
scheduledendFmt: fv(r, "scheduledend"),
|
|
estado: estadoBase(r.statecode),
|
|
objetivo,
|
|
etapa: objetivo ? OBJETIVO_A_ETAPA[objetivo] || null : null,
|
|
referente: tipoRef && nombreRef ? { tipo: tipoRef, nombre: nombreRef, id: r._regardingobjectid_value } : null,
|
|
campoPropio: { label: propioLabel, valor: propioValor },
|
|
ingresoEstimado: opp && typeof opp.estimatedvalue === "number" ? opp.estimatedvalue : null,
|
|
tipoOportunidad: opp ? fv(opp, "alfa_typeopportunity") : null,
|
|
};
|
|
}
|
|
|
|
// scope: { email, locked }. email null (admin, "todos") trae los ejecutivos de venta curados —
|
|
// mismo alcance que el resto del informe (EJECUTIVOS_VENTA), resuelto en vivo contra systemusers
|
|
// en vez de una tabla fija de GUID (que es lo que hacía el ETL estático y quedaba desactualizada).
|
|
const COHORTE_SELECT = [
|
|
"opportunityid", "name", "createdon", "statecode", "actualclosedate", "estimatedclosedate",
|
|
"alfa_typeopportunity", "alfa_tipodeventa", "_ownerid_value", "_customerid_value",
|
|
"_alfa_lineadenegocioid_value", "_campaignid_value", "estimatedvalue", "actualvalue",
|
|
].join(",");
|
|
|
|
function mapCohorteRow(o) {
|
|
const tipo = fv(o, "alfa_typeopportunity");
|
|
const creada = o.createdon ? o.createdon.slice(0, 10) : null;
|
|
const estado = o.statecode === 1 ? "Ganada" : o.statecode === 2 ? "Perdida" : "Abierta";
|
|
const cierre = o.actualclosedate ? o.actualclosedate.slice(0, 10) : null;
|
|
const hoy = new Date().toISOString().slice(0, 10);
|
|
const diasEntre = (a, b) => (a && b ? Math.round((new Date(b) - new Date(a)) / 86400000) : null);
|
|
return {
|
|
id: o.opportunityid,
|
|
name: o.name,
|
|
owner: fv(o, "_ownerid_value"),
|
|
cliente: fv(o, "_customerid_value"),
|
|
creada,
|
|
mesCohorte: creada ? creada.slice(0, 7) : null,
|
|
estado,
|
|
cierre,
|
|
tipo,
|
|
segmento: segmentoDe(tipo),
|
|
origen: fv(o, "alfa_tipodeventa"),
|
|
linea: fv(o, "_alfa_lineadenegocioid_value"),
|
|
campaign: fv(o, "_campaignid_value"),
|
|
est: o.estimatedvalue || 0,
|
|
val: o.actualvalue || 0,
|
|
diasACierre: estado !== "Abierta" ? diasEntre(creada, cierre) : null,
|
|
diasAbierta: estado === "Abierta" ? diasEntre(creada, hoy) : null,
|
|
};
|
|
}
|
|
|
|
// scope: { email, locked }. mesesAtras: ventana de creación — el sitio HTML deja elegir el rango;
|
|
// acá se fija a 6 meses para acotar el volumen de la consulta en vivo (createdon no tiene índice
|
|
// de "top N recientes" propio, así que sin tope esto podría traer años de historial).
|
|
export async function getCohorte(accessToken, scope, mesesAtras = 6) {
|
|
const desde = new Date();
|
|
desde.setMonth(desde.getMonth() - mesesAtras);
|
|
desde.setDate(1);
|
|
const filterDesde = desde.toISOString().slice(0, 10);
|
|
|
|
let filter = `createdon ge ${filterDesde}`;
|
|
if (scope.emails?.length) {
|
|
const ownerIds = await resolveOwnerIds(scope.emails, accessToken);
|
|
if (!ownerIds.length) return [];
|
|
filter += ` and ${ownerOrClause(ownerIds)}`;
|
|
}
|
|
const data = await dv(
|
|
`opportunities?$select=${COHORTE_SELECT}&$filter=${encodeURIComponent(filter)}&$top=5000`,
|
|
accessToken
|
|
);
|
|
return (data.value || []).map(mapCohorteRow);
|
|
}
|
|
|
|
// roster: lista de nombres a incluir cuando no hay un solo propietario en `scope` (default
|
|
// EJECUTIVOS_VENTA) — Renovaciones pasa EJECUTIVOS_RENOV (Ventas + SAC, ver CLAUDE.md) para no
|
|
// perderse las actividades de SAC en el cruce "¿Ya se agendó algo?".
|
|
export async function getActividades(accessToken, scope, roster = EJECUTIVOS_VENTA) {
|
|
let ownerIds;
|
|
if (scope.emails?.length) {
|
|
ownerIds = await resolveOwnerIds(scope.emails, accessToken);
|
|
} else {
|
|
const users = await getSystemUsers(accessToken);
|
|
ownerIds = users.filter((u) => roster.includes(u.name)).map((u) => u.id);
|
|
}
|
|
if (!ownerIds.length) return [];
|
|
|
|
const cutoff = new Date(Date.now() - ACTIVIDADES_DIAS_HISTORIA * 86400000).toISOString().slice(0, 10);
|
|
const ownerFilterStr = `(${ownerIds.map((id) => `_ownerid_value eq ${id}`).join(" or ")})`;
|
|
const filter = `(statecode eq 0 or scheduledend ge ${cutoff}) and ${ownerFilterStr}`;
|
|
|
|
const results = await Promise.all(
|
|
ACTIVIDAD_ENTIDADES.map(async ({ entity, tipo, navProp, propioField, propioLabel }) => {
|
|
// actualend/statuscode salieron del $select: se traían pero nada en la UI los lee — menos
|
|
// columnas por fila, Dataverse arma la respuesta más rápido (3 consultas en paralelo con
|
|
// $expand, la página más pesada de la app).
|
|
const select = [
|
|
"activityid", "subject", "scheduledstart", "scheduledend",
|
|
"statecode", "_ownerid_value", "_regardingobjectid_value",
|
|
"_alfa_objetivodeactividad_value", propioField,
|
|
];
|
|
const query =
|
|
`${entity}?$select=${select.join(",")}` +
|
|
`&$expand=${navProp}($select=estimatedvalue,alfa_typeopportunity)` +
|
|
`&$filter=${encodeURIComponent(filter)}&$top=5000`;
|
|
const data = await dv(query, accessToken);
|
|
return (data.value || []).map((r) => mapActividadRow(r, tipo, navProp, propioField, propioLabel));
|
|
})
|
|
);
|
|
return results.flat();
|
|
}
|