informe-comercial-alfa/app/components/plan/AgendadorPanel.js

302 lines
16 KiB
JavaScript
Raw Normal View History

"use client";
import { useMemo, useState, useTransition } from "react";
import { useRouter } from "next/navigation";
import { money, actividadUrl } from "../../lib/constants";
import { diaCorto } from "../../lib/plan";
import {
AGENDADOR, TIPOS_AGENDADOR, OBJETIVOS_AGENDADOR, proponer, validar, horasDe, minAHora,
} from "../../lib/agendador";
import { crearLoteAction, deshacerLoteAction } from "../../actividades/agendadorActions";
const NOMBRE_PLURAL = { Llamada: "llamadas", Cita: "visitas", Tarea: "tareas" };
const fechaHora = (iso) =>
new Intl.DateTimeFormat("es-NI", { timeZone: "America/Managua", day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" }).format(new Date(iso));
// Filtros para afinar qué oportunidades se quieren agendar. Vacío = todas.
const FILTROS = [
{ k: "tipo", lbl: "Tipo de oportunidad", valor: (c) => c.tipo || "(sin tipo)" },
{ k: "plan", lbl: "Plan de cierre", valor: (c) => c.plan || "Sin plan de cierre" },
{ k: "forecast", lbl: "Categoría de previsión", valor: (c) => c.forecast || "Sin categoría" },
];
const pctDe = (s) => parseInt(s, 10) || 0;
// Menú de filtro con casillas (varias opciones a la vez).
function Filtro({ lbl, opciones, sel, onChange, deshabilitado }) {
const resumen = sel.length === 0 ? "Todos" : sel.length === 1 ? sel[0] : `${sel.length} seleccionados`;
const alternar = (v) => onChange(sel.includes(v) ? sel.filter((x) => x !== v) : [...sel, v]);
return (
<details className="agd-filtro">
<summary><span className="agd-filtro-l">{lbl}:</span> <b>{resumen}</b></summary>
<div className="agd-opts">
{opciones.map(([v, n]) => (
<label key={v}>
<input type="checkbox" checked={sel.includes(v)} disabled={deshabilitado} onChange={() => alternar(v)} /> {v} <span className="agd-n">({n})</span>
</label>
))}
{sel.length > 0 && <button type="button" className="agd-btn-sec" onClick={() => onChange([])}>Quitar filtro</button>}
</div>
</details>
);
}
// Agendador sugerido de la semana (PILOTO). Flujo: 1) filtrar las oportunidades por planificar (tipo,
// plan de cierre, categoría de previsión), 2) «Proponer agenda» reparte las filtradas en la semana con
// su objetivo sugerido, 3) la persona marca las que va a agendar y ajusta día/hora/tipo/objetivo,
// 4) «Crear en Dynamics» las crea de una vez con el propietario de la oportunidad. Nada se escribe
// antes de ese botón. Diseño: agendador-automatico-diseno.md.
export default function AgendadorPanel({ ownerEmail, ownerName, periodo, dias, hoy, ahoraMin, candidatos, existentes, bloques, lotes }) {
const router = useRouter();
const [pendiente, empezar] = useTransition();
const base = { dias, existentes, bloques, hoy, ahoraMin };
const [tipoTodas, setTipoTodas] = useState("Llamada");
const [filtros, setFiltros] = useState({ tipo: [], plan: [], forecast: [] });
const [items, setItems] = useState([]);
const [propuesto, setPropuesto] = useState(false);
const [resultado, setResultado] = useState(null);
const [aviso, setAviso] = useState(null);
const yaCreadas = new Set(items.filter((i) => i.creada).map((i) => i.oppId));
const coinciden = useMemo(
() => candidatos.filter((c) => FILTROS.every((f) => !filtros[f.k].length || filtros[f.k].includes(f.valor(c)))),
[candidatos, filtros]
);
const opciones = useMemo(() => {
const out = {};
for (const f of FILTROS) {
const m = new Map();
candidatos.forEach((c) => m.set(f.valor(c), (m.get(f.valor(c)) || 0) + 1));
out[f.k] = [...m.entries()].sort((a, b) => (f.k === "forecast" ? pctDe(b[0]) - pctDe(a[0]) : 0) || b[1] - a[1] || a[0].localeCompare(b[0], "es"));
}
return out;
}, [candidatos]);
const incluidos = items.filter((i) => i.incluir && !i.creada);
const val = useMemo(() => validar({ items: incluidos, ...base }), [items, dias, existentes, bloques, hoy, ahoraMin]); // eslint-disable-line react-hooks/exhaustive-deps
const cambiar = (key, cambios) => setItems((prev) => prev.map((i) => (i.key === key ? { ...i, ...cambios } : i)));
// «Proponer agenda»: reparte las oportunidades que coinciden con los filtros (menos las ya creadas).
// Las propuestas quedan SIN marcar: la persona elige cuáles agendar.
const proponerAgenda = (tipo = tipoTodas) => {
const nuevos = proponer({ candidatos: coinciden.filter((c) => !yaCreadas.has(c.id)), ...base, tipo }).map((i) => ({ ...i, incluir: false }));
setItems([...items.filter((i) => i.creada), ...nuevos]);
setPropuesto(true);
setResultado(null);
setAviso(null);
};
const marcarTodas = (marcar) => setItems((prev) => prev.map((i) => (i.creada ? i : { ...i, incluir: marcar && !!i.dia })));
const cambiarTipo = (it, tipo) => {
const horas = horasDe(tipo).map(minAHora);
const hora = tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : horas.includes(it.hora) ? it.hora : horas[0];
cambiar(it.key, { tipo, hora });
};
const cambiarDia = (it, dia) => {
const horas = horasDe(it.tipo).map(minAHora);
const hora = it.tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : it.hora && horas.includes(it.hora) ? it.hora : horas[0] || "";
cambiar(it.key, { dia: dia || null, hora: dia ? hora : null, sinCupo: !dia });
};
const crear = () => {
setAviso(null);
if (!incluidos.length || !val.ok) return;
const resumen = TIPOS_AGENDADOR.map((t) => [t, incluidos.filter((i) => i.tipo === t).length]).filter(([, n]) => n).map(([t, n]) => `${n} ${NOMBRE_PLURAL[t]}`).join(", ");
if (!window.confirm(`Se crearán en Dynamics ${incluidos.length} actividades (${resumen}) para ${ownerName}, a su nombre. ¿Continuar?`)) return;
empezar(async () => {
const r = await crearLoteAction({
ownerEmail,
periodo,
items: incluidos.map((i) => ({ oppId: i.oppId, nombre: i.nombre, cliente: i.cliente, tipo: i.tipo, objetivo: i.objetivo, dia: i.dia, hora: i.hora })),
});
if (!r.ok) { setAviso({ mal: true, texto: r.error }); return; }
const creadas = new Map(r.resultados.filter((x) => x.estado === "creada").map((x) => [x.oppId, x]));
setItems((prev) => prev.map((i) => (creadas.has(i.oppId) ? { ...i, creada: creadas.get(i.oppId) } : i)));
setResultado(r);
router.refresh();
});
};
const deshacer = (id) => {
if (!window.confirm("Se cancelarán en Dynamics las actividades de esa tanda que sigan abiertas. ¿Deshacer?")) return;
empezar(async () => {
const r = await deshacerLoteAction(id);
setAviso(r.ok ? { texto: `Tanda deshecha: ${r.canceladas} cancelada(s)${r.yaCerradas ? `, ${r.yaCerradas} ya estaban cerradas` : ""}${r.errores ? `, ${r.errores} con error` : ""}.` } : { mal: true, texto: r.error });
router.refresh();
});
};
const hayCitas = incluidos.some((i) => i.tipo === "Cita");
const sinCupo = items.filter((i) => i.sinCupo && !i.dia && !i.creada).length;
return (
<section className="panel plan-agd no-print">
<h3>Agendador de la semana — {ownerName} <span className="agd-piloto">piloto</span></h3>
<p className="hint">
<b>1.</b> Filtra las oportunidades por planificar · <b>2.</b> pulsa «Proponer agenda» · <b>3.</b> marca las que vas a agendar y ajusta día, hora, tipo u objetivo · <b>4.</b> pulsa «Crear en Dynamics».
Horario de lunes a viernes entre 9:00–12:00 y 14:00–16:00; máximo por día: {AGENDADOR.topes.Llamada} llamadas, {AGENDADOR.topes.Cita} visitas, {AGENDADOR.topes.Tarea} tareas.
No se crea nada en Dynamics hasta el paso 4, y las actividades quedan a nombre del propietario de la oportunidad.
</p>
{candidatos.length === 0 ? (
<p>No hay oportunidades por planificar esta semana: todas tienen alguna actividad.</p>
) : (
<>
<div className="agd-filtros">
{FILTROS.map((f) => (
<Filtro key={f.k} lbl={f.lbl} opciones={opciones[f.k]} sel={filtros[f.k]} onChange={(v) => setFiltros((p) => ({ ...p, [f.k]: v }))} deshabilitado={pendiente} />
))}
</div>
<div className="agd-barra">
<label htmlFor="agd-tipo">Tipo de actividad:</label>
<select id="agd-tipo" value={tipoTodas} onChange={(e) => setTipoTodas(e.target.value)} disabled={pendiente}>
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
<button type="button" className="agd-btn" onClick={() => proponerAgenda()} disabled={pendiente || coinciden.length === 0}>
{propuesto ? "Volver a proponer agenda" : "Proponer agenda"}
</button>
<span className="hint">
{coinciden.length} de {candidatos.length} oportunidad{candidatos.length === 1 ? "" : "es"} coinciden con los filtros
{propuesto && " · cambia filtros o tipo y vuelve a proponer (lo ya creado se conserva)"}
</span>
</div>
{propuesto && (
<>
<div className="agd-dias">
{dias.map((d) => {
const c = val.porDia[d] || { Llamada: 0, Cita: 0, Tarea: 0, ...(existentes[d] || {}) };
const exc = TIPOS_AGENDADOR.some((t) => c[t] > AGENDADOR.topes[t]);
return (
<span key={d} className={`agd-dia${exc ? " mal" : ""}`} title="Lo que ya tiene agendado ese día más lo que marcaste">
<b>{diaCorto(d)}</b> {c.Llamada} llam. · {c.Cita} vis. · {c.Tarea} tar.
</span>
);
})}
</div>
<div className="agd-barra">
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(true)} disabled={pendiente}>Marcar todas las propuestas</button>
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(false)} disabled={pendiente}>Desmarcar todas</button>
<span className="hint">
{incluidos.length} marcada{incluidos.length === 1 ? "" : "s"} para crear
{sinCupo > 0 && ` · ${sinCupo} sin cupo esta semana con estos máximos (puedes elegirles un día a mano)`}
</span>
</div>
<div className="ts" style={{ maxHeight: 520, overflowY: "auto" }}>
<table>
<thead>
<tr>
<th></th>
<th>Cliente / oportunidad</th>
<th className="num">Valor</th>
<th>Tipo</th>
<th>Día</th>
<th>Hora</th>
<th>Objetivo</th>
<th>Avisos</th>
</tr>
</thead>
<tbody>
{items.map((it) => {
const probs = val.porItem[it.key] || [];
const horas = horasDe(it.tipo).map(minAHora);
return (
<tr key={it.key} style={it.creada ? { opacity: 0.6 } : undefined}>
<td>
<input type="checkbox" checked={!!it.incluir && !it.creada} disabled={!!it.creada || pendiente} onChange={(e) => cambiar(it.key, { incluir: e.target.checked })} aria-label="Agendar esta oportunidad" />
</td>
<td>
<strong>{it.cliente || it.nombre}</strong>
{it.cliente && <div style={{ fontSize: 11, color: "var(--tinta-suave)" }}>{it.nombre}</div>}
</td>
<td className="num">{money(it.valor)}{it.pct ? <div style={{ fontSize: 11, color: "var(--tinta-suave)" }}>{it.pct}%</div> : null}</td>
<td>
<select value={it.tipo} disabled={!!it.creada || pendiente} onChange={(e) => cambiarTipo(it, e.target.value)}>
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
</td>
<td>
<select value={it.dia || ""} disabled={!!it.creada || pendiente} onChange={(e) => cambiarDia(it, e.target.value)}>
<option value="">— elegir —</option>
{dias.map((d) => <option key={d} value={d}>{diaCorto(d)}</option>)}
</select>
</td>
<td>
{it.tipo === "Tarea" ? (
<span title="Las tareas vencen a las 16:00">vence {minAHora(AGENDADOR.horaTarea)}</span>
) : (
<select value={it.hora || ""} disabled={!!it.creada || pendiente || !it.dia} onChange={(e) => cambiar(it.key, { hora: e.target.value })}>
<option value="">—</option>
{horas.map((h) => <option key={h} value={h}>{h}</option>)}
</select>
)}
</td>
<td>
<select value={it.objetivo} disabled={!!it.creada || pendiente} onChange={(e) => cambiar(it.key, { objetivo: e.target.value })}>
<option value="">— elegir —</option>
{OBJETIVOS_AGENDADOR.map((o) => <option key={o} value={o}>{o}</option>)}
</select>
</td>
<td>
{it.creada ? (
<a className="agd-ok" href={actividadUrl({ tipo: it.creada.tipo, id: it.creada.activityId })} target="_blank" rel="noreferrer">✓ Creada · abrir en CRM</a>
) : it.sinCupo && !it.dia ? (
<span className="agd-mal">Sin cupo esta semana: elige un día para agendarla.</span>
) : it.incluir && probs.length ? (
<span className="agd-mal">{probs.join(" ")}</span>
) : it.tipo === "Cita" && it.incluir ? (
<span className="hint">Se crea genérica: completa lugar y participantes en el CRM.</span>
) : null}
</td>
</tr>
);
})}
</tbody>
</table>
</div>
<div className="agd-pie">
<button type="button" className="agd-btn" disabled={pendiente || !incluidos.length || !val.ok} onClick={crear}>
{pendiente ? "Trabajando…" : `Crear ${incluidos.length} actividad${incluidos.length === 1 ? "" : "es"} en Dynamics`}
</button>
{!val.ok && incluidos.length > 0 && <span className="agd-mal">Corrige los avisos en rojo para poder crear.</span>}
{incluidos.length === 0 && <span className="hint">Marca al menos una oportunidad para poder crear.</span>}
</div>
{hayCitas && (
<p className="hint">Las visitas se crean con lo básico (fecha, hora, objetivo, oportunidad). Después de crearlas, abre cada una con «abrir en CRM» para agregar el lugar y los participantes.</p>
)}
</>
)}
</>
)}
{aviso && <p className={aviso.mal ? "agd-mal" : "agd-ok"} role="status">{aviso.texto}</p>}
{resultado && (
<div className="agd-res">
<strong>Tanda #{resultado.loteId}:</strong> {resultado.creadas} creada(s){resultado.errores ? `, ${resultado.errores} con error` : ""}{resultado.omitidas ? `, ${resultado.omitidas} omitida(s)` : ""}.
{resultado.resultados.filter((x) => x.estado !== "creada").map((x) => (
<div key={x.oppId} className="agd-mal">{x.nombre || x.oppId}: {x.error}</div>
))}
</div>
)}
{lotes.length > 0 && (
<details className="agd-lotes">
<summary>Tandas creadas esta semana ({lotes.length})</summary>
<ul>
{lotes.map((l) => (
<li key={l.id}>
#{l.id} · {fechaHora(l.creado_en)} · {l.creado_por} · {l.items.filter((x) => x.estado === "creada").length} actividad(es)
{l.deshecho_en ? <span> — deshecha {fechaHora(l.deshecho_en)}</span> : (
<button type="button" className="agd-btn-sec" disabled={pendiente} onClick={() => deshacer(l.id)} style={{ marginLeft: 8 }}>Deshacer</button>
)}
</li>
))}
</ul>
</details>
)}
</section>
);
}