349 lines
20 KiB
JavaScript
349 lines
20 KiB
JavaScript
|
|
"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 }) };
|
||
|
|
}
|
||
|
|
}
|