informe-comercial-alfa/app/actividades/gestionActions.js

349 lines
20 KiB
JavaScript
Raw Permalink Normal View History

"use server";
import { revalidatePath } from "next/cache";
import { auth } from "../lib/auth";
import { esAsistente } from "../lib/authz";
import { resolveOwnerId } from "../lib/queries";
import { hoyManagua, esHabil } from "../lib/plan";
import { TIPOS_AGENDADOR, OBJETIVOS_LIBRES, horaAMin, localDeIso, fechaMaxima, validar, resumenExistentes } from "../lib/agendador";
import { objetivosPorNombre, actividadesFrescas, oportunidadesFrescas, crearActividad, cancelarActividad as cancelarAgendada } from "../lib/agendadorServer";
import {
leerActividad, problemaPara, fotoDe, completarActividad, cancelarActividad, reprogramarActividad, deshacerAccion,
leerParticipacionOpp, sumarParticipacionOpp, notaLegible, editarActividad, deshacerEdicion,
} from "../lib/actividadesServer";
import { registrarAccion, getAccion, marcarAccionDeshecha } from "../lib/actividadAcciones";
import { CODIGOS, nombresDe } from "../lib/participantes";
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
const ACCIONES = ["completar", "reprogramar", "cancelar"];
const MAX_NOTA = 1500;
// Interruptor de emergencia: con ACTIVIDADES_ACCIONES=off en el entorno, la app solo muestra las
// actividades y no escribe nada en Dynamics (sin necesidad de publicar de nuevo).
const apagado = () => String(process.env.ACTIVIDADES_ACCIONES || "").toLowerCase() === "off";
// Interruptor aparte para la participación que se suma a la oportunidad (afecta la puntuación): con
// PARTICIPANTES_OPP=off la actividad se completa igual, pero no se toca la oportunidad.
const oppApagado = () => String(process.env.PARTICIPANTES_OPP || "").toLowerCase() === "off";
// La Agenda es la página raíz («/»), por eso va en la lista.
const refrescar = () => {
["/", "/actividades", "/plan", "/prevision", "/agendador", "/tuberia", "/participacion", "/m/hoy", "/m/semana", "/m/calendario", "/m/tuberia"].forEach((p) => revalidatePath(p));
};
const MENSAJES = {
CERRADA: "Esta actividad ya está cerrada (completada o cancelada). Recarga la pantalla.",
CON_INVITADOS: "Esta cita tiene invitados. Para no enviarles avisos por error, reprográmala o cancélala directamente en Dynamics.",
};
// Traduce los errores de Dynamics a algo que el ejecutivo pueda entender y accionar.
function errorDe(e, contexto = {}) {
const m = String(e?.message || e);
console.error("[actividades]", JSON.stringify({ ...contexto, error: m.slice(0, 400) }));
if (m === "TOKEN_EXPIRED") return "Tu sesión expiró. Vuelve a iniciar sesión y reintenta (lo que escribiste en la nota se conserva en esta ventana).";
if (m.includes("DATAVERSE_403")) return "Dynamics no te permite modificar esta actividad. Si es de otro ejecutivo, pídele que la gestione o hazlo en Dynamics.";
if (m.includes("DATAVERSE_404")) return "No encontré la actividad en Dynamics (¿la eliminaron?). Recarga la pantalla.";
if (m.includes("DATAVERSE_412")) return "Alguien cambió esta actividad mientras la tenías abierta. Cierra esta ventana, ábrela de nuevo y reintenta.";
if (m.includes("DATAVERSE_429")) return "Dynamics está ocupado. Espera unos segundos y reintenta.";
const codigo = m.match(/DATAVERSE_(\d+)/)?.[1];
return `No se pudo completar la operación en Dynamics${codigo ? ` (código ${codigo})` : ""}. Intenta de nuevo; si persiste, avisa a Marco.`;
}
// ¿Puede esta sesión tocar una actividad de `ownerId`? El propio ejecutivo; el administrador y la asistente
// de ventas pueden hacerlo a nombre de otros (Dynamics igual aplica los permisos de quien actúa).
async function puedeTocar(session, ownerId) {
const mio = await resolveOwnerId(session.email, session.accessToken);
const esMia = !!mio && mio === ownerId;
if (session.isAdmin || esAsistente(session.email)) return { ok: true, enNombreDeOtro: !esMia };
return esMia ? { ok: true, enNombreDeOtro: false } : { ok: false };
}
// El refresco de las pantallas se hace AL CERRAR la ventana, no al ejecutar: si se refrescara antes, la
// actividad (ya completada) desaparecería de la lista y se llevaría la ventana con el botón «Deshacer».
export async function refrescarPantallasAction() {
const session = await auth();
if (!session?.email) return { ok: false };
refrescar();
return { ok: true };
}
const datosPublicos = (act, { hoy, puede }) => ({
id: act.id,
tipo: act.tipo,
etag: act.etag,
asunto: act.asunto,
estado: act.estado,
scheduledstart: act.scheduledstart,
scheduledend: act.scheduledend,
owner: act.owner,
referente: act.referente,
invitados: act.invitados,
tieneNota: !!(act.tipo === "Cita" ? act.resultadoVisita : act.description),
hoy,
enNombreDeOtro: puede.enNombreDeOtro,
objetivo: act.objetivo,
nota: notaLegible(act),
lugar: act.lugar || null,
duracion: act.scheduledstart && act.scheduledend ? Math.round((new Date(act.scheduledend) - new Date(act.scheduledstart)) / 60000) : null,
});
// Abre una actividad: la vuelve a leer en Dynamics (datos de este momento) y dice qué se puede hacer.
export async function abrirActividadAction({ tipo, id }) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (!TIPOS_AGENDADOR.includes(tipo) || !UUID.test(String(id || ""))) return { ok: false, error: "Actividad no válida." };
try {
const act = await leerActividad(session.accessToken, tipo, id);
const puede = await puedeTocar(session, act.ownerId);
if (!puede.ok) return { ok: false, error: "Solo puedes gestionar tus propias actividades." };
const pub = datosPublicos(act, { hoy: hoyManagua(), puede });
// Lo que ya está registrado en la oportunidad (para mostrarlo y no pedirlo dos veces).
let opp = null;
if (act.oppId) {
try {
const o = await leerParticipacionOpp(session.accessToken, act.oppId);
opp = { gv: o.gv, participantes: o.participantes };
} catch { /* sin dato: el modal funciona igual */ }
}
// Lo ya agendado HOY por el dueño de la actividad: con eso la ventana quita las horas que chocarían al
// programar un seguimiento «hoy, más tarde». Si falla, la ventana solo quita las horas pasadas y el servidor valida.
let hoyAgenda = null;
if (act.oppId) {
try {
const acts = await actividadesFrescas(session.accessToken, act.ownerId, pub.hoy, pub.hoy);
const r = resumenExistentes(acts);
hoyAgenda = { bloques: r.bloques[pub.hoy] || [], cuenta: r.existentes[pub.hoy] || { Llamada: 0, Cita: 0, Tarea: 0 } };
} catch { /* sin dato */ }
}
return { ok: true, apagado: apagado(), actividad: { ...pub, participantes: act.participantes, tieneOpp: !!act.oppId, opp, hoyAgenda } };
} catch (e) {
return { ok: false, error: errorDe(e, { paso: "abrir", tipo, id }) };
}
}
// Completar, reprogramar o cancelar. El navegador solo dice QUÉ quiere; permisos, estado, fechas y
// concurrencia se verifican AQUÍ con datos de este momento.
export async function ejecutarAccionAction({ tipo, id, accion, nota, dia, hora, participantes }) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (apagado()) return { ok: false, error: "La gestión de actividades está en pausa por mantenimiento. Intenta más tarde o hazlo en Dynamics." };
if (!TIPOS_AGENDADOR.includes(tipo) || !UUID.test(String(id || "")) || !ACCIONES.includes(accion)) return { ok: false, error: "Solicitud no válida." };
const texto = String(nota || "").slice(0, MAX_NOTA);
const hoy = hoyManagua();
if (accion === "reprogramar") {
if (!/^\d{4}-\d{2}-\d{2}$/.test(String(dia || "")) || dia < hoy || dia > fechaMaxima(hoy)) {
return { ok: false, error: "La nueva fecha debe estar entre hoy y los próximos 30 días." };
}
if (tipo !== "Tarea") {
const m = horaAMin(String(hora || ""));
if (m == null || m < 360 || m > 1200) return { ok: false, error: "Elige una hora entre 6:00 y 20:00." };
if (dia === hoy && m < localDeIso(new Date().toISOString()).min) return { ok: false, error: "Esa hora ya pasó." };
}
}
const ctx = { actor: session.email, tipo, id, accion };
try {
const token = session.accessToken;
const act = await leerActividad(token, tipo, id);
const puede = await puedeTocar(session, act.ownerId);
if (!puede.ok) return { ok: false, error: "Solo puedes gestionar tus propias actividades." };
const prob = problemaPara(act, accion);
if (prob) return { ok: false, error: MENSAJES[prob] };
const previo = fotoDe(act);
let nuevo;
let opp = null;
let avisoOpp = null;
if (accion === "completar") {
const roles = (Array.isArray(participantes) ? participantes : []).map(String).filter((c) => CODIGOS.includes(c));
nuevo = await completarActividad(token, act, texto, roles);
if ((act.tipo === "Cita" || act.tipo === "Llamada") && roles.length) nuevo.escribioParticipantes = true;
// La actividad ya quedó completada. Sumar la participación a la oportunidad es un segundo paso que
// puede fallar SIN deshacer el cierre: en ese caso solo se avisa.
if (roles.length && act.oppId && !oppApagado()) {
try {
opp = await sumarParticipacionOpp(token, act.oppId, roles);
if (opp.cambio) {
previo.opp = opp.previo;
nuevo.opp = opp.nuevo;
}
} catch (e) {
avisoOpp = "La actividad se completó, pero no pude actualizar la participación en la oportunidad. Puedes marcarla en Dynamics.";
console.error("[actividades]", JSON.stringify({ paso: "participacion_opp", actor: session.email, id, error: String(e?.message || e).slice(0, 300) }));
}
} else if (roles.length && !act.oppId) {
avisoOpp = "La actividad no está ligada a una oportunidad: la participación no se registró en ninguna.";
}
} else if (accion === "cancelar") nuevo = await cancelarActividad(token, act, texto);
else nuevo = await reprogramarActividad(token, act, dia, hora);
const accionId = registrarAccion({
actor: session.email, ownerId: act.ownerId, ownerName: act.owner, tipo, activityId: id, accion, resultado: "ok", previo, nuevo,
});
// Resumen para mostrar: qué cambió en la oportunidad.
const resumenOpp = opp?.cambio
? {
roles: nombresDe(opp.nuevo.participantes.filter((c) => !opp.previo.participantes.includes(c))),
marcoGV: opp.nuevo.gv && !opp.previo.gv,
}
: opp && !opp.cambio
? { yaEstaba: true }
: null;
return { ok: true, accionId, accion, enNombreDeOtro: puede.enNombreDeOtro, owner: act.owner, nuevo, opp: resumenOpp, avisoOpp };
} catch (e) {
try {
registrarAccion({ actor: session.email, tipo, activityId: id, accion, resultado: "error", error: e?.message });
} catch { /* la bitácora nunca debe ocultar el error real */ }
return { ok: false, error: errorDe(e, ctx) };
}
}
// «Deshacer» la última acción: reabre (vuelve al estado previo) o devuelve la fecha anterior.
export async function deshacerAccionAction(accionId) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (apagado()) return { ok: false, error: "La gestión de actividades está en pausa por mantenimiento." };
const reg = getAccion(Number(accionId));
if (!reg || reg.resultado !== "ok") return { ok: false, error: "No encontré esa acción." };
if (reg.deshecho_en) return { ok: false, error: "Esa acción ya se deshizo." };
try {
const puede = await puedeTocar(session, reg.owner_id);
if (!puede.ok) return { ok: false, error: "No tienes permiso para deshacer esta acción." };
const r = await deshacerAccion(session.accessToken, reg.tipo, reg.activity_id, reg.accion, reg.previo, reg.nuevo);
if (r === "CAMBIO") return { ok: false, error: "La actividad cambió después de tu acción; ya no se puede deshacer desde aquí." };
marcarAccionDeshecha(reg.id, session.email);
return { ok: true, sinNota: r === "ok_sin_nota" };
} catch (e) {
return { ok: false, error: errorDe(e, { paso: "deshacer", accionId }) };
}
}
// Programa la SIGUIENTE actividad de seguimiento justo después de completar otra (misma oportunidad, mismo
// propietario). Reutiliza las reglas del Agendador (horario, máximos por día, sin encimar) y se registra en la
// bitácora para poder deshacerla (cancela la nueva; nunca borra).
export async function crearSeguimientoAction({ tipo, id, nuevoTipo, objetivo, dia, hora }) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (apagado()) return { ok: false, error: "La gestión de actividades está en pausa por mantenimiento." };
if (!TIPOS_AGENDADOR.includes(tipo) || !TIPOS_AGENDADOR.includes(nuevoTipo) || !UUID.test(String(id || ""))) return { ok: false, error: "Solicitud no válida." };
if (!OBJETIVOS_LIBRES.includes(String(objetivo || ""))) return { ok: false, error: "Elige un objetivo." };
const hoy = hoyManagua();
if (!/^\d{4}-\d{2}-\d{2}$/.test(String(dia || "")) || dia < hoy || dia > fechaMaxima(hoy)) {
return { ok: false, error: "La fecha debe estar entre hoy y los próximos 30 días." };
}
// El seguimiento sigue el mismo horario del Agendador: de lunes a viernes (sábados y domingos no).
if (!esHabil(dia)) return { ok: false, error: "Elige un día hábil: el seguimiento no se agenda en sábado ni en domingo." };
try {
const token = session.accessToken;
const origen = await leerActividad(token, tipo, id);
const puede = await puedeTocar(session, origen.ownerId);
if (!puede.ok) return { ok: false, error: "Solo puedes gestionar tus propias actividades." };
if (!origen.oppId) return { ok: false, error: "La actividad no está ligada a una oportunidad; el seguimiento se agenda desde el Agendador o en Dynamics." };
const [opps, objetivos, acts] = await Promise.all([
oportunidadesFrescas(token, [origen.oppId]),
objetivosPorNombre(token),
actividadesFrescas(token, origen.ownerId, dia, dia),
]);
const opp = opps.get(origen.oppId);
if (!opp || !opp.abierta) return { ok: false, error: "La oportunidad ya no está abierta." };
const objetivoId = objetivos.get(objetivo);
if (!objetivoId) return { ok: false, error: "No encontré ese objetivo en Dynamics." };
const it = { key: origen.oppId, oppId: origen.oppId, nombre: opp.nombre, cliente: null, tipo: nuevoTipo, objetivo, dia, hora: nuevoTipo === "Tarea" ? "" : String(hora || "") };
const { existentes, bloques } = resumenExistentes(acts);
const ahoraMin = localDeIso(new Date().toISOString()).min;
// El seguimiento acepta los objetivos «libres» (incluye «Prospección», que el ejecutivo trae de la actividad original);
// el Agendador masivo sigue limitado a OBJETIVOS_AGENDADOR.
const v = validar({ items: [it], dias: [dia], existentes, bloques, hoy, ahoraMin, objetivos: OBJETIVOS_LIBRES });
if (!v.ok) return { ok: false, error: (v.porItem[it.key] || []).join(" ") };
const nuevoId = await crearActividad(token, it, opp, origen.ownerId, objetivoId, session.email);
const accionId = registrarAccion({
actor: session.email, ownerId: origen.ownerId, ownerName: origen.owner, tipo: nuevoTipo, activityId: nuevoId, accion: "seguimiento", resultado: "ok",
previo: { origenId: id, origenTipo: tipo }, nuevo: { dia, hora: it.hora, objetivo },
});
return { ok: true, accionId, tipo: nuevoTipo, dia, hora: it.hora };
} catch (e) {
try { registrarAccion({ actor: session.email, tipo: nuevoTipo, activityId: id, accion: "seguimiento", resultado: "error", error: e?.message }); } catch { /* ignorar */ }
return { ok: false, error: errorDe(e, { paso: "seguimiento", tipo, id }) };
}
}
export async function deshacerSeguimientoAction(accionId) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
const reg = getAccion(Number(accionId));
if (!reg || !["seguimiento", "creacion"].includes(reg.accion) || reg.resultado !== "ok") return { ok: false, error: "No encontré esa acción." };
if (reg.deshecho_en) return { ok: false, error: "Ese seguimiento ya se deshizo." };
try {
const puede = await puedeTocar(session, reg.owner_id);
if (!puede.ok) return { ok: false, error: "No tienes permiso para deshacer esta acción." };
await cancelarAgendada(session.accessToken, reg.tipo, reg.activity_id);
marcarAccionDeshecha(reg.id, session.email);
return { ok: true };
} catch (e) {
return { ok: false, error: errorDe(e, { paso: "deshacer_seguimiento", accionId }) };
}
}
const DURACIONES = { Llamada: [10, 15, 30, 45, 60], Cita: [30, 60, 90, 120] };
// Edita una actividad abierta sin completarla (objetivo, duración, nota previa, participantes de la visita). No toca
// asunto, descripción ni invitados. Cambiar la duración de una visita con invitados se hace en Dynamics (avisaría a los
// invitados). Se registra en la bitácora y se puede deshacer.
export async function editarActividadAction({ tipo, id, objetivo, duracion, nota, participantes }) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (apagado()) return { ok: false, error: "La gestión de actividades está en pausa por mantenimiento. Intenta más tarde o hazlo en Dynamics." };
if (!TIPOS_AGENDADOR.includes(tipo) || !UUID.test(String(id || ""))) return { ok: false, error: "Solicitud no válida." };
if (objetivo && !OBJETIVOS_LIBRES.includes(String(objetivo))) return { ok: false, error: "Objetivo no permitido." };
const dur = duracion ? Number(duracion) : null;
if (dur && !(DURACIONES[tipo] || []).includes(dur)) return { ok: false, error: "Duración no válida." };
const roles = Array.isArray(participantes) ? participantes.map(String).filter((c) => CODIGOS.includes(c)) : null;
const ctx = { actor: session.email, tipo, id, accion: "editar" };
try {
const token = session.accessToken;
const act = await leerActividad(token, tipo, id);
const puede = await puedeTocar(session, act.ownerId);
if (!puede.ok) return { ok: false, error: "Solo puedes gestionar tus propias actividades." };
if (act.estado !== "abierta") return { ok: false, error: MENSAJES.CERRADA };
if (dur && tipo === "Cita" && act.invitados > 0) {
const igual = act.scheduledstart && act.scheduledend && Math.round((new Date(act.scheduledend) - new Date(act.scheduledstart)) / 60000) === dur;
if (!igual) return { ok: false, error: "Esta visita tiene invitados: cambia su duración directamente en Dynamics para no enviarles avisos por error." };
}
let objetivoId = null;
if (objetivo) {
objetivoId = (await objetivosPorNombre(token)).get(objetivo) || null;
if (!objetivoId) return { ok: false, error: "No encontré ese objetivo en Dynamics." };
}
const r = await editarActividad(token, act, { objetivoId, duracionMin: dur, nota: String(nota || "").slice(0, MAX_NOTA), participantes: tipo === "Cita" || tipo === "Llamada" ? roles : null });
if (!r) return { ok: false, error: "No hay cambios que guardar." };
const accionId = registrarAccion({
actor: session.email, ownerId: act.ownerId, ownerName: act.owner, tipo, activityId: id, accion: "edicion", resultado: "ok", previo: r.previo, nuevo: r.nuevo,
});
return { ok: true, accionId, accion: "editar", enNombreDeOtro: puede.enNombreDeOtro, owner: act.owner };
} catch (e) {
try {
registrarAccion({ actor: session.email, tipo, activityId: id, accion: "edicion", resultado: "error", error: e?.message });
} catch { /* la bitácora nunca debe ocultar el error real */ }
return { ok: false, error: errorDe(e, ctx) };
}
}
export async function deshacerEdicionAction(accionId) {
const session = await auth();
if (!session?.email) return { ok: false, error: "Inicia sesión." };
if (apagado()) return { ok: false, error: "La gestión de actividades está en pausa por mantenimiento." };
const reg = getAccion(Number(accionId));
if (!reg || reg.accion !== "edicion" || reg.resultado !== "ok") return { ok: false, error: "No encontré esa acción." };
if (reg.deshecho_en) return { ok: false, error: "Esa edición ya se deshizo." };
try {
const puede = await puedeTocar(session, reg.owner_id);
if (!puede.ok) return { ok: false, error: "No tienes permiso para deshacer esta acción." };
const r = await deshacerEdicion(session.accessToken, reg.tipo, reg.activity_id, reg.previo || {}, reg.nuevo || {});
if (r === "CAMBIO") return { ok: false, error: "La actividad ya no está abierta; no se puede deshacer desde aquí." };
marcarAccionDeshecha(reg.id, session.email);
return { ok: true };
} catch (e) {
return { ok: false, error: errorDe(e, { paso: "deshacer_edicion", accionId }) };
}
}