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

301 lines
16 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.

"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>
);
}