commit 1b8fb200c0fcdaea0cc19e53981c5f5aa932c2bc Author: MarcoMontenegro Date: Tue Nov 10 08:26:25 2026 -0600 Plan del Dia accionable (gestionar y agendar por fila), vista Equipo para el gerente (semana y mes), vencidas clicables en el calendario diff --git a/.claude/launch.json b/.claude/launch.json new file mode 100644 index 0000000..d830409 --- /dev/null +++ b/.claude/launch.json @@ -0,0 +1,11 @@ +{ + "version": "0.0.1", + "configurations": [ + { + "name": "informe-comercial-dev", + "runtimeExecutable": "npm", + "runtimeArgs": ["run", "dev"], + "port": 3000 + } + ] +} diff --git a/.claude/scheduled_tasks.lock b/.claude/scheduled_tasks.lock new file mode 100644 index 0000000..f379b6e --- /dev/null +++ b/.claude/scheduled_tasks.lock @@ -0,0 +1 @@ +{"sessionId":"e423c846-29e7-41ef-9e20-37bad045d6ba","pid":6112,"procStart":"134350917200947005","acquiredAt":1790621443967} \ No newline at end of file diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..70df0dd --- /dev/null +++ b/.dockerignore @@ -0,0 +1,10 @@ +node_modules +.next +.git +data +__nm_old +.nm_trash* +*.log +npm-debug.log* +.env +.env.local diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..28c3b14 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +node_modules +.next +data +__nm_old +*.log +.DS_Store +.env +.env.local diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..643577d --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,9 @@ + + +# This is NOT the Next.js you know + +This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` (resolved from this file's directory; in monorepos the `next` package may not be visible from the repo root) before writing any code. Heed deprecation notices. + +This block is written and re-added by `next dev` — verify at `node_modules/next/dist/server/lib/generate-agent-files.js`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean. + + diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..4d126c1 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,72 @@ +@AGENTS.md + +# Informe Comercial ALFA+ — app Next.js (Dataverse en vivo) + +Dashboard comercial de **ALFA+** (Alfanumeric Nicaragua), consulta Dynamics 365 en vivo por OAuth +de vendedor (`dynamic = "force-dynamic"`, sin caché) — reemplaza al sitio HTML estático que vive en +`Proyectos/Análisis e Informes/Analitica de CRM/App Informe/` (archivado, solo referencia; los comentarios del +código que citan `herramientas/…` o `App Informe/…` apuntan a ese material). Publicado en +`https://informe-comercial.apps.online.com.ni`. + +## ⚠️ Esta es la carpeta que corre en producción + +**`C:\dev\informe-comercial` es la única carpeta de trabajo y la fuente real de lo publicado.** Es un +repo git (rama `main`) sincronizado con Forgejo (`MarcoMontenegro/informe-comercial-alfa`). La copia +anterior en `C:\Mis Aplicaciones\informe-comercial` se eliminó el 2026-09-28. Historial del tema en +`Proyectos/Análisis e Informes/Analitica de CRM/sesion.md`, entrada "2026-09-28". + +## ⚠️ Publicar y git — leer antes de tocar el repo local (2026-10-27) + +- **`publish_changes` publica lo que hay en esta carpeta y sube su propio commit a Forgejo** (fuerza el push). El git local de esta carpeta queda **desfasado** (rama «adelante 1, atrás 1») y con cambios sin commit: es normal. **No hacer `git pull`, `git reset` ni `git checkout .` sin revisar**: perderías trabajo que ya está en producción. +- **Rutina después de cada publicación (acordada con Marco el 2026-11-06):** correr `git fetch origin` y luego `git reset origin/main` (sin `--hard`). Mueve solo el historial local al de Forgejo y **no toca ningún archivo**, así el git no queda «adelante/atrás». Antes, comprobar que la carpeta coincide con `origin/main` (ignorando fin de línea: `git archive origin/main` a una carpeta temporal y `diff -rq --strip-trailing-cr`). Solo `git reset` **sin** `--hard`; `git pull` y `git checkout .` siguen prohibidos sin revisar. +- Para saber si algo está publicado, no fiarse de `git status`: comparar los archivos con `origin/main` (`git fetch` y comparar hashes) o leer el commit desplegado en `get_logs`. El 2026-10-27 se comprobó así que los 104 archivos coinciden con el commit `0a51fac`. +- **Dos sesiones pueden trabajar en paralelo en esta misma carpeta** (el 2026-10-27: una en Previsión de Ventas, otra en Plan del Día / enlaces). Como comparten el árbol de trabajo, lo que publique una incluye lo de la otra: avisar antes de publicar y revisar `git status` para no subir trabajo a medias. +- **Enlaces para crear actividades en Dynamics** (`nuevaActividadUrl` en `app/lib/constants.js`): el tipo del «Referente a» va en `regardingobjectidtype=opportunity`. Con `regardingobjecttypecode` el formulario se ve bien pero **al guardar falla con 0x80040217**. Los correos de Power Automate usan el mismo enlace (corregidos el 2026-10-27). + +## Filtro de propietario persistente y Plan del Día (2026-10-26) + +Cómo quedaron hechos (archivos, reglas de clasificación, PDF Carta horizontal, decisiones) y cómo reutilizarlos: +`Proyectos/Análisis e Informes/Analitica de CRM/referencia-implementacion-plan-del-dia.md` — la especificación funcional +está en `requerimientos-plan-del-dia.md` de esa misma carpeta. Código: `app/plan/`, `app/lib/plan.js`, +`app/components/plan/`, `app/components/OwnerControl.js`. + +## Reglas de negocio — viven en el proyecto de análisis, no acá + +**No duplicar aquí** la definición de tipos de oportunidad, tuberías, forecast category, motivos de +cierre, ejecutivos de venta, ni las lecciones aprendidas de interpretación de datos. Esa es la +fuente de verdad y cambia con el negocio — leerla ahí: + +📘 `C:\Users\marco.montenegro\OneDrive - Alfanumeric\Claude\Proyectos\Análisis e Informes\Analitica de CRM\CLAUDE.md` + +De ahí en particular: +- Estructura de tuberías y tipos de oportunidad (`alfa_typeopportunity`) +- **Cumplimiento de meta — qué cuenta**: solo Venta - Cliente Nuevo, Up-Selling, Cross-Selling, + Plan de Cuenta (`TIPOS_META` en `app/lib/derive.js` es el espejo en código de esa lista) +- Ejecutivos de venta reales — Gabriela Sánchez y Ashley Bermúdez aparecen en los datos pero **no** + son ejecutivas de venta (`EJECUTIVOS_VENTA` en `app/lib/derive.js`) +- Forecast category con escala propia de ALFA+ (no la estándar de Dynamics) +- El mapa de motivos de cierre (`MOTIVO_MAP`) — Dynamics reetiquetó el optionset en sep-2026 +- Las advertencias de interpretación (WhatsApp no está en el CRM, promedio ≠ techo, etc.) + +Si una regla de negocio de código acá (`app/lib/derive.js`, `app/lib/queries.js`) no cuadra con lo +que dice ese `CLAUDE.md`, **ese archivo manda** — el código se ajusta a él, no al revés. + +## Entorno técnico (ALFA+, común a todos los proyectos) + +Ver también el `CLAUDE.md` raíz de ALFA+ (`Claude/CLAUDE.md`) para Dynamics +(`alfanumeric.crm.dynamics.com`), convenciones de trabajo (todo en español, no inventar números, +cambios acotados) y marca. + +## Gestionar actividades desde la app (2026-11-06) + +Ventana emergente para **completar, reprogramar, cancelar y deshacer** citas, llamadas y tareas sin ir a Dynamics. Diseño y revisión EGM: `Proyectos/Análisis e Informes/Analitica de CRM/egm/concepts_brief.md`. + +- **Código:** `app/components/actividades/GestionarActividad.js` (ventana; se abre desde la Agenda `/` y el Detalle de Plan de Actividades), `app/actividades/gestionActions.js` (acciones de servidor: abrir, ejecutar, deshacer, refrescar), `app/lib/actividadesServer.js` (Dynamics), `app/lib/actividadAcciones.js` (bitácora SQLite `actividad_accion`: actor, previo, nuevo). +- **Estados (statecode/statuscode), verificados con escritura real:** llamada completada 1/2, cancelada 2/3; cita 1/3 y 2/4; tarea 1/5 y 2/6 (con `percentcomplete` 100). Deshacer reabre al estado previo y devuelve nota, fecha real y avance. +- **Notas:** cita → `alfa_resultadodelavisita` (HTML, antepuesta). **Nunca** la descripción de la cita (es la invitación). Llamada y tarea → `description` (antepuesta). +- **Reglas:** `If-Match` (etag) al escribir datos; citas con invitados (máscara 5 o 6) no se reprograman ni cancelan desde la app; cada ejecutivo solo toca lo suyo, el administrador y la asistente pueden actuar a nombre de otros (la ventana lo avisa). +- **Refresco:** las pantallas se refrescan **al cerrar** la ventana (`refrescarPantallasAction`). Refrescar antes desmonta la ventana y se pierde «Deshacer». La Agenda es la ruta `/`. +- **Interruptores de emergencia (variables de entorno en Coolify, sin publicar de nuevo):** `ACTIVIDADES_ACCIONES=off` deja la app solo de lectura; `PARTICIPANTES_OPP=off` completa igual pero no toca la oportunidad. +- **Participantes:** al completar se marcan chips (`lib/participantes.js`: 100000000 Gerencia Comercial, …01 Preventa SmartWeb, …02 Preventa Seguridad, …03 Gerencia Operaciones, …04 Gerencia General). Se guardan en la cita (`alfa_participantes`, **antes** de cerrarla: una actividad cerrada es de solo lectura) y se **suman** a la oportunidad: Gerencia Comercial → Sí/No `alfa_participaciondegv` (alimenta la puntuación +5), los demás → `alfa_participantes`. Nunca quita ni baja un Sí a No. Si falla la oportunidad, la actividad queda completada y se avisa. Indicador en `/participacion`. +- **Pruebas:** oportunidad «Oportunidad de prueba 2 - stageid» (cuenta EMPRESA ABC, propietario Marco). Crear actividades de prueba es seguro; Marco entra al Agendador por URL (`?owner=marco.montenegro@alfa.com.ni`) pero no aparece en la lista del filtro (solo los 5 ejecutivos); para ver sus actividades en local se agregó temporalmente su nombre a `EJECUTIVOS_VENTA` en `derive.js` (quitarlo antes de publicar). +- **Lección:** al escribir regex con scripts de shell se pueden perder las `\` (el Agendador rechazó toda fecha por `/^d{4}-d{2}-d{2}$/`). Revisar el archivo después de escribirlo. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..8901c53 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,23 @@ +# syntax=docker/dockerfile:1.7 +# Debian slim (glibc), no Alpine: el build de Coolify no puede bajar el binario precompilado de +# better-sqlite3 (sin red saliente durante npm ci), así que igual compila con node-gyp — pero +# node:22-alpine actual trae Python 3.14, incompatible con la toolchain de compilación de gyp; +# Debian slim trae una versión de Python compatible (ver Proyectos/Analitica de CRM/sesion.md, +# 2026-09-28). +FROM node:22-slim +WORKDIR /app +RUN apt-get update && apt-get install -y --no-install-recommends python3 make g++ \ + && rm -rf /var/lib/apt/lists/* +COPY package.json package-lock.json ./ +# --mount=type=cache persiste el cache de npm/de build de Next entre deploys en el mismo host de +# Coolify (BuildKit) — evita re-descargar el registry completo y recompilar todo Next.js desde cero +# cuando solo cambió código de la app, no dependencias. npm ci en vez de npm install: no resuelve +# versiones (usa el lockfile tal cual), más rápido y determinístico para build reproducible. +RUN --mount=type=cache,target=/root/.npm npm ci +COPY . . +RUN --mount=type=cache,target=/app/.next/cache npm run build +EXPOSE 3000 +ENV NODE_ENV=production +ENV PORT=3000 +ENV HOSTNAME=0.0.0.0 +CMD ["npm", "start"] diff --git a/app/actividades/gestionActions.js b/app/actividades/gestionActions.js new file mode 100644 index 0000000..8f51548 --- /dev/null +++ b/app/actividades/gestionActions.js @@ -0,0 +1,268 @@ +"use server"; +import { revalidatePath } from "next/cache"; +import { auth } from "../lib/auth"; +import { esAsistente } from "../lib/authz"; +import { resolveOwnerId } from "../lib/queries"; +import { hoyManagua } 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, +} 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"].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, +}); + +// 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 */ } + } + return { ok: true, apagado: apagado(), actividad: { ...pub, participantes: act.participantes, tieneOpp: !!act.oppId, opp } }; + } 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" && 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." }; + } + 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; + const v = validar({ items: [it], dias: [dia], existentes, bloques, hoy, ahoraMin }); + 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 }) }; + } +} diff --git a/app/actividades/loading.js b/app/actividades/loading.js new file mode 100644 index 0000000..57f0fae --- /dev/null +++ b/app/actividades/loading.js @@ -0,0 +1,4 @@ +import PageLoading from "../components/PageLoading"; +export default function Loading() { + return ; +} diff --git a/app/actividades/page.js b/app/actividades/page.js new file mode 100644 index 0000000..c673e8f --- /dev/null +++ b/app/actividades/page.js @@ -0,0 +1,309 @@ +import { Suspense } from "react"; +import Link from "next/link"; +import { auth } from "../lib/auth"; +import { ownerFilter, puedeAgendarPara } from "../lib/authz"; +import { getActividades, getSystemUsers, getOportunidadesSemana } from "../lib/queries"; +import { AGENDADOR } from "../lib/agendador"; +import { EJECUTIVOS_VENTA } from "../lib/derive"; +import { + armarPlanPeriodo, sinActividadPeriodo, hoyManagua, addDays, semanaDe, diasDelRango, esHabil, diaDe, diaCorto, diaSemana, + PERIODOS_ACT, periodoActActivo, rangoPeriodoAct, +} from "../lib/plan"; +import { actEstadoFinal } from "../lib/derive"; +import LoginPrompt from "../components/LoginPrompt"; +import OwnerControl from "../components/OwnerControl"; +import ErrorNotice from "../components/ErrorNotice"; +import PeriodoControles from "../components/plan/PeriodoControles"; +import PlanSeccion from "../components/plan/PlanSeccion"; +import MrrSegmentos from "../components/plan/MrrSegmentos"; +import SinActividadPanel from "../components/plan/SinActividadPanel"; +import DetalleActividades from "../components/plan/DetalleActividades"; + +export const dynamic = "force-dynamic"; + +const fechaTxt = (iso) => iso.split("-").reverse().join("/"); +const fechaCorta = (iso) => iso.split("-").reverse().slice(0, 2).join("/"); +const pct = (hechas, total) => (total ? Math.round((hechas / total) * 1000) / 10 : null); +const pctTxt = (v) => (v == null ? "—" : `${v.toFixed(1)}%`); + +// Franja de cobertura: una ficha por día (semana) o por semana (mes). Los días hábiles sin ninguna +// actividad se resaltan como hueco; en la semana cada ficha abre el Plan del Día de ese día. +function Franja({ rango, plan, hoy, owner }) { + if (rango.tipo === "semana") { + const dias = diasDelRango(rango.desde, rango.hasta).filter((d) => esHabil(d) || plan.porDia[d]); + return ( +
+ {dias.map((d) => { + const x = plan.porDia[d]; + const hueco = esHabil(d) && !x; + const futuro = d > hoy; + const cls = `pa-dia${d === hoy ? " hoy" : ""}${futuro ? " futuro" : ""}${hueco ? " hueco" : ""}${esHabil(d) ? "" : " fin"}`; + const texto = hueco + ? "sin actividades" + : d <= hoy + ? `${x.hechas} de ${x.total} completadas` + : `${x.total} agendada${x.total === 1 ? "" : "s"}`; + const contenido = ( + <> + {diaSemana(d)} {Number(d.slice(8, 10))} + {texto} + + ); + const p = new URLSearchParams(); + if (owner) p.set("owner", owner); + if (d !== hoy) p.set("fecha", d); + const href = `/plan${p.toString() ? `?${p.toString()}` : ""}`; + return ( + + {contenido} + + ); + })} +
+ ); + } + // Mes: una ficha por semana comercial (lunes–domingo) que toca el mes. + const semanas = []; + for (let l = semanaDe(rango.desde).lunes; l <= rango.hasta; l = addDays(l, 7)) semanas.push(l); + return ( +
+ {semanas.map((l) => { + const dias = diasDelRango(l, addDays(l, 6)).filter((d) => d >= rango.desde && d <= rango.hasta); + const total = dias.reduce((t, d) => t + (plan.porDia[d]?.total || 0), 0); + const hechas = dias.reduce((t, d) => t + (plan.porDia[d]?.hechas || 0), 0); + const sinAct = dias.filter((d) => esHabil(d) && !plan.porDia[d]).length; + const fin = addDays(l, 6); + const futura = l > hoy; + const actual = l <= hoy && hoy <= fin; + return ( +
+ {fechaCorta(dias[0])} – {fechaCorta(dias[dias.length - 1])} + + {total === 0 ? "sin actividades" : futura ? `${total} agendadas` : `${hechas} de ${total} completadas`} + + {total > 0 && sinAct > 0 && {sinAct} día{sinAct === 1 ? "" : "s"} sin actividad} +
+ ); + })} +
+ ); +} + +function ResumenEquipoPeriodo({ nombres, plan, rango, hoy, etiqueta }) { + const semanasMes = []; + if (rango.tipo === "mes") for (let l = semanaDe(rango.desde).lunes; l <= rango.hasta; l = addDays(l, 7)) semanasMes.push(l); + const diasSemana = rango.tipo === "semana" ? diasDelRango(rango.desde, rango.hasta).filter(esHabil) : []; + const filas = nombres.map((n) => ({ n, o: plan.porOwner[n] || { total: 0, hechas: 0, debidas: 0, debidasHechas: 0, vencidas: 0, porDia: {} } })); + const sumaDia = (fn) => filas.reduce((t, f) => t + fn(f.o), 0); + const tot = { + total: sumaDia((o) => o.total), hechas: sumaDia((o) => o.hechas), debidas: sumaDia((o) => o.debidas), + debidasHechas: sumaDia((o) => o.debidasHechas), vencidas: sumaDia((o) => o.vencidas), + }; + const enSemana = (o, l) => diasDelRango(l, addDays(l, 6)).filter((d) => d >= rango.desde && d <= rango.hasta).reduce((t, d) => t + (o.porDia[d] || 0), 0); + return ( +
+

PLAN DE ACTIVIDADES — RESUMEN DEL EQUIPO

+
Período: {etiqueta}
+
+ + + + + + + + + {diasSemana.map((d) => )} + {semanasMes.map((l) => ( + + ))} + + + + {filas.map(({ n, o }) => ( + + + + + + + {diasSemana.map((d) => { + const c = o.porDia[d] || 0; + return ; + })} + {semanasMes.map((l) => { + const c = enSemana(o, l); + return ; + })} + + ))} + + + + + + + + + {diasSemana.map((d) => )} + {semanasMes.map((l) => )} + + +
EjecutivoAgendadasCompletadasCumpl. a la fechaVencidas{diaCorto(d)} + {fechaCorta(l < rango.desde ? rango.desde : l)} – {fechaCorta(addDays(l, 6) > rango.hasta ? rango.hasta : addDays(l, 6))} +
{n}{o.total}{o.hechas}{o.debidas ? `${pctTxt(pct(o.debidasHechas, o.debidas))} (${o.debidasHechas}/${o.debidas})` : "—"}{o.vencidas}{c || "○"}{c || "○"}
Total equipo{tot.total}{tot.hechas}{tot.debidas ? `${pctTxt(pct(tot.debidasHechas, tot.debidas))} (${tot.debidasHechas}/${tot.debidas})` : "—"}{tot.vencidas}{plan.porDia[d]?.total || 0}{filas.reduce((t, f) => t + enSemana(f.o, l), 0)}
+
+

+ Actividades agendadas en actividades comerciales (oportunidades, casos y cuentas). ○ = ninguna actividad ese día o semana. + Cumplimiento a la fecha = completadas ÷ actividades de los días anteriores a hoy ({fechaTxt(hoy)}); el avance de hoy está en el Plan del Día. +

+
+ ); +} + +export default async function PlanDeActividades({ searchParams }) { + const session = await auth(); + if (!session?.email) return ; + + const sp = await searchParams; + const scope = ownerFilter(session, sp.owner, { asistente: true }); + const hoy = hoyManagua(); + const periodo = periodoActActivo(sp.periodo); + const rango = rangoPeriodoAct(periodo, hoy); + const { desde, hasta } = rango; + const etiquetaPeriodo = PERIODOS_ACT.find((p) => p.k === periodo).lbl; + const etiqueta = `${etiquetaPeriodo} · ${fechaTxt(desde)} – ${fechaTxt(hasta)}`; + const esActualOFuturo = hasta >= hoy; + + // El agendador ahora es una página aparte (/agendador); aquí solo se ofrece el acceso. + const ownerAgenda = scope.emails.length === 1 ? scope.emails[0] : null; + const puedeAgendar = !!ownerAgenda && puedeAgendarPara(session, ownerAgenda); + + let raw, allUsers, oppsPeriodo; + try { + [raw, allUsers, oppsPeriodo] = await Promise.all([ + getActividades(session.accessToken, scope), + session.isAdmin || scope.asistente ? getSystemUsers(session.accessToken) : Promise.resolve([]), + // Solo las que cierran dentro del período (lista «por planificar»). + esActualOFuturo ? getOportunidadesSemana(session.accessToken, scope, desde, hasta) : Promise.resolve([]), + ]); + } catch (error) { + return ; + } + // La asistente solo ve a los ejecutivos del piloto (ver ownerFilter). + const owners = allUsers + .filter((u) => EJECUTIVOS_VENTA.includes(u.name)) + .filter((u) => !scope.asistente || AGENDADOR.piloto.includes(u.email)); + const plan = armarPlanPeriodo(raw, desde, hasta, hoy); + const r = plan.resumen; + + const sinActividad = esActualOFuturo + ? sinActividadPeriodo( + scope.emails?.length ? oppsPeriodo : oppsPeriodo.filter((o) => EJECUTIVOS_VENTA.includes(o.owner)), + raw, + desde, + hasta + ) + : []; + + // Detalle: todas las actividades no canceladas del período (cualquier referente). + const detalle = raw + .filter((a) => a.estado !== "cancelada") + .map((a) => ({ ...a, fecha: diaDe(a), estadoFinal: actEstadoFinal(a) })) + .filter((a) => a.fecha && a.fecha >= desde && a.fecha <= hasta); + + const quien = scope.locked + ? session.email + : scope.emails.length === 1 + ? owners.find((o) => o.email === scope.emails[0])?.name || scope.emails[0] + : scope.emails.length + ? `${scope.emails.length} ejecutivos` + : "Equipo"; + const verEquipo = !scope.locked && scope.emails.length !== 1 && owners.length > 0; + const nombresEquipo = owners.filter((o) => !scope.emails.length || scope.emails.includes(o.email)).map((o) => o.name); + const pctF = r.pctFecha; + + return ( +
+
+

Plan de Actividades

+
+ +
+
+ +
+ +
+
+ + {verEquipo && } + +
+

PLAN DE ACTIVIDADES

+
+ Período: {etiqueta} + Ejecutivo: {quien} +
+ +
+
+ {pctTxt(pctF)} + + {r.debidas ? `Cumplimiento a la fecha (${r.debidasHechas} de ${r.debidas} de los días anteriores a hoy)` : "Cumplimiento a la fecha: aún no hay días anteriores a hoy en el período"} + +
+
+ {r.agendadas} + Actividades agendadas en el período ({r.hechas} completadas) +
+
+ {r.vencidas} + Vencidas (siguen abiertas y su día ya pasó) +
+
+ {r.diasSinActividad} + Días hábiles sin actividad (de {r.diasHabiles}) +
+ +
+ + + + {plan.secciones.map((s) => ( + + ))} +
+ + {puedeAgendar && ( +
+
+

+ Agendador de actividades: ahora es un módulo aparte, con calendario de hasta 30 días, buscador y prioridad sugerida.{" "} + Abrir el agendador de {quien} → +

+
+
+ )} + + {esActualOFuturo && ( + + )} + + +
+ ); +} diff --git a/app/admin/metas/page.js b/app/admin/metas/page.js new file mode 100644 index 0000000..4886c82 --- /dev/null +++ b/app/admin/metas/page.js @@ -0,0 +1,100 @@ +import { revalidatePath } from "next/cache"; +import { auth } from "../../lib/auth"; +import { getSystemUsers } from "../../lib/queries"; +import { getMetas, getMetaGlobal, setMeta, setMetaGlobal } from "../../lib/metas"; +import { EJECUTIVOS_VENTA } from "../../lib/derive"; +import LoginPrompt from "../../components/LoginPrompt"; + +export const dynamic = "force-dynamic"; + +export default async function AdminMetasPage() { + const session = await auth(); + if (!session?.email) return ; + if (!session.isAdmin) { + return ( +
+

Metas

+

Esta página es solo para administradores.

+
+ ); + } + + const allUsers = await getSystemUsers(session.accessToken); + const metas = getMetas(); + const metaGlobal = getMetaGlobal(); + + const vendedoras = EJECUTIVOS_VENTA.map((nombre) => { + const u = allUsers.find((x) => x.name === nombre); + return { nombre, email: u?.email || null, monto: u ? metas[u.email] || 0 : 0 }; + }); + + async function guardarMeta(formData) { + "use server"; + const email = formData.get("email"); + const monto = Number(formData.get("monto")); + if (email && monto >= 0) setMeta(email, monto); + revalidatePath("/admin/metas"); + revalidatePath("/"); + revalidatePath("/ganadas"); + revalidatePath("/prevision"); + revalidatePath("/tendencia"); + } + + async function guardarGlobal(formData) { + "use server"; + const monto = Number(formData.get("metaGlobal")); + if (monto >= 0) setMetaGlobal(monto); + revalidatePath("/admin/metas"); + revalidatePath("/"); + revalidatePath("/ganadas"); + revalidatePath("/prevision"); + revalidatePath("/tendencia"); + } + + return ( +
+

Metas mensuales

+

+ Solo administradores.

+ +
+

Meta global del equipo

+
+ + +
+
+ +
+

Meta por ejecutiva

+ {vendedoras.map((v) => ( +
+ {v.nombre} + {v.email ? ( +
+ + + +
+ ) : ( + No encontrada en systemusers + )} +
+ ))} +
+
+ ); +} diff --git a/app/admin/uso/page.js b/app/admin/uso/page.js new file mode 100644 index 0000000..05add91 --- /dev/null +++ b/app/admin/uso/page.js @@ -0,0 +1,106 @@ +import Link from "next/link"; +import { auth } from "../../lib/auth"; +import { resumenUso, accionesPorPersona } from "../../lib/uso"; +import LoginPrompt from "../../components/LoginPrompt"; + +export const dynamic = "force-dynamic"; + +const PERIODOS = { 7: "Últimos 7 días", 14: "Últimos 14 días", 30: "Últimos 30 días" }; +const NOMBRE_RUTA = { + "/": "Calendario", "/plan": "Plan del Día", "/actividades": "Plan de Actividades", "/agendador": "Agendador", "/cuentas": "Cuentas (búsqueda)", + "/cuentas/ficha": "Cuentas (ficha)", "/prevision": "Previsión de Ventas", "/tuberia": "Tubería de Ventas", "/resumen": "Ventas Resumen", "/ganadas": "Oportunidades Ganadas", + "/perdemos": "Oportunidades Perdidas", "/tendencia": "Tendencia", "/renovaciones/prevision": "Previsión de Renovaciones", "/renovaciones/tuberia": "Tubería de Renovaciones", + "/renovaciones/logradas": "Renovaciones Logradas", "/renovaciones/perdidas": "Renovaciones Perdidas", "/nuevas": "Cohorte / Oportunidades nuevas", "/participacion": "Participación de Gerencia", + "/detalle": "Detalle", "/admin/metas": "Metas", "/admin/uso": "Uso de la app", "/equipo": "Equipo (gerente)", +}; +const nom = (r) => NOMBRE_RUTA[r] || r; +const fechaHora = (iso) => (iso ? new Date(new Date(iso).getTime() - 6 * 3600 * 1000).toISOString().replace("T", " ").slice(0, 16) : "—"); + +// Uso de la app por página y por persona (solo administradores). Mide VISITAS a páginas: no mide tiempo ni +// lo que se hace dentro de cada página. Se complementa con las acciones sobre actividades (bitácora). +export default async function UsoPage({ searchParams }) { + const session = await auth(); + if (!session?.email) return ; + if (!session.isAdmin) return

