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

282 lines
12 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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 (
<div className="pa-franja">
{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 = (
<>
<span className="t">{diaSemana(d)} {Number(d.slice(8, 10))}</span>
<span className="s">{texto}</span>
</>
);
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 (
<Link key={d} href={href} className={cls} title="Abrir el Plan del Día de este día">
{contenido}
</Link>
);
})}
</div>
);
}
// 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 (
<div className="pa-franja">
{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 (
<div key={l} className={`pa-dia${actual ? " hoy" : ""}${futura ? " futuro" : ""}${total === 0 ? " hueco" : ""}`}>
<span className="t">{fechaCorta(dias[0])} – {fechaCorta(dias[dias.length - 1])}</span>
<span className="s">
{total === 0 ? "sin actividades" : futura ? `${total} agendadas` : `${hechas} de ${total} completadas`}
</span>
{total > 0 && sinAct > 0 && <span className="s mal">{sinAct} día{sinAct === 1 ? "" : "s"} sin actividad</span>}
</div>
);
})}
</div>
);
}
// 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 <LoginPrompt />;
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 <ErrorNotice error={error} />;
}
// 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 (
<div className="plan-act" style={{ padding: 24 }}>
<div className="no-print" style={{ display: "flex", justifyContent: "space-between", alignItems: "center", flexWrap: "wrap", gap: 12 }}>
<h2>Plan de Actividades</h2>
<div style={{ display: "flex", gap: 14, alignItems: "center", flexWrap: "wrap" }}>
<OwnerControl owners={owners} current={scope.locked ? [session.email] : scope.emails} locked={scope.locked} lockedLabel={session.email} />
</div>
</div>
<Suspense fallback={null}>
<div style={{ margin: "12px 0 16px" }}>
<PeriodoControles
periodos={PERIODOS_ACT}
periodo={periodo}
defecto="semana"
tituloPdf={`Plan de actividades – ${quien} – ${etiquetaPeriodo} ${desde}`}
/>
</div>
</Suspense>
{verVarios && session.isAdmin && (
<p className="no-print pa-equipo-link">
<Link href={hrefEquipo(periodo)}>Ver el resumen por ejecutivo en Equipo →</Link>
</p>
)}
<div className="plan-doc plan-detalle">
<h1 className="plan-titulo">PLAN DE ACTIVIDADES</h1>
<div className="plan-meta">
<span><strong>Período:</strong> {etiqueta}</span>
<span><strong>Ejecutivo:</strong> {quien}</span>
</div>
<PlanTarjetasPeriodo
actTotal={actTotalPeriodo}
tipos={tiposPeriodo}
mrr={mrrPeriodo}
actsGC={actsDelPlan}
hrefGC={hrefGC}
filtradoGC={soloGC}
r={r}
hrefVenc={hrefVenc}
filtradoVenc={soloVenc}
/>
<Franja rango={rango} plan={planCompleto} hoy={hoy} owner={sp.owner} />
{/* Pantalla: una sola tabla cronológica agrupada por día (una fila por actividad). */}
<AgendaCronologica
items={items}
agruparPor="dia"
colEjecutivo={conEjecutivo}
modo="periodo"
ahora={{ dia: hoy, min: ahoraMin }}
hoy={hoy}
/>
{/* PDF: sigue por objetivo, igual que siempre (en pantalla va oculto). */}
<div className="vista-impresion">
<BarraSecciones casillas={casillas} />
{plan.secciones.map((s) => (
<PlanSeccionPeriodo key={s.key} seccion={s} conEjecutivo={conEjecutivo} hoy={hoy} />
))}
</div>
</div>
{puedeAgendar && (
<section className="panel plan-agd no-print">
<div className="agd-ayuda">
<p>
<b>Agendador de actividades:</b> ahora es un módulo aparte, con calendario de hasta 30 días, buscador y prioridad sugerida.{" "}
<Link href={`/agendador?owner=${ownerAgenda}`}>Abrir el agendador de {quien} →</Link>
</p>
</div>
</section>
)}
{esActualOFuturo && (
<SinActividadPanel
filas={sinActividad}
titulo="Oportunidades por planificar: cierre estimado en el período y sin actividad agendada"
hint={`Cierre entre el ${fechaCorta(desde)} y el ${fechaCorta(hasta)} · cuenta cualquier actividad del período, pendiente o completada · solo en pantalla`}
vacio="Todas las oportunidades con cierre en este período tienen al menos una actividad agendada."
/>
)}
</div>
);
}