commit 287ddce8146a2f380a1c464bd58ba19fbdcd647d Author: MarcoMontenegro Date: Thu Nov 19 16:46:18 2026 -0600 Objetivos de actividad: agrega Reunión Técnica, Recopilación Proyecto SW, Retención y Cobro Factura (antes Postventa/Cobro); Next 16.4.6 por GHSA-vc7v-qv4w-wrv8 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..85e5f73 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,93 @@ +@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. + +## Agendador: reglas y GV (2026-11-11) + +- Reglas en `AGENDADOR` (`app/lib/agendador.js`): franjas 8:30–12:00 y 13:30–17:00; llamada 10 min (horas cada 10), visita 60 min (cada 30); máximos por día 10 llamadas, 4 visitas, 6 tareas; tareas vencen 16:00. También rigen el seguimiento al completar. +- **«Con GV»**: ver `crearActividad` (`agendadorServer.js`) y `agendadorActions.js`. Cita con GV: `appointment_activity_parties` con organizador (7) y Marco (5, `GV_USUARIO` en `participantes.js`). Esas citas cuentan a Marco como «invitado», así que la ventana de gestión no las reprograma ni cancela (se hace en Dynamics). +- Seguimiento al completar: un solo botón «Guardar, completar y programar seguimiento»; objetivo validado contra `OBJETIVOS_LIBRES`; el servidor rechaza sábados y domingos. + +## Campanita y seguimiento del mismo día (2026-11-13) + +- **Campanita** (barra superior, `app/components/Campanita.js`; datos en `app/api/campanita/route.js` + `app/lib/campanita.js`, que reutiliza `armarPlanPeriodo`/`listaPlana`): número rojo = vencidas del mes en curso (abiertas de días anteriores o de hoy con hora pasada) + llamadas/visitas que empiezan en ≤30 min. Ejecutivo: sus actividades. Administrador sin `?owner`: solo actividades con Gerencia Comercial, sin vencidas. El administrador puede pasar `?owner=correo` al endpoint para ver lo que vería ese ejecutivo (así se validó). `fresh=1` salta la caché de 4 min (se usa tras gestionar). Sin avisos push (va en la PWA, etapa 2). +- **Seguimiento mismo día**: botón «Hoy, más tarde» en `GestionarActividad`; `horasLibres` (`agendador.js`) quita horas pasadas (margen 5 min) y las que chocan con lo ya agendado hoy (`hoyAgenda` de `abrirActividadAction`). El servidor sigue validando igual. + +## App de campo (PWA) — rutas `/m/...` (2026-11-14) + +Versión de teléfono de la misma app (mismo login, mismos permisos: `ownerFilter`/`authz`). **Las páginas web no cambian** (solo: `AppShell` cede el marco a `CampoShell` cuando la ruta empieza por `/m`, y muestra el aviso «Usar la versión de campo →» en ≤ 600 px). +- **Pantallas:** `/m/hoy`, `/m/calendario`, `/m/semana`, `/m/tuberia`, `/m/cuentas`, `/m/cuentas/[id]`, `/m/oportunidad/[id]`. Marco/asistente eligen propietario con `OwnerM` (`?owner=`). +- **Código:** `app/m/` (páginas, `components/`: `CampoShell`, `HojaActividad` = hoja de acciones, `NuevaMovil` = botón +, `BotonesContacto`, `WhatsAppRegistro`, `OppAcciones` = ✎ Editar y 📝 Nota), `lib/campo.js` (puro: WhatsApp/teléfono/mapas, categorías, opciones de campos), `lib/campoServer.js` (Dynamics), `lib/campoPagina.js`, `m/campoActions.js`. CSS propio: `public/assets/css/campo.css` (solo se carga en `/m`). +- **Reutiliza**, sin duplicar reglas: `plan.js`, `agendaDia.js`, `agendador.js`, `participantes.js`, `queries.js`, acciones de `gestionActions.js` (completar/reprogramar/cancelar/seguimiento/editar/deshacer) y `cuentasActions.js` (alta con «Ya la realicé»; se le añadió el parámetro `canal`: `whatsapp` pone «WhatsApp – …» en el asunto). +- **PWA:** `public/campo/manifest.webmanifest` (+ iconos a partir de `Logos A+ -01.png`), `public/campo-sw.js` (alcance **solo `/m/`**: copia de `/m/hoy` con sesión → «Sin conexión · actualizado HH:MM»; estáticos de Next; no guarda auth ni otras rutas; sin push). Cerrar sesión borra esa copia. +- **Edición de oportunidad (✎):** PATCH con `If-Match`, solo lo que cambió; «Deshacer» 10 min (bitácora `actividad_accion`, acciones `edicion_opp`/`nota_opp`, canal `movil`). Editable: previsión, tipo (`alfa_typeopportunity`, **es un Choice, no un lookup**: no existe otro campo «tipo de oportunidad»), nivel de probabilidad (`alfa_niveldeprobabilidad`: Alta/Mediana/**Se desconoce**, no hay «Baja»), cierre, MRR, competidor (lookup `alfa_competidorid` → `competitors`), luz amarilla, participantes (GC → `alfa_participaciondegv`), estado de la negociación (memo ≤ 2000) + nota nativa opcional. Solo lectura: plan de cierre, clasificación (`alfa_clasificaciondeoportunidad`, el termómetro), línea de negocio. No se gana/pierde. Interruptor: `OPORTUNIDAD_EDICION=off`. +- **Pendiente:** avisos push; probar el service worker en un teléfono real (el navegador integrado no registra SW); probar WhatsApp real. 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..fd52e54 --- /dev/null +++ b/app/actividades/gestionActions.js @@ -0,0 +1,348 @@ +"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 }) }; + } +} 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..850b119 --- /dev/null +++ b/app/actividades/page.js @@ -0,0 +1,282 @@ +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, localDeIso } from "../lib/agendador"; +import { EJECUTIVOS_VENTA } from "../lib/derive"; +import { + armarPlanPeriodo, sinActividadPeriodo, hoyManagua, addDays, semanaDe, diasDelRango, esHabil, diaSemana, + PERIODOS_ACT, periodoActActivo, rangoPeriodoAct, +} from "../lib/plan"; +import LoginPrompt from "../components/LoginPrompt"; +import OwnerControl from "../components/OwnerControl"; +import ErrorNotice from "../components/ErrorNotice"; +import PeriodoControles from "../components/plan/PeriodoControles"; +import PlanSeccionPeriodo from "../components/plan/PlanSeccionPeriodo"; +import PlanTarjetasPeriodo from "../components/plan/PlanTarjetasPeriodo"; +import BarraSecciones from "../components/plan/BarraSecciones"; +import SinActividadPanel from "../components/plan/SinActividadPanel"; +import { gcDe } from "../lib/gerencia"; +import { actsDeSeccion, casillasSecciones, conteoTipos } from "../lib/planDia"; +import { listaPlana, marcarCruces } from "../lib/agendaDia"; +import AgendaCronologica from "../components/plan/AgendaCronologica"; + +export const dynamic = "force-dynamic"; + +const fechaTxt = (iso) => iso.split("-").reverse().join("/"); +const fechaCorta = (iso) => iso.split("-").reverse().slice(0, 2).join("/"); + +// 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} +
+ ); + })} +
+ ); +} + +// Enlace al resumen por ejecutivo de /equipo, con el mismo período (semana pasada/esta/próxima, mes pasado/este). +function hrefEquipo(periodo) { + const vista = periodo.startsWith("mes") ? "mes" : "semana"; + const off = periodo.endsWith("pasada") ? -1 : periodo.endsWith("proxima") ? 1 : 0; + const p = new URLSearchParams(); + if (vista === "mes") p.set("vista", "mes"); + if (off) p.set("off", String(off)); + return `/equipo${p.toString() ? `?${p.toString()}` : ""}`; +} + +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 planCompleto = armarPlanPeriodo(raw, desde, hasta, hoy); // sin filtrar: lo usan las tarjetas y la franja + const r = planCompleto.resumen; + const actsDelPlan = planCompleto.secciones.flatMap((s) => s.filas.flatMap((fila) => fila.acts)); + + // Filtros combinables (intersección): «solo Gerencia Comercial» (?gc=1) y «solo vencidas» (?venc=1). + // Trabajan sobre una copia: `planCompleto` no se muta. Vencida = fila con al menos una actividad abierta cuyo día ya pasó. + const soloGC = sp.gc === "1"; + const soloVenc = sp.venc === "1"; + const plan = + soloGC || soloVenc + ? { + ...planCompleto, + secciones: planCompleto.secciones.map((s) => { + const filas = s.filas.filter((fila) => (!soloGC || fila.acts.some((a) => gcDe(a))) && (!soloVenc || fila.vencidas > 0)); + return { ...s, filas, subtotal: filas.reduce((t, fila) => t + (fila.opp.valor || 0), 0) }; + }), + } + : planCompleto; + // Cada enlace alterna su filtro y conserva los demás parámetros (owner, periodo y el otro filtro). + const hrefFiltro = (clave, activo) => { + const qs = new URLSearchParams(Object.entries(sp).filter(([k, v]) => k !== clave && typeof v === "string")); + if (!activo) qs.set(clave, "1"); + return `/actividades${qs.toString() ? `?${qs.toString()}` : ""}`; + }; + const hrefGC = hrefFiltro("gc", soloGC); + const hrefVenc = hrefFiltro("venc", soloVenc); + + // Tarjetas: sobre el plan sin filtrar (no cambian al activar un filtro). Barra y secciones: sobre el filtrado. + const actTotalPeriodo = planCompleto.secciones.reduce((t, s) => t + actsDeSeccion(s), 0); + const mrrPeriodo = planCompleto.secciones.reduce((t, s) => t + (s.subtotal || 0), 0); + const tiposPeriodo = conteoTipos(planCompleto.secciones); + const casillas = casillasSecciones(plan.secciones); + + const sinActividad = esActualOFuturo + ? sinActividadPeriodo( + scope.emails?.length ? oppsPeriodo : oppsPeriodo.filter((o) => EJECUTIVOS_VENTA.includes(o.owner)), + raw, + desde, + 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"; + // Varios ejecutivos a la vez: la tabla muestra la columna Ejecutivo y el gerente tiene el resumen en /equipo. + const verVarios = !scope.locked && scope.emails.length !== 1 && owners.length > 0; + const conEjecutivo = scope.emails.length !== 1; + + // Vista cronológica (solo pantalla), agrupada por día. Los cruces se calculan sobre todas las actividades del período; + // los filtros ?gc=1 y ?venc=1 (a nivel de fila, como siempre) solo quitan filas de la tabla. + const ahoraMin = localDeIso(new Date().toISOString()).min; + const itemsTodos = marcarCruces(listaPlana(planCompleto.secciones, { hoy, ahoraMin, porHora: false })); + const items = itemsTodos.filter((it) => (!soloGC || it.filaGC) && (!soloVenc || it.filaVencidas > 0)); + + return ( +
+
+