Uso de la app

Esta página es solo para administradores.

; + + const sp = await searchParams; + const dias = PERIODOS[sp.dias] ? Number(sp.dias) : 14; + const u = resumenUso(dias); + const acc = accionesPorPersona(dias); + const accPor = {}; + acc.forEach((a) => { (accPor[a.email] ||= {})[a.accion] = a.n; }); + const topPor = {}; + u.rutasPorPersona.forEach((r) => { (topPor[r.email] ||= []).length < 3 && topPor[r.email].push(`${nom(r.ruta)} (${r.n})`); }); + const rutasPorRol = {}; + u.porRol.forEach((r) => { (rutasPorRol[r.ruta] ||= {})[r.rol] = r.n; }); + const personasEsperadas = 7; + + return ( +
+

Uso de la app

+

+ Cada fila es una visita a una página (cambio de ruta); las recargas en menos de 20 segundos no cuentan. Mide qué páginas se abren y quién, no el tiempo ni lo que se hace + dentro. {u.total.n ? `Hay datos desde el ${u.total.desde}.` : "Todavía no hay datos: el registro empieza con la primera visita tras publicar."} +

+
+ {Object.entries(PERIODOS).map(([k, l]) => ( + {l} + ))} +
+ +
+
{u.porRuta.reduce((a, r) => a + r.visitas, 0)}Visitas en el periodo
+
{u.porPersona.length}Personas que entraron (de {personasEsperadas} usuarios previstos)
+
{u.porRuta.length}Páginas distintas abiertas
+
+ +
+

Por página

+ + + + {u.porRuta.map((r) => ( + + + + + ))} + {!u.porRuta.length && } + +
PáginaVisitasPersonasDías con usoEjecutivosAsistenteGerente
{nom(r.ruta)}{r.visitas}{r.personas}{r.dias_con_uso}{rutasPorRol[r.ruta]?.ejecutivo || 0}{rutasPorRol[r.ruta]?.asistente || 0}{rutasPorRol[r.ruta]?.gerente || 0}
Sin visitas registradas en este periodo.
+
+ +
+

Por persona

+ + + + {u.porPersona.map((p) => { + const a = accPor[p.email] || {}; + const txt = Object.entries(a).map(([k, n]) => `${n} ${k}`).join(", "); + return ( + + + + + ); + })} + {!u.porPersona.length && } + +
PersonaRolVisitasDías activosPáginasMás visitadasÚltima visitaActividades (en la app)
{p.email}{p.rol}{p.visitas}{p.dias_activos}{p.paginas}{(topPor[p.email] || []).join(", ")}{fechaHora(p.ultima)}{txt || "—"}
Sin visitas registradas en este periodo.
+
+ +
+

Primera página que abre cada persona cada día

+

Indica por dónde empieza el día: si no es «Plan del Día» o «Calendario», la entrada principal no está cumpliendo su función.

+ + + + {u.primeraDelDia.map((r) => )} + {!u.primeraDelDia.length && } + +
PáginaVeces que fue la primera del día
{nom(r.ruta)}{r.n}
Sin datos todavía.
+
+
+ ); +} diff --git a/app/agenda/page.js b/app/agenda/page.js new file mode 100644 index 0000000..b77b102 --- /dev/null +++ b/app/agenda/page.js @@ -0,0 +1,10 @@ +import { redirect } from "next/navigation"; + +// Agenda pasó a ser la página de inicio ("/") — Marco pidió que sea lo primero que ve el equipo al +// entrar, en vez de Ventas Resumen. Esta ruta se conserva como redirect por si algún bookmark viejo +// apunta acá. +export default async function AgendaRedirect({ searchParams }) { + const params = new URLSearchParams(await searchParams); + const qs = params.toString(); + redirect(qs ? `/?${qs}` : "/"); +} diff --git a/app/agendador/agendadorActions.js b/app/agendador/agendadorActions.js new file mode 100644 index 0000000..c1e12fd --- /dev/null +++ b/app/agendador/agendadorActions.js @@ -0,0 +1,163 @@ +"use server"; +import { revalidatePath } from "next/cache"; +import { auth } from "../lib/auth"; +import { puedeAgendarPara } from "../lib/authz"; +import { resolveOwnerId, getSystemUsers } from "../lib/queries"; +import { hoyManagua } from "../lib/plan"; +import { TIPOS_AGENDADOR, OBJETIVOS_AGENDADOR, validar, resumenExistentes, localDeIso, ventanaDe, fechaMaxima } from "../lib/agendador"; +import { + objetivosPorNombre, actividadesFrescas, oportunidadesFrescas, crearActividad, cancelarActividad, +} from "../lib/agendadorServer"; +import { guardarLote, getLote, marcarDeshecho } from "../lib/agendadorLotes"; + +const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; +const MAX_ITEMS = 40; + +const refrescar = () => { + revalidatePath("/agendador"); + revalidatePath("/actividades"); + revalidatePath("/plan"); + revalidatePath("/prevision"); +}; + +const errorDe = (e) => + e?.message === "TOKEN_EXPIRED" + ? "Tu sesión expiró. Vuelve a iniciar sesión y reintenta." + : "No se pudo completar la operación en Dynamics. Intenta de nuevo."; + +// Crea en Dynamics las actividades propuestas por el agendador. El navegador solo manda QUÉ quiere +// (oportunidad, tipo, objetivo, día, hora): todo lo demás se vuelve a verificar AQUÍ, con datos de este +// momento — permisos, semana, que la oportunidad esté abierta y sea del ejecutivo, topes por día, +// horarios, que no se encime ni duplique. Si algo no cuadra, NO se crea nada. +export async function crearLoteAction({ ownerEmail, fecha, items }) { + const session = await auth(); + if (!session?.email) return { ok: false, error: "Inicia sesión para agendar." }; + const owner = String(ownerEmail || "").toLowerCase(); + if (!puedeAgendarPara(session, owner)) return { ok: false, error: "No tienes permiso para agendar para este ejecutivo." }; + + const hoy = hoyManagua(); + // Días de agendado: 5 días hábiles desde la fecha elegida (hoy como mínimo, hoy + 30 días como máximo). + const fechaTxt = String(fecha || ""); + if (!/^\d{4}-\d{2}-\d{2}$/.test(fechaTxt) || fechaTxt > fechaMaxima(hoy)) { + return { ok: false, error: "La fecha de agendado debe estar entre hoy y los próximos 30 días." }; + } + const dias = ventanaDe(fechaTxt, hoy); + if (!dias.length) return { ok: false, error: "No hay días hábiles para agendar con esa fecha." }; + const rango = { desde: dias[0], hasta: dias[dias.length - 1] }; + const ahoraMin = localDeIso(new Date().toISOString()).min; + + if (!Array.isArray(items) || !items.length) return { ok: false, error: "No hay actividades para crear." }; + if (items.length > MAX_ITEMS) return { ok: false, error: `Máximo ${MAX_ITEMS} actividades por tanda.` }; + const limpios = items.map((i) => ({ + key: String(i?.oppId || ""), + oppId: String(i?.oppId || ""), + nombre: String(i?.nombre || "").slice(0, 200), + cliente: i?.cliente ? String(i.cliente).slice(0, 200) : null, + tipo: String(i?.tipo || ""), + objetivo: String(i?.objetivo || ""), + dia: String(i?.dia || ""), + hora: String(i?.hora || ""), + })); + if (limpios.some((i) => !UUID.test(i.oppId))) return { ok: false, error: "Hay una oportunidad no válida en la lista." }; + if (new Set(limpios.map((i) => i.oppId)).size !== limpios.length) return { ok: false, error: "Una oportunidad aparece más de una vez." }; + if (limpios.some((i) => !TIPOS_AGENDADOR.includes(i.tipo) || !OBJETIVOS_AGENDADOR.includes(i.objetivo))) { + return { ok: false, error: "Hay un tipo u objetivo no permitido." }; + } + + try { + const token = session.accessToken; + const ownerId = await resolveOwnerId(owner, token); + if (!ownerId) return { ok: false, error: "No encontré al ejecutivo en Dynamics." }; + const [opps, acts, objetivos, users] = await Promise.all([ + oportunidadesFrescas(token, limpios.map((i) => i.oppId)), + actividadesFrescas(token, ownerId, rango.desde, rango.hasta), + objetivosPorNombre(token), + getSystemUsers(token), + ]); + const ownerName = users.find((u) => u.id === ownerId)?.name || owner; + + // Cada oportunidad debe estar abierta y ser del ejecutivo; si ya tiene algo pendiente esta semana, se omite. + const pendientes = new Set(acts.filter((a) => a.estado === "abierta" && a.oppId).map((a) => a.oppId)); + const resultados = []; + const aCrear = []; + for (const it of limpios) { + const o = opps.get(it.oppId); + if (!o || !o.abierta) { resultados.push({ ...it, estado: "omitida", error: "La oportunidad no está abierta." }); continue; } + if (o.ownerId !== ownerId) { resultados.push({ ...it, estado: "omitida", error: "La oportunidad no es de este ejecutivo." }); continue; } + if (pendientes.has(it.oppId)) { resultados.push({ ...it, estado: "omitida", error: "Ya tiene una actividad pendiente en esos días." }); continue; } + if (!objetivos.get(it.objetivo)) { resultados.push({ ...it, estado: "omitida", error: "No encontré ese objetivo en Dynamics." }); continue; } + aCrear.push({ ...it, opp: o }); + } + if (!aCrear.length) return { ok: false, error: "Ninguna actividad se puede crear: " + resultados.map((r) => r.error).join(" ") }; + + const { existentes, bloques } = resumenExistentes(acts); + const v = validar({ items: aCrear, dias, existentes, bloques, hoy, ahoraMin }); + if (!v.ok) { + const detalle = aCrear.filter((i) => v.porItem[i.key]).map((i) => `${i.nombre || i.oppId}: ${v.porItem[i.key].join(" ")}`); + return { ok: false, error: "No se creó nada. Revisa: " + detalle.join(" · ") }; + } + + // Se crean de a 3 en paralelo; si una falla, las demás siguen y todo queda registrado. + const quien = session.email; + let i = 0; + const hechos = []; + const trabajador = async () => { + while (i < aCrear.length) { + const it = aCrear[i++]; + try { + const id = await crearActividad(token, it, it.opp, ownerId, objetivos.get(it.objetivo), quien); + hechos.push({ oppId: it.oppId, nombre: it.nombre, cliente: it.cliente, tipo: it.tipo, objetivo: it.objetivo, dia: it.dia, hora: it.hora, estado: "creada", activityId: id }); + } catch (e) { + if (e?.message === "TOKEN_EXPIRED") throw e; + hechos.push({ oppId: it.oppId, nombre: it.nombre, cliente: it.cliente, tipo: it.tipo, objetivo: it.objetivo, dia: it.dia, hora: it.hora, estado: "error", error: String(e?.message || e).slice(0, 200) }); + } + } + }; + await Promise.all([trabajador(), trabajador(), trabajador()]); + + const todos = [...hechos, ...resultados.map((r) => ({ oppId: r.oppId, nombre: r.nombre, tipo: r.tipo, estado: r.estado, error: r.error }))]; + const loteId = guardarLote({ creadoPor: quien, ownerId, ownerEmail: owner, ownerName, desde: rango.desde, hasta: rango.hasta, items: todos }); + refrescar(); + return { + ok: true, + loteId, + creadas: hechos.filter((h) => h.estado === "creada").length, + errores: hechos.filter((h) => h.estado === "error").length, + omitidas: resultados.length, + resultados: todos, + }; + } catch (e) { + return { ok: false, error: errorDe(e) }; + } +} + +// «Deshacer» una tanda: cancela (nunca borra) lo que siga abierto. Lo ya completado o cancelado no se toca. +export async function deshacerLoteAction(loteId) { + const session = await auth(); + if (!session?.email) return { ok: false, error: "Inicia sesión." }; + const lote = getLote(Number(loteId)); + if (!lote) return { ok: false, error: "No encontré esa tanda." }; + if (lote.deshecho_en) return { ok: false, error: "Esa tanda ya se deshizo." }; + if (!(puedeAgendarPara(session, lote.owner_email) || session.email === lote.creado_por)) { + return { ok: false, error: "No tienes permiso para deshacer esta tanda." }; + } + try { + const resumen = { canceladas: 0, yaCerradas: 0, errores: 0 }; + for (const it of lote.items) { + if (it.estado !== "creada" || !it.activityId) continue; + try { + const r = await cancelarActividad(session.accessToken, it.tipo, it.activityId); + if (r === "cancelada") resumen.canceladas++; + else resumen.yaCerradas++; + } catch (e) { + if (e?.message === "TOKEN_EXPIRED") throw e; + resumen.errores++; + } + } + marcarDeshecho(lote.id, session.email, resumen); + refrescar(); + return { ok: true, ...resumen }; + } catch (e) { + return { ok: false, error: errorDe(e) }; + } +} diff --git a/app/agendador/loading.js b/app/agendador/loading.js new file mode 100644 index 0000000..57f0fae --- /dev/null +++ b/app/agendador/loading.js @@ -0,0 +1,4 @@ +import PageLoading from "../components/PageLoading"; +export default function Loading() { + return ; +} diff --git a/app/agendador/page.js b/app/agendador/page.js new file mode 100644 index 0000000..32c2fbb --- /dev/null +++ b/app/agendador/page.js @@ -0,0 +1,121 @@ +import { Suspense } from "react"; +import Link from "next/link"; +import { auth } from "../lib/auth"; +import { ownerFilter, puedeAgendarPara } from "../lib/authz"; +import { getActividades, getSystemUsers, getOportunidadesSemana, resolveOwnerId } from "../lib/queries"; +import { AGENDADOR, resumenExistentes, localDeIso, fechaMaxima } from "../lib/agendador"; +import { getLotesRecientes } from "../lib/agendadorLotes"; +import { EJECUTIVOS_VENTA } from "../lib/derive"; +import { hoyManagua, diaDe, objetivoSugerido, COD_RENOVACION } from "../lib/plan"; +import LoginPrompt from "../components/LoginPrompt"; +import OwnerControl from "../components/OwnerControl"; +import ErrorNotice from "../components/ErrorNotice"; +import AgendadorPanel from "../components/plan/AgendadorPanel"; + +export const dynamic = "force-dynamic"; + +// Agendador de actividades — página INDEPENDIENTE del Plan de Actividades (2026-11-06). Para UN ejecutivo +// del piloto, trae TODAS sus oportunidades abiertas (sin esconder ninguna por su fecha de cierre) y deja +// agendar desde hoy hasta hoy + 30 días. Diseño: agendador-automatico-diseno.md. +export default async function Agendador({ searchParams }) { + const session = await auth(); + if (!session?.email) return ; + + const sp = await searchParams; + const scope = ownerFilter(session, sp.owner, { asistente: true }); + const hoy = hoyManagua(); + const ownerAgenda = scope.emails.length === 1 ? scope.emails[0] : null; + const puedeAgendar = !!ownerAgenda && puedeAgendarPara(session, ownerAgenda); + + let allUsers = []; + try { + allUsers = session.isAdmin || scope.asistente ? await getSystemUsers(session.accessToken) : []; + } catch (error) { + return ; + } + // La asistente solo ve a los ejecutivos del piloto (ver ownerFilter). + const owners = allUsers + .filter((u) => EJECUTIVOS_VENTA.includes(u.name)) + .filter((u) => !scope.asistente || AGENDADOR.piloto.includes(u.email)); + + const cabecera = ( +
+
+ + + +
+
+ ); + + if (!puedeAgendar) { + return ( +
+ {cabecera} +
+
+

+ {ownerAgenda + ? "El agendador de actividades no está habilitado para este usuario." + : "Elige arriba, en «Propietario», un solo ejecutivo para ver su agendador."} + {" "}Está habilitado para: {AGENDADOR.piloto.join(", ")}. +

+

← Ir al Plan de Actividades

+
+
+
+ ); + } + + let raw, opps, ownerId; + try { + [raw, opps, ownerId] = await Promise.all([ + getActividades(session.accessToken, scope), + // TODAS las abiertas del ejecutivo: el filtro «Cierre estimado» y el buscador las acotan en pantalla. + getOportunidadesSemana(session.accessToken, scope, null, null), + resolveOwnerId(ownerAgenda, session.accessToken), + ]); + } catch (error) { + return ; + } + let lotes = []; + try { + lotes = ownerId ? getLotesRecientes(ownerId) : []; + } catch { /* sin historial de tandas: el agendador funciona igual */ } + + // Actividades no canceladas por oportunidad, con su fecha (para saber cuáles ya tienen algo agendado + // en los días que se están planificando). Solo importan las de hoy en adelante. + const maxFecha = fechaMaxima(hoy); + const actPorOpp = {}; + for (const a of raw) { + const oppId = a.oportunidad?.id; + if (a.estado === "cancelada" || !oppId) continue; + const d = diaDe(a); + if (!d || d < hoy || d > maxFecha) continue; + (actPorOpp[oppId] ||= []).push(d); + } + const { existentes, bloques } = resumenExistentes(raw); + + const props = { + ownerEmail: ownerAgenda, + ownerName: allUsers.find((u) => u.email === ownerAgenda)?.name || opps[0]?.owner || ownerAgenda, + hoy, + ahoraMin: localDeIso(new Date().toISOString()).min, + candidatos: opps.map((o) => ({ + id: o.id, nombre: o.nombre, cliente: o.cliente, valor: o.valor, pct: parseInt(o.forecast || "", 10) || 0, + tipoCodigo: o.tipoCodigo, esRenovacion: COD_RENOVACION.has(o.tipoCodigo), objetivoSugerido: objetivoSugerido(o), + tipo: o.tipo || null, plan: o.plan || null, forecast: o.forecast || null, cierre: o.cierre || null, + })), + actPorOpp, + existentes, + bloques, + lotes, + }; + + return ( +
+ {cabecera} + +
+ ); +} diff --git a/app/api/auth/[...nextauth]/route.js b/app/api/auth/[...nextauth]/route.js new file mode 100644 index 0000000..e65717d --- /dev/null +++ b/app/api/auth/[...nextauth]/route.js @@ -0,0 +1,2 @@ +import { handlers } from "../../../lib/auth"; +export const { GET, POST } = handlers; diff --git a/app/components/AppShell.js b/app/components/AppShell.js new file mode 100644 index 0000000..6a5fdf0 --- /dev/null +++ b/app/components/AppShell.js @@ -0,0 +1,204 @@ +"use client"; +import { Suspense, useEffect, useState } from "react"; +import Link from "next/link"; +import Image from "next/image"; +import { usePathname, useSearchParams } from "next/navigation"; +import SeccionTabs from "./SeccionTabs"; +import { registrarVistaAction } from "../uso/usoActions"; +import { DYN } from "../lib/constants"; + +// Altas que se hacen en Dynamics (la app no las cubre): se abren directo en el formulario nuevo. +const nuevoEnDynamics = (etn) => DYN.replace("etn=opportunity", `etn=${etn}`).replace(/&id=$/, ""); +const CREAR_EN_DYNAMICS = [ + ["Nueva oportunidad", "opportunity"], + ["Nueva cuenta", "account"], + ["Nuevo cliente potencial", "lead"], + ["Nueva oferta", "quote"], +]; + +// Grupo del menú; si `plegado`, se muestra recogido (se abre solo cuando la página actual es de ese grupo). +function Grupo({ g, plegado, activoAqui, children }) { + return plegado ? ( +
+ {g} + {children} +
+ ) : ( +
+
{g}
+ {children} +
+ ); +} + +// El filtro de Propietario (`owner` en la URL) tiene que sobrevivir al cambio de página: cada +// enlace del menú lo arrastra. Va dentro de un Suspense porque useSearchParams() así lo exige en +// el layout; mientras resuelve, el enlace funciona igual (sin el filtro). +function NavLink({ href, children, ...rest }) { + const owner = useSearchParams().get("owner"); + return ( + + {children} + + ); +} + +function OwnerAwareLink({ href, children, ...rest }) { + return ( + + {children} + + } + > + + {children} + + + ); +} + +// Hora de Nicaragua explícita: el servidor puede correr en otro huso horario y "en vivo" sin hora +// no prueba nada — mostrar solo la hora local del navegador sería ambiguo sobre cuál huso es. +function horaNicaragua(iso) { + return new Intl.DateTimeFormat("es-NI", { + timeZone: "America/Managua", + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + }).format(new Date(iso)); +} + +export default function AppShell({ pages, session, onSignIn, onSignOut, generatedAt, children }) { + const [open, setOpen] = useState(false); + const pathname = usePathname(); + // «Ver el menú como»: el gerente puede ver el menú tal como lo ve un ejecutivo (solo cambia el menú, no los datos). + const [comoEjecutivo, setComoEjecutivo] = useState(false); + useEffect(() => { + try { setComoEjecutivo(localStorage.getItem("informe.menuComo") === "ejecutivo"); } catch { /* sin almacenamiento */ } + }, []); + const cambiarMenu = (v) => { + setComoEjecutivo(v); + try { localStorage.setItem("informe.menuComo", v ? "ejecutivo" : "gerente"); } catch { /* ignorar */ } + }; + const verComoGerente = !!session?.isAdmin && !comoEjecutivo; + const email = session?.email || null; + // `soloGerente`: entradas que solo ve el gerente (y solo con el menú en modo gerente). + const visibles = pages.filter((p) => !p.soloGerente || verComoGerente); + const grupos = [...new Set(visibles.map((p) => p.grupo))]; + + // Registro de uso: una visita por cambio de página (solo con sesión). Nunca bloquea ni muestra errores. + useEffect(() => { + if (!email) return; + try { + const owner = new URLSearchParams(window.location.search).get("owner"); + registrarVistaAction({ ruta: pathname, owner, ancho: window.innerWidth }); + } catch { /* ignorar */ } + }, [pathname, email]); + + return ( +
+ + +
setOpen(false)} /> + +
+
+ +
+ {session?.email ? ( + <> + {session.isAdmin && ( + <> + + + + + + 📊 Uso + + + ⚙ Metas + + + )} + + {session.email} {session.isAdmin ? "(admin)" : ""} + +
+ +
+ + ) : ( +
+ +
+ )} +
+
+
+ + {children} +
+
+
+ ); +} diff --git a/app/components/BuscadorOportunidades.js b/app/components/BuscadorOportunidades.js new file mode 100644 index 0000000..364fa13 --- /dev/null +++ b/app/components/BuscadorOportunidades.js @@ -0,0 +1,59 @@ +"use client"; +import { useEffect, useRef, useState } from "react"; + +// Buscador de oportunidades para las páginas de previsión y tubería (ventas y renovaciones). Filtra las +// FILAS de todas las tablas de la página por nombre de oportunidad o de cliente (sin tildes ni mayúsculas). +// No recalcula las tarjetas ni los totales: es una ayuda para ubicar una oportunidad, no un filtro de datos. +const norm = (s) => String(s || "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase(); + +export default function BuscadorOportunidades() { + const [q, setQ] = useState(""); + const [vis, setVis] = useState(null); // { mostradas, total } mientras hay búsqueda + const qRef = useRef(""); + qRef.current = q; + + useEffect(() => { + let temporizador = null; + const aplicar = () => { + const t = norm(qRef.current).trim(); + const filas = [...document.querySelectorAll("main table tbody tr, .tw table tbody tr")].filter((tr) => tr.querySelector("a.opp")); + let ok = 0; + for (const tr of new Set(filas)) { + const coincide = !t || norm(tr.textContent).includes(t); + tr.hidden = !coincide; + if (coincide) ok++; + } + setVis(t ? { mostradas: ok, total: new Set(filas).size } : null); + }; + aplicar(); + // Si la página se vuelve a pintar (cambia un filtro), se vuelve a aplicar la búsqueda. + const obs = new MutationObserver(() => { + clearTimeout(temporizador); + temporizador = setTimeout(aplicar, 120); + }); + obs.observe(document.body, { childList: true, subtree: true }); + return () => { + obs.disconnect(); + clearTimeout(temporizador); + document.querySelectorAll("tr[hidden]").forEach((tr) => { tr.hidden = false; }); + }; + }, [q]); + + return ( +
+ setQ(e.target.value)} + placeholder="🔍 Buscar oportunidad o cliente…" + aria-label="Buscar oportunidad o cliente" + /> + {vis && ( + + {vis.mostradas === 0 ? "Sin coincidencias en las tablas" : `${vis.mostradas} de ${vis.total} filas`} + {" · "} + + )} +
+ ); +} diff --git a/app/components/ErrorNotice.js b/app/components/ErrorNotice.js new file mode 100644 index 0000000..47db537 --- /dev/null +++ b/app/components/ErrorNotice.js @@ -0,0 +1,17 @@ +export default function ErrorNotice({ error }) { + const isExpired = error?.message === "TOKEN_EXPIRED" || error?.message?.includes("RefreshFailed"); + return ( +
+

No se pudo cargar la información

+ {isExpired ? ( +

Tu sesión con Dynamics expiró. Cerrá sesión y volvé a iniciarla.

+ ) : ( +

+ Dynamics no respondió correctamente (posiblemente por límite de consultas). Recargá la página en unos + segundos. +

+ )} +

{error?.message}

+
+ ); +} diff --git a/app/components/FilterChips.js b/app/components/FilterChips.js new file mode 100644 index 0000000..6075058 --- /dev/null +++ b/app/components/FilterChips.js @@ -0,0 +1,44 @@ +"use client"; +import { useRouter, useSearchParams, usePathname } from "next/navigation"; +import { parseFiltParam, encodeFiltParam } from "../lib/filterState"; + +// Chips de filtros activos — equivalente a chips()/bindChips() del sitio HTML (assets/js/filters.js). +// dimLabels: {dimKey: "Etiqueta legible"} opcional, para no mostrar la clave técnica cruda. +export default function FilterChips({ dimLabels = {} }) { + const router = useRouter(); + const pathname = usePathname(); + const searchParams = useSearchParams(); + const filt = parseFiltParam(searchParams.get("f")); + const keys = Object.keys(filt); + if (!keys.length) return null; + + function removeDim(dim) { + const next = { ...filt }; + delete next[dim]; + const params = new URLSearchParams(searchParams.toString()); + const f = encodeFiltParam(next); + if (f) params.set("f", f); + else params.delete("f"); + const qs = params.toString(); + router.push(qs ? `${pathname}?${qs}` : pathname, { scroll: false }); + } + + function clearAll() { + const params = new URLSearchParams(searchParams.toString()); + params.delete("f"); + const qs = params.toString(); + router.push(qs ? `${pathname}?${qs}` : pathname, { scroll: false }); + } + + return ( +
+ Filtros: + {keys.map((k) => ( + removeDim(k)} title="Quitar filtro"> + {dimLabels[k] || k}: {filt[k]} ✕ + + ))} + Limpiar +
+ ); +} diff --git a/app/components/FilterableRow.js b/app/components/FilterableRow.js new file mode 100644 index 0000000..d993d95 --- /dev/null +++ b/app/components/FilterableRow.js @@ -0,0 +1,31 @@ +"use client"; +import { useRouter, useSearchParams, usePathname } from "next/navigation"; +import { parseFiltParam, encodeFiltParam, toggleFilt, isFiltActive } from "../lib/filterState"; + +// Envoltura clickeable genérica para clic-para-filtrar — reemplaza bindRows()/bindMatriz*() del +// sitio HTML (assets/js/filters.js). `pairs` es [[dim, valor], ...]: una fila de panel manda un +// solo par, una celda de matriz (calidad×movimiento, plan×termómetro) manda dos — el toggle es +// "todo o nada" sobre ese conjunto de ejes (ver toggleFilt en lib/filterState.js). +export default function FilterableRow({ pairs, className = "", activeClassName = "active", as: As = "div", children, ...rest }) { + const router = useRouter(); + const pathname = usePathname(); + const searchParams = useSearchParams(); + const filt = parseFiltParam(searchParams.get("f")); + const active = isFiltActive(filt, pairs); + + function onClick() { + const next = toggleFilt(filt, pairs); + const params = new URLSearchParams(searchParams.toString()); + const f = encodeFiltParam(next); + if (f) params.set("f", f); + else params.delete("f"); + const qs = params.toString(); + router.push(qs ? `${pathname}?${qs}` : pathname, { scroll: false }); + } + + return ( + + {children} + + ); +} diff --git a/app/components/LoginPrompt.js b/app/components/LoginPrompt.js new file mode 100644 index 0000000..21212b6 --- /dev/null +++ b/app/components/LoginPrompt.js @@ -0,0 +1,8 @@ +export default function LoginPrompt() { + return ( +
+

Informe Comercial ALFA+

+

Iniciá sesión con tu cuenta de Alfanumeric para ver tu información.

+
+ ); +} diff --git a/app/components/OwnerControl.js b/app/components/OwnerControl.js new file mode 100644 index 0000000..ff74079 --- /dev/null +++ b/app/components/OwnerControl.js @@ -0,0 +1,168 @@ +"use client"; +import { useState, useRef, useEffect } from "react"; +import { useRouter, useSearchParams, usePathname } from "next/navigation"; + +// Selector de Propietario con multi-selección — puerto de owner.js/owner-panel (App Informe). +// Estado en la URL (`owner=email1,email2`), no en un Set en memoria de módulo como el HTML: cada +// página server-side ya lee esa lista vía ownerFilter() (authz.js). Sin el param `owner` en la URL +// = "todos" — pero en el dropdown eso se representa con el set COMPLETO marcado (no un set vacío): +// así un clic sobre un ejecutivo ya marcado lo desmarca a él y deja a los demás como estaban, en +// vez de invertir la selección entera (bug real encontrado al probar: con "vacío = todos", el +// primer clic dejaba SOLO a esa persona marcada). No se puede llegar a 0 marcados: desmarcar el +// último no hace nada, en vez de una pantalla en blanco confusa. +// +// Persistencia entre páginas: el menú lateral (AppShell) arrastra `owner` en cada enlace, y como +// respaldo la última selección se guarda en localStorage — si se abre una página sin `owner` en la +// URL (recarga, otra pestaña, enlace directo) se restaura. "*" = todos. Las páginas no comparten la +// misma lista de propietarios (Tubería: equipo activo; Ganadas/Perdidas: histórico; Renovaciones: +// Ventas + SAC), así que los correos que no existan en la lista de ESTA página se descartan. +const STORAGE_KEY = "informe.owner"; +const readSaved = () => { + try { + return localStorage.getItem(STORAGE_KEY); + } catch { + return null; + } +}; +const saveSel = (value) => { + try { + localStorage.setItem(STORAGE_KEY, value); + } catch {} +}; + +export default function OwnerControl({ owners, current, locked, lockedLabel }) { + const router = useRouter(); + const pathname = usePathname(); + const searchParams = useSearchParams(); + const [open, setOpen] = useState(false); + const ref = useRef(null); + const allRef = useRef(null); + const currentKey = (current || []).join(","); + const ownersKey = owners.map((o) => o.email).join(","); + + const effectiveSet = (list) => { + const arr = list && list.length ? list : owners.map((o) => o.email); + return new Set(arr); + }; + + // Estado local vía ref además de useState: dos clics seguidos en el dropdown ocurren en el mismo + // tick de JS, antes de que React aplique el primer setState — computar `next` desde el ref (no + // desde `selected`, el valor de render) evita perder el primer clic. + const [selected, setSelected] = useState(() => effectiveSet(current)); + const selRef = useRef(selected); + useEffect(() => { + const next = effectiveSet(current); + selRef.current = next; + setSelected(next); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [currentKey]); + + // Descarta de la URL los correos que no están en la lista de esta página y, si la URL no trae + // `owner`, restaura la selección guardada (ver nota arriba). No corre para el vendedor (locked). + useEffect(() => { + if (locked) return; + const valid = new Set(owners.map((o) => o.email.toLowerCase())); + const cur = (current || []).map((e) => e.toLowerCase()); + let wanted = null; + if (cur.length) { + const kept = cur.filter((e) => valid.has(e)); + if (kept.length !== cur.length) wanted = kept; + } else { + const saved = readSaved(); + if (saved && saved !== "*") { + const kept = saved.split(",").filter((e) => valid.has(e.toLowerCase())); + if (kept.length && kept.length < valid.size) wanted = kept; + } + } + if (wanted === null) return; + const params = new URLSearchParams(searchParams.toString()); + if (!wanted.length || wanted.length === valid.size) params.delete("owner"); + else params.set("owner", wanted.join(",")); + const qs = params.toString(); + router.replace(qs ? `${pathname}?${qs}` : pathname, { scroll: false }); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [currentKey, ownersKey, locked]); + + // Estado intermedio de «Seleccionar todos» cuando hay una selección parcial. + useEffect(() => { + if (allRef.current) allRef.current.indeterminate = selected.size > 0 && selected.size < owners.length; + }, [selected, owners.length]); + + useEffect(() => { + function onDocClick(e) { + if (ref.current && !ref.current.contains(e.target)) setOpen(false); + } + document.addEventListener("mousedown", onDocClick); + return () => document.removeEventListener("mousedown", onDocClick); + }, []); + + if (locked) { + return ( +
+ + +
+ ); + } + + function applySet(nextSet) { + selRef.current = nextSet; + setSelected(nextSet); + const params = new URLSearchParams(searchParams.toString()); + const all = nextSet.size === 0 || nextSet.size === owners.length; + if (all) params.delete("owner"); + else params.set("owner", [...nextSet].join(",")); + saveSel(all ? "*" : [...nextSet].join(",")); + const qs = params.toString(); + router.push(qs ? `${pathname}?${qs}` : pathname, { scroll: false }); + } + + const allSelected = selected.size === owners.length; + // Desmarcar «Seleccionar todos» no puede dejar 0 marcados (pantalla en blanco): deja solo al + // primero de la lista, que el usuario ajusta marcando a los demás. + function toggleAll() { + if (allSelected) { + if (owners.length) applySet(new Set([owners[0].email])); + } else { + applySet(new Set(owners.map((o) => o.email))); + } + } + + function toggle(email) { + const next = new Set(selRef.current); + if (next.has(email)) next.delete(email); + else next.add(email); + if (next.size === 0) return; // no se puede desmarcar al último + applySet(next); + } + + const label = + selected.size === owners.length + ? "Todos los propietarios" + : selected.size === 1 + ? owners.find((o) => o.email === [...selected][0])?.name || [...selected][0] + : `${selected.size} propietarios`; + + return ( +
+ + +
+ + {owners.map((o) => ( + + ))} +
+
+ ); +} diff --git a/app/components/PageLoading.js b/app/components/PageLoading.js new file mode 100644 index 0000000..f78ab48 --- /dev/null +++ b/app/components/PageLoading.js @@ -0,0 +1,17 @@ +// Fallback de carga — Next.js la muestra automáticamente (vía loading.js) mientras la página de +// datos espera Dynamics, en vez de dejar la pantalla en blanco. El armazón (nav, topbar) ya está +// pintado en este punto porque vive en layout.js, fuera de este límite de Suspense. +export default function PageLoading() { + return ( +
+
+ {[0, 1, 2, 3].map((i) => ( +
+ ··· + Cargando… +
+ ))} +
+
+ ); +} diff --git a/app/components/PlanFilterSelect.js b/app/components/PlanFilterSelect.js new file mode 100644 index 0000000..af8a8a7 --- /dev/null +++ b/app/components/PlanFilterSelect.js @@ -0,0 +1,24 @@ +"use client"; +import { useRouter } from "next/navigation"; + +// Select "Plan de Cierre" de Detalle — navega por URL (?plan=...) al cambiar, mismo patrón que el +// resto de la app (sin estado de cliente propio, todo vive en la URL). +export default function PlanFilterSelect({ options, current, baseHref }) { + const router = useRouter(); + return ( + + ); +} diff --git a/app/components/ReportModal.js b/app/components/ReportModal.js new file mode 100644 index 0000000..d1339f1 --- /dev/null +++ b/app/components/ReportModal.js @@ -0,0 +1,83 @@ +"use client"; +import { useState } from "react"; + +// Modal de informe imprimible — puerto de openReporteEjecutivo()/openInformePrevision() + +// bindPrint() (App Informe/assets/js/modals.js, pdf.js). Sin librería de PDF: usa window.print() +// + las reglas @media print de public/assets/css/layout.css sobre body.rep-print (ya existían, +// vendorizadas junto con el resto del CSS del sitio HTML). +export default function ReportModal({ buttonLabel, disabled, disabledTitle, children }) { + const [open, setOpen] = useState(false); + + function handlePrint() { + document.body.classList.add("rep-print"); + const cleanup = () => { + document.body.classList.remove("rep-print"); + window.removeEventListener("afterprint", cleanup); + }; + window.addEventListener("afterprint", cleanup); + window.print(); + } + + return ( + <> + + {open && ( + <> +
setOpen(false)} + /> +
+
+ + +
+
+ {children} +
+
+ + )} + + ); +} diff --git a/app/components/SeccionTabs.js b/app/components/SeccionTabs.js new file mode 100644 index 0000000..d26148e --- /dev/null +++ b/app/components/SeccionTabs.js @@ -0,0 +1,42 @@ +"use client"; +import { Suspense } from "react"; +import Link from "next/link"; +import { usePathname, useSearchParams } from "next/navigation"; +import { seccionDe } from "../lib/secciones"; + +// Barra de pestañas de una sección (Cierres, Resultados, Semana). Va arriba de las páginas que pertenecen a una +// sección; conserva el filtro de Propietario al cambiar de pestaña o de universo. +function Barra() { + const pathname = usePathname(); + const owner = useSearchParams().get("owner"); + const hit = seccionDe(pathname); + if (!hit) return null; + const { seccion, vista, universo } = hit; + const con = (href) => (owner && href ? `${href}?owner=${encodeURIComponent(owner)}` : href); + return ( +
+
+ {seccion.vistas.map((v) => { + const href = universo === "renov" && v.renov ? v.renov : v.ventas; + return ( + {v.label} + ); + })} +
+ {seccion.interruptor && ( +
+ Ventas + Renovaciones +
+ )} +
+ ); +} + +export default function SeccionTabs() { + return ( + + + + ); +} diff --git a/app/components/SegTabs.js b/app/components/SegTabs.js new file mode 100644 index 0000000..6148546 --- /dev/null +++ b/app/components/SegTabs.js @@ -0,0 +1,28 @@ +"use client"; +import { useRouter, useSearchParams, usePathname } from "next/navigation"; + +// Pestañas rotativas genéricas — reemplaza indTabsBar()/las pestañas de MTZ_DIMS/COH_DIMS del +// sitio HTML (assets/js/tables.js). `tabs` es [{k, lbl}], `paramName` el searchParam que guarda la +// pestaña activa (equivalente a indTab/mtzEjeDim/cohDim en state.js — acá vive en la URL, no en +// una variable global de módulo). +export default function SegTabs({ tabs, activeKey, paramName }) { + const router = useRouter(); + const pathname = usePathname(); + const searchParams = useSearchParams(); + + function onClick(k) { + const params = new URLSearchParams(searchParams.toString()); + params.set(paramName, k); + router.push(`${pathname}?${params.toString()}`, { scroll: false }); + } + + return ( +
+ {tabs.map((t) => ( + + ))} +
+ ); +} diff --git a/app/components/actividades/AgendarBoton.js b/app/components/actividades/AgendarBoton.js new file mode 100644 index 0000000..9cc8b22 --- /dev/null +++ b/app/components/actividades/AgendarBoton.js @@ -0,0 +1,45 @@ +"use client"; +import { useState } from "react"; +import NuevaActividad from "./NuevaActividad"; +import { hoyManagua, addDays, objetivoSugerido } from "../../lib/plan"; +import { localDeIso, OBJETIVOS_LIBRES } from "../../lib/agendador"; + +// Botón «+ Actividad» de las tablas de oportunidades. Reemplaza a los tres enlaces (Cita / Tarea / Llamada) que +// abrían el formulario de Dynamics: ahora se abre la ventana de la app, ya ligada a la oportunidad, con el +// objetivo sugerido según su etapa. La actividad queda a nombre del propietario de la oportunidad. +// `opp`: { id, nombre | name, cliente, ownerId, forecast, tipoCodigo } +export default function AgendarBoton({ opp }) { + const [abierto, setAbierto] = useState(false); + const [preset, setPreset] = useState(null); + + function abrir() { + const hoy = hoyManagua(); + const ahora = localDeIso(new Date().toISOString()).min; + // Próxima hora en punto dentro del horario (8:00–17:00); si ya pasó, mañana a las 9:00. + const sig = Math.ceil((ahora + 1) / 60) * 60; + const hoyOk = sig >= 480 && sig <= 1020; + const dia = hoyOk ? hoy : addDays(hoy, sig < 480 ? 0 : 1); + const min = hoyOk ? sig : 540; + const sug = objetivoSugerido(opp); + const nombre = opp.nombre || opp.name || ""; + setPreset({ + referente: { tipo: "opportunity", id: opp.id, nombre: opp.cliente ? `${opp.cliente} — ${nombre}` : nombre }, + dia, + hora: `${String(Math.floor(min / 60)).padStart(2, "0")}:${String(min % 60).padStart(2, "0")}`, + objetivo: sug && OBJETIVOS_LIBRES.includes(sug) ? sug : "", + enNombreDe: true, // queda a nombre del propietario de la oportunidad (el servidor valida el permiso) + }); + setAbierto(true); + } + + return ( + <> + + + + {abierto && preset && setAbierto(false)} />} + + ); +} diff --git a/app/components/actividades/GestionarActividad.js b/app/components/actividades/GestionarActividad.js new file mode 100644 index 0000000..454d7d4 --- /dev/null +++ b/app/components/actividades/GestionarActividad.js @@ -0,0 +1,394 @@ +"use client"; +import { useState, useRef } from "react"; +import { createPortal } from "react-dom"; +import { useRouter } from "next/navigation"; +import { abrirActividadAction, ejecutarAccionAction, deshacerAccionAction, refrescarPantallasAction, crearSeguimientoAction, deshacerSeguimientoAction } from "../../actividades/gestionActions"; +import { actividadUrl } from "../../lib/constants"; +import { addDays, esHabil } from "../../lib/plan"; +import { ROLES, nombresDe } from "../../lib/participantes"; +import { OBJETIVOS_LIBRES, horasDe, minAHora } from "../../lib/agendador"; +import { clienteDe, oportunidadDe } from "../../lib/agendaVista"; + +// Ventana emergente para completar, reprogramar o cancelar UNA actividad sin salir del informe. Pensada +// para pocos toques: fechas y horas por botones (no menús), nota breve con frases rápidas y «Deshacer». +// El mismo componente sirve luego a la versión móvil: no depende de la pantalla donde se abre. + +const FRASES = { + Llamada: ["No contestó", "Dejé mensaje", "Habló con el decisor", "Interesado", "Pidió propuesta", "Llamar de nuevo"], + Cita: ["Visita realizada", "Se presentó la oferta", "Pidió ajustes", "Pasan a revisión interna", "Se definió fecha de firma"], + Tarea: ["Oferta enviada", "Contrato elaborado", "Seguimiento realizado", "Pendiente de respuesta del cliente"], +}; +const HORAS = ["08:00", "09:00", "10:00", "11:00", "14:00", "15:00", "16:00"]; +const DIAS = ["domingo", "lunes", "martes", "miércoles", "jueves", "viernes", "sábado"]; +const MESES = ["ene", "feb", "mar", "abr", "may", "jun", "jul", "ago", "sep", "oct", "nov", "dic"]; + +const dow = (iso) => new Date(`${iso}T12:00:00Z`).getUTCDay(); +const etiqueta = (iso) => { + const [y, m, d] = iso.split("-").map(Number); + return `${DIAS[dow(iso)]} ${d} ${MESES[m - 1]}`; +}; +function proximoLunes(hoy) { + let d = addDays(hoy, 1); + while (dow(d) !== 1) d = addDays(d, 1); + return d; +} +const horaLocal = (iso) => { + if (!iso) return ""; + const d = new Date(new Date(iso).getTime() - 6 * 3600 * 1000); + return `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`; +}; + +export default function GestionarActividad({ a, className, title, children }) { + const router = useRouter(); + const [abierto, setAbierto] = useState(false); + const [carga, setCarga] = useState("idle"); // idle | cargando | listo | error + const [det, setDet] = useState(null); + const [error, setError] = useState(""); + const [accion, setAccion] = useState("completar"); + const [nota, setNota] = useState(""); + const [dia, setDia] = useState(""); + const [hora, setHora] = useState(""); + const [confirma, setConfirma] = useState(false); + const [trabajando, setTrabajando] = useState(false); + const [roles, setRoles] = useState([]); // códigos de quienes participaron (solo al completar) + const [hecho, setHecho] = useState(null); // { accionId, accion, ... } + const [deshecho, setDeshecho] = useState(false); + const huboCambio = useRef(false); + // Seguimiento: programar la siguiente actividad justo después de completar. + const [segAbierto, setSegAbierto] = useState(false); + const [segTipo, setSegTipo] = useState("Llamada"); + const [segObj, setSegObj] = useState(""); + const [segDia, setSegDia] = useState(""); + const [segHora, setSegHora] = useState("09:00"); + const [segTrab, setSegTrab] = useState(false); + const [segError, setSegError] = useState(""); + const [seg, setSeg] = useState(null); // { accionId, tipo, dia, hora } cuando se creó + const [segDeshecho, setSegDeshecho] = useState(false); + + async function abrir() { + setAbierto(true); + setCarga("cargando"); + setError(""); + setHecho(null); + setDeshecho(false); + setConfirma(false); + setNota(""); + setAccion("completar"); + setSegAbierto(false); + setSeg(null); + setSegDeshecho(false); + setSegError(""); + const r = await abrirActividadAction({ tipo: a.tipo, id: a.id }); + if (!r.ok) { + setError(r.error); + setCarga("error"); + return; + } + setDet(r.actividad); + setRoles(r.actividad.participantes || []); // en una cita ya marcada, parte de lo que tenía + setDia(r.actividad.hoy); + setSegTipo(a.tipo === "Cita" ? "Llamada" : a.tipo); + setSegObj(OBJETIVOS_LIBRES.includes(r.actividad.objetivo) ? r.actividad.objetivo : ""); + let sig = addDays(r.actividad.hoy, 1); + while (!esHabil(sig)) sig = addDays(sig, 1); + setSegDia(sig); + setHora(horaLocal(r.actividad.scheduledstart) || "09:00"); + setCarga(r.apagado ? "apagado" : "listo"); + } + + async function cerrar() { + setAbierto(false); + if (huboCambio.current) { + huboCambio.current = false; + await refrescarPantallasAction(); // vacía la caché de datos de las pantallas afectadas + router.refresh(); + } + } + + async function ejecutar() { + if (accion === "completar" && !nota.trim() && !confirma) { + setConfirma(true); + return; + } + if (accion === "cancelar" && !confirma) { + setConfirma(true); + return; + } + setTrabajando(true); + setError(""); + const r = await ejecutarAccionAction({ tipo: a.tipo, id: a.id, accion, nota, dia, hora, participantes: accion === "completar" ? roles : [] }); + setTrabajando(false); + if (!r.ok) { + setError(r.error); + setConfirma(false); + return; + } + huboCambio.current = true; + setHecho(r); + } + + async function deshacer() { + setTrabajando(true); + setError(""); + const r = await deshacerAccionAction(hecho.accionId); + setTrabajando(false); + if (!r.ok) { + setError(r.error); + return; + } + setDeshecho(true); + } + + const cerrada = det && det.estado !== "abierta"; + const conInvitados = det?.tipo === "Cita" && det.invitados > 0; + const bloqueaFecha = conInvitados && (accion === "reprogramar" || accion === "cancelar"); + const hoy = det?.hoy; + const rapidos = hoy + ? [["Hoy", hoy], ["Mañana", addDays(hoy, 1)], ["Pasado mañana", addDays(hoy, 2)], ["Lunes", proximoLunes(hoy)]] + : []; + const esTarea = a.tipo === "Tarea"; + const crm = actividadUrl({ tipo: a.tipo, id: a.id }); + const fraseDe = (f) => setNota((n) => (n.trim() ? `${n.trim()}. ${f}` : f)); + + // El botón de abajo es el que guarda en Dynamics; las pestañas de arriba solo eligen la acción. + const textoAccion = { completar: "Guardar y completar", reprogramar: "Guardar nueva fecha", cancelar: "Cancelar actividad" }[accion]; + + async function programarSeguimiento() { + setSegTrab(true); + setSegError(""); + const r = await crearSeguimientoAction({ tipo: a.tipo, id: a.id, nuevoTipo: segTipo, objetivo: segObj, dia: segDia, hora: segTipo === "Tarea" ? "" : segHora }); + setSegTrab(false); + if (!r.ok) { + setSegError(r.error); + return; + } + huboCambio.current = true; + setSeg(r); + } + async function deshacerSeguimiento() { + setSegTrab(true); + setSegError(""); + const r = await deshacerSeguimientoAction(seg.accionId); + setSegTrab(false); + if (!r.ok) { + setSegError(r.error); + return; + } + setSegDeshecho(true); + } + const puedeSeguir = hecho && hecho.accion === "completar" && !deshecho && det?.tieneOpp; + const horasSeg = horasDe(segTipo).map(minAHora); + + return ( + <> + + {abierto && typeof document !== "undefined" && createPortal( +
+
e.stopPropagation()}> +
+
+
{a.tipo} · {clienteDe(a) || det?.asunto || a.asunto}
+
+ {(oportunidadDe(a) || det?.referente) ? `${oportunidadDe(a) || det.referente} · ` : ""}{det?.asunto && clienteDe(a) ? `${det.asunto} · ` : ""} + {det?.scheduledend ? `Para el ${det.scheduledend.slice(0, 10).split("-").reverse().join("/")}` : ""} + {det?.owner ? ` · ${det.owner}` : ""} +
+
+ +
+ + {carga === "cargando" &&

Cargando desde Dynamics…

} + {carga === "error" &&

{error}

} + {carga === "apagado" &&

La gestión de actividades está en pausa por mantenimiento. Mientras tanto, ábrela en Dynamics.

} + + {carga === "listo" && det && !hecho && ( + <> + {det.enNombreDeOtro &&

Estás actuando en nombre de {det.owner}.

} + {cerrada ? ( +

Esta actividad ya está {det.estado}. Abrir en Dynamics ↗

+ ) : ( + <> +
+ {[["completar", "✓ Completar"], ["reprogramar", "📅 Reprogramar"], ["cancelar", "✕ Cancelar"]].map(([k, l]) => ( + + ))} +
+ + {bloqueaFecha && ( +

+ Esta cita tiene {det.invitados} invitado{det.invitados === 1 ? "" : "s"}. Para no enviarles avisos por error, {accion === "cancelar" ? "cancélala" : "reprográmala"} directamente en Dynamics.{" "} + Abrir en Dynamics ↗ +

+ )} + + {accion === "reprogramar" && !bloqueaFecha && ( +
+
Nueva fecha
+
+ {rapidos.map(([l, v]) => ( + + ))} + setDia(e.target.value)} /> +
+ {!esTarea && ( + <> +
Hora
+
+ {HORAS.map((h) => ( + + ))} + setHora(e.target.value)} /> +
+ + )} + {dia &&

Nueva fecha: {etiqueta(dia)}{!esTarea && hora ? ` · ${hora}` : ""}{esTarea ? " (vence a las 16:00)" : ""}

} +
+ )} + + {accion !== "reprogramar" && !bloqueaFecha && ( +
+
{accion === "completar" ? "Nota breve: qué pasó y qué sigue" : "Motivo (opcional)"}
+