Plan de Actividades

+
+ +
+
+ +
+ +
+
+ + {verVarios && session.isAdmin && ( +

+ Ver el resumen por ejecutivo en Equipo → +

+ )} + +
+

PLAN DE ACTIVIDADES

+
+ Período: {etiqueta} + Ejecutivo: {quien} +
+ + + + + + {/* Pantalla: una sola tabla cronológica agrupada por día (una fila por actividad). */} + + + {/* PDF: sigue por objetivo, igual que siempre (en pantalla va oculto). */} +
+ + + {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..eff46db --- /dev/null +++ b/app/agendador/agendadorActions.js @@ -0,0 +1,195 @@ +"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"; +import { GC } from "../lib/participantes"; +import { sumarParticipacionOpp, restaurarParticipacionOpp } from "../lib/actividadesServer"; + +// Igual que en gestionActions: con PARTICIPANTES_OPP=off no se toca la participación de la oportunidad. +const oppApagado = () => String(process.env.PARTICIPANTES_OPP || "").toLowerCase() === "off"; + +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 || ""), + gv: i?.gv === true && (i?.tipo === "Llamada" || i?.tipo === "Cita"), // «Con GV»: solo llamadas y visitas + })); + 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); + const hecho = { oppId: it.oppId, nombre: it.nombre, cliente: it.cliente, tipo: it.tipo, objetivo: it.objetivo, dia: it.dia, hora: it.hora, gv: it.gv, estado: "creada", activityId: id }; + // «Con GV»: se marca «Participación de GV» en la oportunidad AL AGENDAR (decisión de Marco). Solo suma (nunca baja + // un Sí a No) y se guarda lo previo para «Deshacer». Si falla, la actividad queda creada y solo se avisa. + if (it.gv && !oppApagado()) { + try { + const r = await sumarParticipacionOpp(token, it.oppId, [GC]); + if (r.cambio) hecho.opp = { previo: r.previo, nuevo: r.nuevo }; + } catch (e) { + if (e?.message === "TOKEN_EXPIRED") throw e; + hecho.avisoOpp = "No pude marcar la participación de GV en la oportunidad; márcala en Dynamics."; + } + } + hechos.push(hecho); + } 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, gv: it.gv, 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, + conGV: hechos.filter((h) => h.estado === "creada" && h.gv).length, + avisosOpp: hechos.filter((h) => h.avisoOpp).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, oppRestauradas: 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++; + // La oportunidad vuelve a su valor previo SOLO si esta tanda la cambió y la actividad se canceló aquí + // (si ya se completó, la participación de GV pudo ser real y se deja). + if (it.opp?.previo && it.opp?.nuevo && !oppApagado()) { + try { + await restaurarParticipacionOpp(session.accessToken, it.opp.previo, it.opp.nuevo); + resumen.oppRestauradas++; + } catch (e) { + if (e?.message === "TOKEN_EXPIRED") throw e; + resumen.errores++; + } + } + } 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..04e6d64 --- /dev/null +++ b/app/agendador/page.js @@ -0,0 +1,127 @@ +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 = ( +
+

Agendador de actividades

+
+ {puedeAgendar && Ver el Plan de Actividades →} + + + +
+
+ ); + + 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); + + // `?fecha=YYYY-MM-DD` (desde «Agendar ▸» del Plan del Día): abre el agendador con esa fecha, solo si cae entre hoy y el horizonte. + const fechaInicial = /^\d{4}-\d{2}-\d{2}$/.test(sp.fecha || "") && sp.fecha >= hoy && sp.fecha <= maxFecha ? sp.fecha : null; + + const props = { + fechaInicial, + 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/api/campanita/route.js b/app/api/campanita/route.js new file mode 100644 index 0000000..a116670 --- /dev/null +++ b/app/api/campanita/route.js @@ -0,0 +1,30 @@ +import { NextResponse } from "next/server"; +import { auth } from "../../lib/auth"; +import { ownerFilter } from "../../lib/authz"; +import { getActividades } from "../../lib/queries"; +import { hoyManagua } from "../../lib/plan"; +import { localDeIso } from "../../lib/agendador"; +import { armarCampanita } from "../../lib/campanita"; + +export const dynamic = "force-dynamic"; + +// Datos de la campanita con la sesión de quien consulta. Ejecutivo (y asistente): sus propias actividades. +// Administrador sin `owner`: solo las actividades con Gerencia Comercial de cualquier ejecutivo. +// `owner` (solo administrador, para validar): ve lo que vería ese ejecutivo. `fresh=1`: sin caché (tras gestionar). +export async function GET(req) { + const session = await auth(); + if (!session?.email) return NextResponse.json({ ok: false, error: "sin_sesion" }, { status: 401 }); + const url = new URL(req.url); + const owner = session.isAdmin ? url.searchParams.get("owner") || undefined : undefined; + const scope = ownerFilter(session, owner); + try { + const acts = await getActividades(session.accessToken, scope, undefined, { fresh: url.searchParams.get("fresh") === "1" }); + const ahoraMin = localDeIso(new Date().toISOString()).min; + const data = armarCampanita(acts, { hoy: hoyManagua(), ahoraMin, gerente: !!session.isAdmin && !owner }); + const acciones = String(process.env.ACTIVIDADES_ACCIONES || "").toLowerCase() !== "off"; // con «off» no se ofrece «Gestionar» + return NextResponse.json({ ok: true, ...data, ahoraMin, acciones }, { headers: { "Cache-Control": "no-store" } }); + } catch (e) { + const expirada = String(e?.message) === "TOKEN_EXPIRED"; + return NextResponse.json({ ok: false, error: expirada ? "sesion_expirada" : "error" }, { status: expirada ? 401 : 500 }); + } +} diff --git a/app/components/AppShell.js b/app/components/AppShell.js new file mode 100644 index 0000000..e1c2725 --- /dev/null +++ b/app/components/AppShell.js @@ -0,0 +1,230 @@ +"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"; +import Campanita from "./Campanita"; +import CampoShell from "../m/components/CampoShell"; + +// 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]); + + // Aviso discreto en teléfono (ancho ≤ 600 px): ofrecer la versión de campo. Descartable y recordado. + const [avisoCampo, setAvisoCampo] = useState(false); + useEffect(() => { + try { + if (window.innerWidth <= 600 && email && !localStorage.getItem("informe.avisoCampo")) setAvisoCampo(true); + } catch { /* sin almacenamiento */ } + }, [email]); + const descartarAviso = () => { + setAvisoCampo(false); + try { localStorage.setItem("informe.avisoCampo", "1"); } catch { /* ignorar */ } + }; + + // La app de campo (/m) tiene su propio marco: sin menú lateral. + if (pathname === "/m" || pathname?.startsWith("/m/")) { + return {children}; + } + + return ( +
+ {avisoCampo && ( +
+ Usar la versión de campo → + +
+ )} + + +
setOpen(false)} /> + +
+
+ + {session?.email && } +
+ {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/Campanita.js b/app/components/Campanita.js new file mode 100644 index 0000000..e09ace1 --- /dev/null +++ b/app/components/Campanita.js @@ -0,0 +1,153 @@ +"use client"; +import { useCallback, useEffect, useRef, useState } from "react"; +import Link from "next/link"; +import GestionarActividad from "./actividades/GestionarActividad"; +import { ICONO_TIPO, ROTULO_TIPO } from "../lib/agendaDia"; + +// Campanita de notificaciones (etapa 1, solo web). Muestra lo que pide acción hoy: actividades vencidas sin completar +// y las que vienen. Datos de /api/campanita (sesión del usuario). Se actualiza al cargar, al abrir el panel (si los datos +// tienen más de 1 min) y cada 5 min mientras la pestaña está visible; tras gestionar una actividad vuelve a leer sin caché. +const CADA_MS = 5 * 60 * 1000; +const FRESCO_MS = 60 * 1000; +const MAX_PROXIMAS = 6; + +export default function Campanita({ rutaPlan = "/plan", rutaVenc = "/actividades?periodo=mes&venc=1" }) { + const [abierto, setAbierto] = useState(false); + const [d, setD] = useState(null); + const [error, setError] = useState(false); + const raiz = useRef(null); + const ultima = useRef(0); + const gestionando = useRef(0); // ventanas «Gestionar» abiertas: mientras haya una, no se reemplaza la lista + const cargando = useRef(false); + + const cargar = useCallback(async (fresh = false) => { + if (cargando.current) return; + cargando.current = true; + try { + const r = await fetch(`/api/campanita${fresh ? "?fresh=1" : ""}`, { cache: "no-store" }); + if (!r.ok) throw new Error(String(r.status)); + const j = await r.json(); + if (!j.ok) throw new Error(j.error || "error"); + if (gestionando.current === 0) setD(j); + ultima.current = Date.now(); + setError(false); + } catch { + setError(true); + } finally { + cargando.current = false; + } + }, []); + + useEffect(() => { + cargar(); + const t = setInterval(() => { + if (document.visibilityState === "visible" && gestionando.current === 0) cargar(); + }, CADA_MS); + const vis = () => { + if (document.visibilityState === "visible" && Date.now() - ultima.current > CADA_MS) cargar(); + }; + document.addEventListener("visibilitychange", vis); + return () => { + clearInterval(t); + document.removeEventListener("visibilitychange", vis); + }; + }, [cargar]); + + useEffect(() => { + if (!abierto) return; + const clic = (e) => { + if (raiz.current?.contains(e.target) || e.target.closest?.(".gst-bd")) return; // la ventana «Gestionar» vive fuera del panel + setAbierto(false); + }; + const tecla = (e) => { + if (e.key === "Escape" && gestionando.current === 0) setAbierto(false); + }; + document.addEventListener("mousedown", clic); + document.addEventListener("keydown", tecla); + return () => { + document.removeEventListener("mousedown", clic); + document.removeEventListener("keydown", tecla); + }; + }, [abierto]); + + const alternar = () => { + const nuevo = !abierto; + setAbierto(nuevo); + if (nuevo && Date.now() - ultima.current > FRESCO_MS) cargar(); + }; + const alAbrir = () => { + gestionando.current++; + }; + const alCerrar = (cambio) => { + gestionando.current = Math.max(0, gestionando.current - 1); + cargar(cambio); + }; + + const n = d?.numero || 0; + const visibles = d ? d.proximas.slice(0, MAX_PROXIMAS) : []; + const resto = d ? d.proximas.length - visibles.length : 0; + + const fila = (it, hecho) => ( +
  • + {hecho ? "✓ " : ""}{it.hora || "—"} + + {ICONO_TIPO[it.tipo]} {it.cliente}{it.esCaso && (caso)}{it.esCuenta && (cuenta)} + + {ROTULO_TIPO[it.tipo] || it.tipo} · {it.objetivo} + {it.enMin != null && · {it.enMin <= 0 ? "ahora" : `en ${it.enMin} min`}} + + + {!hecho && d.acciones && ( + Gestionar + )} +
  • + ); + + return ( +
    + + {/* El panel se queda montado (oculto) para no desmontar una ventana «Gestionar» abierta desde él. */} + +
    + ); +} 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..fe46c3e --- /dev/null +++ b/app/components/actividades/GestionarActividad.js @@ -0,0 +1,525 @@ +"use client"; +import { useState, useRef } from "react"; +import { createPortal } from "react-dom"; +import { useRouter } from "next/navigation"; +import { abrirActividadAction, ejecutarAccionAction, deshacerAccionAction, refrescarPantallasAction, crearSeguimientoAction, deshacerSeguimientoAction, editarActividadAction, deshacerEdicionAction } from "../../actividades/gestionActions"; +import { actividadUrl } from "../../lib/constants"; +import { addDays, esHabil } from "../../lib/plan"; +import { ROLES, nombresDe } from "../../lib/participantes"; +import { AGENDADOR, OBJETIVOS_LIBRES, horasDe, horasLibres, horaAMin, localDeIso, 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. + +export 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, onAbrir, onCerrado }) { + 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); + // Pestaña «Editar»: cambios sin completar la actividad (objetivo, duración, nota previa, participantes de la visita). + const [objEd, setObjEd] = useState(""); + const [durEd, setDurEd] = useState(null); + const [notaEd, setNotaEd] = useState(""); + const [rolesEd, setRolesEd] = useState([]); + // 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); + if (onAbrir) onAbrir(); + 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 + setRolesEd(r.actividad.participantes || []); + setObjEd(OBJETIVOS_LIBRES.includes(r.actividad.objetivo) ? r.actividad.objetivo : ""); + setDurEd(r.actividad.duracion || null); + setNotaEd(""); + 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() { + // «Listo»/✕/clic fuera con un seguimiento a medio llenar (abierto, sin guardar): se pide confirmación antes de descartarlo. + if (hecho && hecho.accion === "completar" && !deshecho && det?.tieneOpp && segAbierto && !seg && !segDeshecho && !window.confirm("Tienes un seguimiento sin guardar. ¿Cerrar sin guardarlo?")) return; + setAbierto(false); + const cambio = huboCambio.current; + if (cambio) { + huboCambio.current = false; + await refrescarPantallasAction(); // vacía la caché de datos de las pantallas afectadas + router.refresh(); + } + if (onCerrado) onCerrado(cambio); // la campanita se actualiza al cerrar (sin caché si hubo cambios) + } + + async function ejecutar() { + if (accion === "editar") { + setTrabajando(true); + setError(""); + const r = await editarActividadAction({ tipo: a.tipo, id: a.id, objetivo: objEd, duracion: a.tipo === "Tarea" ? null : durEd, nota: notaEd, participantes: a.tipo === "Cita" || a.tipo === "Llamada" ? rolesEd : null }); + setTrabajando(false); + if (!r.ok) { + setError(r.error); + return; + } + huboCambio.current = true; + setHecho(r); + return; + } + 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 : [] }); + if (!r.ok) { + setTrabajando(false); + setError(r.error); + setConfirma(false); + return; + } + huboCambio.current = true; + setHecho(r); + // Un solo botón: si el formulario de seguimiento estaba abierto y completo, se crea justo después de completar. + // Si el seguimiento falla, la actividad ya quedó completada y el formulario sigue abierto para reintentar. + if (accion === "completar" && quiereSeg) await guardarSeguimiento(); + setTrabajando(false); + } + + async function deshacer() { + setTrabajando(true); + setError(""); + const r = hecho.accion === "editar" ? await deshacerEdicionAction(hecho.accionId) : 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 ahoraMin = localDeIso(new Date().toISOString()).min; // hora de Managua, se recalcula en cada pintado + const hoyBloques = det?.hoyAgenda?.bloques || []; + 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 horaPasada = !esTarea && !!hora && dia === hoy && (horaAMin(hora) ?? 9999) < ahoraMin; + 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. + // Seguimiento (solo si la actividad está ligada a una oportunidad): válido si tiene objetivo y un día hábil. + const segDiaMalo = segAbierto && !!segDia && !esHabil(segDia); + // Horas del seguimiento: si el día es hoy, solo futuras y sin choques con lo ya agendado; la elegida se ajusta sola. + const horasSeg = hoy ? horasLibres({ tipo: segTipo, dia: segDia, hoy, ahoraMin, bloques: hoyBloques }) : []; + const horaSeg = horasSeg.includes(segHora) ? segHora : horasSeg[0] || ""; + const segSinHoras = segTipo !== "Tarea" && !!segDia && horasSeg.length === 0; + const segListo = segAbierto && !!segObj && !!segDia && !segDiaMalo && !segSinHoras; + const quiereSeg = segAbierto && !!det?.tieneOpp && segListo; + const textoAccion = { completar: segAbierto && det?.tieneOpp ? "Guardar, completar y programar seguimiento" : "Guardar y completar", reprogramar: "Guardar nueva fecha", cancelar: "Cancelar actividad", editar: "Guardar cambios" }[accion]; + + async function guardarSeguimiento() { + setSegTrab(true); + setSegError(""); + const r = await crearSeguimientoAction({ tipo: a.tipo, id: a.id, nuevoTipo: segTipo, objetivo: segObj, dia: segDia, hora: segTipo === "Tarea" ? "" : horaSeg }); + setSegTrab(false); + if (!r.ok) { + setSegError(r.error); + return; + } + huboCambio.current = true; + setSeg(r); + } + const cambiarSegTipo = (t) => { + setSegTipo(t); + const hs = horasLibres({ tipo: t, dia: segDia, hoy, ahoraMin, bloques: hoyBloques }); + if (t !== "Tarea" && !hs.includes(segHora)) setSegHora(hs.includes("09:00") ? "09:00" : hs[0] || ""); + }; + 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; + // «Hoy, más tarde»: solo si hoy es hábil y todavía queda lugar (llamada/visita: alguna hora libre; tarea: antes de su vencimiento). + const hoyHabil = !!hoy && esHabil(hoy); + const hoyCupo = hoyHabil && (segTipo === "Tarea" ? ahoraMin < AGENDADOR.horaTarea : horasLibres({ tipo: segTipo, dia: hoy, hoy, ahoraMin, bloques: hoyBloques }).length > 0) + && (det?.hoyAgenda?.cuenta?.[segTipo] ?? 0) < AGENDADOR.topes[segTipo]; + const TXT_SIN_OPP = "No se ofrece programar un seguimiento desde aquí: esta actividad no está ligada a una oportunidad (su «Referente a» es una cuenta o un caso). Puedes agendarlo desde el Agendador o en Dynamics."; + + // Campos del seguimiento: se usan antes de completar (un solo botón) y después (para reintentar o añadirlo). + const camposSeguimiento = () => ( + <> +
    Siguiente actividad
    +
    + {["Llamada", "Cita", "Tarea"].map((t) => ( + + ))} +
    +
    Objetivo
    +
    + +
    +
    Fecha (lunes a viernes)
    +
    + {hoyHabil && ( + + )} + {[["Mañana", addDays(hoy, 1)], ["En 2 días", addDays(hoy, 2)], ["En 3 días", addDays(hoy, 3)], ["Lunes", proximoLunes(hoy)]].map(([l, v]) => ( + + ))} + setSegDia(e.target.value)} /> +
    + {segDiaMalo &&

    Elige un día hábil: el seguimiento no se agenda en sábado ni en domingo.

    } + {segTipo !== "Tarea" && ( + <> +
    Hora
    +
    + +
    + + )} + {segSinHoras && !segDiaMalo &&

    {segDia === hoy ? "Ya no quedan horas libres hoy para esto. Elige otro día." : "No hay horas disponibles ese día."}

    } + {segDia && !segDiaMalo && !segSinHoras &&

    Se agenda: {segTipo === "Cita" ? "Visita" : segTipo} · {etiqueta(segDia)}{segTipo !== "Tarea" ? ` · ${horaSeg}` : " (vence a las 16:00)"}

    } + {segError &&

    {segError}

    } + + ); + + 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 ↗

    + ) : ( + <> +
    +
    Ya registrado
    +
    Objetivo: {det.objetivo || "—"}{a.tipo !== "Tarea" && <> · Participantes: {det.participantes?.length ? nombresDe(det.participantes) : "ninguno marcado"}{det.invitados > 0 ? ` · ${det.invitados} invitado${det.invitados === 1 ? "" : "s"}` : ""}}
    + {a.tipo === "Cita" && det.lugar &&
    Lugar: {det.lugar}
    } +
    {det.nota ? <>{a.tipo === "Cita" ? "Resultado" : "Nota"}: {det.nota} : Sin nota registrada.}
    +
    +
    + {[["completar", "✓ Completar"], ["editar", "✎ Editar"], ["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.filter((h) => dia !== hoy || horaAMin(h) >= ahoraMin + 5).map((h) => ( + + ))} + setHora(e.target.value)} /> +
    + + )} + {horaPasada &&

    Esa hora ya pasó. Elige una hora más tarde o cambia el día.

    } + {dia &&

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

    } +
    + )} + + {accion === "editar" && ( +
    +
    Objetivo
    +
    + +
    + {a.tipo !== "Tarea" && !conInvitados && ( + <> +
    Duración
    +
    + {(a.tipo === "Cita" ? [30, 60, 90, 120] : [10, 15, 30, 45, 60]).map((m) => ( + + ))} +
    + + )} + {a.tipo === "Cita" && conInvitados &&

    Esta visita tiene invitados: su duración se cambia en Dynamics para no enviarles avisos por error.

    } + {a.tipo !== "Tarea" ? ( + <> +
    ¿Quién participará?
    +
    + {ROLES.map((r) => ( + + ))} +
    +

    Se guarda en la {a.tipo === "Cita" ? "visita" : "llamada"}. La oportunidad se actualiza cuando la completes.

    + + ) : ( +

    Las tareas no llevan participantes.

    + )} +
    Agregar una nota (se suma arriba de lo anterior)
    +