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

566 lines
35 KiB
JavaScript
Raw Permalink 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 { Fragment, useEffect, 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, NIVELES_PRIO, proponer, validar, horasDe, minAHora, sumarFijos, baseItem, textoHorario,
ventanaDe, fechaMaxima, calcularPrioridades,
} from "../../lib/agendador";
import { crearLoteAction, deshacerLoteAction } from "../../agendador/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));
const fechaLarga = (iso) => { const [y, m, d] = iso.split("-"); return `${d}/${m}/${y.slice(2)}`; };
const fechaCorta = (iso) => iso.split("-").reverse().slice(0, 2).join("/");
const sinAcentos = (t) => String(t || "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
const pctDe = (s) => parseInt(s, 10) || 0;
// Filtros para afinar qué oportunidades se quieren agendar. Dentro de un filtro, las opciones suman
// (o); entre filtros se combinan (y). Vacío = todas. NINGÚN filtro de menú viene activado de entrada (el ejecutivo ve
// todas sus oportunidades abiertas, 2026-11-06); desde 2026-11-11 sí viene activado «Ocultar las que ya tienen actividad».
// `visible`: a la vista en la franja; el resto queda bajo «Más filtros».
// «Cierre estimado» se mide contra los días de agendado (ventana).
const ORDEN_CIERRE = ["Vencida (antes de esos días)", "En esos días", "Resto del mes", "Mes siguiente", "Más adelante", "Sin fecha"];
const finDeMes = (iso, sumar = 0) => {
const [y, m] = iso.split("-").map(Number);
return new Date(Date.UTC(y, m + sumar, 0)).toISOString().slice(0, 10);
};
function bucketCierre(c, v) {
const d = c.cierre;
if (!d) return ORDEN_CIERRE[5];
if (d < v.desde) return ORDEN_CIERRE[0];
if (d <= v.hasta) return ORDEN_CIERRE[1];
if (d <= finDeMes(v.desde)) return ORDEN_CIERRE[2];
if (d <= finDeMes(v.desde, 1)) return ORDEN_CIERRE[3];
return ORDEN_CIERRE[4];
}
const FILTROS = [
{ k: "tipo", lbl: "Tipo de oportunidad", visible: true, valor: (c) => c.tipo || "(sin tipo)" },
{ k: "prio", lbl: "Prioridad", visible: true, valor: (c) => c.prioNivel, orden: NIVELES_PRIO },
{ 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" },
{ k: "cierre", lbl: "Cierre", visible: true, valor: (c, v) => bucketCierre(c, v), orden: ORDEN_CIERRE },
];
const SIN_FILTROS = { prio: [], tipo: [], plan: [], forecast: [], cierre: [] };
const pasa = (c, filtros, v, salvo) => FILTROS.every((f) => f.k === salvo || !filtros[f.k].length || filtros[f.k].includes(f.valor(c, v)));
// Orden de la tabla. Por defecto, VALOR de mayor a menor (2026-11-06); los encabezados con ▲▼ cambian el orden.
const ORDENES = {
valor: (x, y) => (y.valor || 0) - (x.valor || 0),
prio: (x, y) => (x.prioRank ?? 9) - (y.prioRank ?? 9) || (y.valor || 0) - (x.valor || 0),
cliente: (x, y) => String(x.cliente || x.nombre || "").localeCompare(String(y.cliente || y.nombre || ""), "es"),
cierre: (x, y) => (x.cierre || "9999-12-31").localeCompare(y.cierre || "9999-12-31"),
forecast: (x, y) => (y.pct || 0) - (x.pct || 0),
};
const ORDEN_INICIAL = { k: "valor", dir: 1 };
// Agendador de actividades (PILOTO). Página propia: trae TODAS las oportunidades abiertas del ejecutivo;
// se elige desde qué fecha agendar (hasta 30 días) y se reparte en 5 días hábiles a partir de ahí. La
// persona marca las que va a agendar y ajusta día/hora/tipo/objetivo; lo marcado o editado a mano queda
// FIJO y el resto se acomoda alrededor. «Crear en Dynamics» las crea con el propietario de la
// oportunidad; nada se escribe antes. Diseño: agendador-automatico-diseno.md.
export default function AgendadorPanel({ fechaInicial, ownerEmail, ownerName, hoy, ahoraMin, candidatos, actPorOpp, existentes, bloques, lotes }) {
const router = useRouter();
const [pendiente, empezar] = useTransition();
const maxFecha = fechaMaxima(hoy);
const [fecha, setFecha] = useState(fechaInicial || hoy);
const dias = useMemo(() => ventanaDe(fecha, hoy), [fecha, hoy]);
const ventana = useMemo(() => ({ desde: dias[0] || hoy, hasta: dias[dias.length - 1] || hoy }), [dias, hoy]);
const base = { dias, existentes, bloques, hoy, ahoraMin };
const [tipoTodas, setTipoTodas] = useState("Llamada");
const [filtros, setFiltros] = useState(SIN_FILTROS);
const [busqueda, setBusqueda] = useState("");
const [ocultarConAct, setOcultarConAct] = useState(true);
const [masFiltros, setMasFiltros] = useState(false);
const [orden, setOrden] = useState(ORDEN_INICIAL);
const [abierto, setAbierto] = useState(null); // filtro con el menú desplegado
// Lo que la persona decidió a mano, por oportunidad: { tipo, dia, hora, objetivo, incluir, tocada }.
const [edits, setEdits] = useState({});
const [creadas, setCreadas] = useState([]); // filas ya creadas en esta sesión (con su creada)
const [resultado, setResultado] = useState(null);
const [aviso, setAviso] = useState(null);
// Cierra el menú al hacer clic fuera o con Escape.
useEffect(() => {
if (!abierto) return;
const fuera = (e) => { if (!(e.target instanceof Element) || !e.target.closest(".agd-filtro")) setAbierto(null); };
const tecla = (e) => { if (e.key === "Escape") setAbierto(null); };
document.addEventListener("mousedown", fuera);
document.addEventListener("keydown", tecla);
return () => { document.removeEventListener("mousedown", fuera); document.removeEventListener("keydown", tecla); };
}, [abierto]);
// Prioridad sugerida de cada oportunidad (sobre la cartera completa del ejecutivo).
const conPrio = useMemo(() => {
const m = calcularPrioridades(candidatos, hoy);
return candidatos.map((c) => ({ ...c, ...m.get(c.id) }));
}, [candidatos, hoy]);
// ¿Ya tiene una actividad agendada (no cancelada) en los días que se planifican?
const conActividad = (c) => (actPorOpp[c.id] || []).some((d) => d >= ventana.desde && d <= ventana.hasta);
const fechaActividad = (c) => (actPorOpp[c.id] || []).filter((d) => d >= ventana.desde && d <= ventana.hasta).sort()[0];
const idsCreadas = useMemo(() => new Set(creadas.map((c) => c.oppId)), [creadas]);
const disponibles = useMemo(() => conPrio.filter((c) => !idsCreadas.has(c.id)), [conPrio, idsCreadas]);
const q = sinAcentos(busqueda.trim());
// Lo que pasa búsqueda y «ocultar» (antes de los filtros de menú).
const baseVisible = useMemo(
() => disponibles.filter((c) => (!q || sinAcentos(`${c.cliente || ""} ${c.nombre || ""}`).includes(q)) && !(ocultarConAct && conActividad(c))),
[disponibles, q, ocultarConAct, ventana, actPorOpp] // eslint-disable-line react-hooks/exhaustive-deps
);
const coinciden = useMemo(() => baseVisible.filter((c) => pasa(c, filtros, ventana)), [baseVisible, filtros, ventana]);
const marcadasIds = Object.keys(edits).filter((k) => edits[k].incluir);
// Opciones de cada filtro con su conteo FRENTE A LOS OTROS filtros (las que quedarían en 0 se ven en gris).
const opciones = useMemo(() => {
const out = {};
for (const f of FILTROS) {
const total = new Map();
conPrio.forEach((c) => total.set(f.valor(c, ventana), (total.get(f.valor(c, ventana)) || 0) + 1));
const visibles = new Map();
baseVisible.filter((c) => pasa(c, filtros, ventana, f.k)).forEach((c) => visibles.set(f.valor(c, ventana), (visibles.get(f.valor(c, ventana)) || 0) + 1));
out[f.k] = [...total.entries()]
.sort((a, b) =>
f.orden ? f.orden.indexOf(a[0]) - f.orden.indexOf(b[0])
: (f.k === "forecast" ? pctDe(b[0]) - pctDe(a[0]) : 0) || b[1] - a[1] || a[0].localeCompare(b[0], "es"))
.map(([v]) => [v, visibles.get(v) || 0]);
}
return out;
}, [conPrio, baseVisible, filtros, ventana]);
// Filas visibles = las que coinciden + las marcadas que el filtro/búsqueda dejó fuera.
const filas = useMemo(() => {
const porId = new Map(conPrio.map((c) => [c.id, c]));
const marcadasFuera = marcadasIds.filter((id) => porId.has(id) && !coinciden.some((c) => c.id === id)).map((id) => porId.get(id));
const visibles = [...coinciden, ...marcadasFuera];
// Filas sin decisión a mano: se acomodan alrededor de las marcadas (que quedan fijas). Las que ya
// tienen actividad en esos días no se proponen.
const fijas = marcadasIds.map((id) => ({ ...edits[id] }));
const { existentes: ex, bloques: bl } = sumarFijos(existentes, bloques, fijas);
const auto = proponer({ candidatos: visibles.filter((c) => !edits[c.id] && !conActividad(c)), ...base, existentes: ex, bloques: bl, tipo: tipoTodas });
const autoPorId = new Map(auto.map((i) => [i.oppId, { ...i, incluir: false }]));
const filasV = visibles.map((c) => {
const e = edits[c.id];
if (!e) {
if (conActividad(c)) return { ...baseItem(c, tipoTodas), dia: null, hora: null, sinCupo: false, incluir: false, conActividad: fechaActividad(c) };
return autoPorId.get(c.id);
}
return { ...baseItem(c, e.tipo), tipo: e.tipo, dia: e.dia, hora: e.hora, objetivo: e.objetivo, gv: !!e.gv && e.tipo !== "Tarea", incluir: !!e.incluir, sinCupo: !e.dia, tocada: !!e.tocada, fueraDelFiltro: !coinciden.some((x) => x.id === c.id) };
});
const cmp = ORDENES[orden.k];
return filasV.sort((x, y) => orden.dir * cmp(x, y) || ORDENES.valor(x, y));
}, [conPrio, coinciden, edits, tipoTodas, dias, existentes, bloques, hoy, ahoraMin, orden, actPorOpp]); // eslint-disable-line react-hooks/exhaustive-deps
const marcadas = filas.filter((f) => f.incluir);
const val = useMemo(() => validar({ items: marcadas, ...base }), [filas, dias, existentes, bloques, hoy, ahoraMin]); // eslint-disable-line react-hooks/exhaustive-deps
const congelar = (f, extra = {}) => ({ tipo: f.tipo, dia: f.dia, hora: f.hora, objetivo: f.objetivo, gv: !!f.gv, incluir: !!f.incluir, tocada: !!f.tocada, ...extra });
const editar = (f, cambios) => setEdits((p) => ({ ...p, [f.key]: congelar(f, { ...cambios, tocada: true }) }));
const marcar = (f, valor) =>
setEdits((p) => {
const n = { ...p };
if (valor) n[f.key] = congelar(f, { incluir: true });
else if (f.tocada) n[f.key] = congelar(f, { incluir: false });
else delete n[f.key];
return n;
});
const marcarTodas = (valor) =>
setEdits((p) => {
const n = { ...p };
filas.forEach((f) => {
if (valor) { if (f.dia && !f.conActividad) n[f.key] = congelar(f, { incluir: true }); }
else if (f.incluir) { if (f.tocada) n[f.key] = congelar(f, { incluir: false }); else delete n[f.key]; }
});
return n;
});
// «Marcar GV en las seleccionadas»: solo llamadas y visitas (las tareas no llevan GV).
const marcarGV = () =>
setEdits((p) => Object.fromEntries(Object.entries(p).map(([k, e]) => [k, e.incluir && e.tipo !== "Tarea" ? { ...e, gv: true } : e])));
const restablecer = () => setEdits((p) => Object.fromEntries(Object.entries(p).filter(([, e]) => e.incluir)));
const cambiarTipo = (f, tipo) => {
const horas = horasDe(tipo).map(minAHora);
const hora = tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : horas.includes(f.hora) ? f.hora : horas[0];
editar(f, { tipo, hora: f.dia ? hora : null, gv: tipo === "Tarea" ? false : f.gv });
};
const cambiarDia = (f, dia) => {
const horas = horasDe(f.tipo).map(minAHora);
const hora = f.tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : f.hora && horas.includes(f.hora) ? f.hora : horas[0] || "";
editar(f, { dia: dia || null, hora: dia ? hora : null });
};
// Cambiar la fecha cambia los días de agendado: lo marcado se descarta (sus días ya no valdrían).
const cambiarFecha = (nueva) => {
if (!nueva) return;
const f = nueva < hoy ? hoy : nueva > maxFecha ? maxFecha : nueva;
if (f === fecha) return;
if (marcadasIds.length && !window.confirm("Al cambiar la fecha se desmarcan las oportunidades que habías marcado. ¿Continuar?")) return;
setEdits({});
setFecha(f);
};
const ordenarPor = (k) => setOrden((o) => (o.k === k ? { k, dir: -o.dir } : { k, dir: k === "valor" || k === "forecast" ? 1 : 1 }));
const flecha = (k) => (orden.k === k ? (orden.dir === 1 ? " ▼" : " ▲") : "");
const crear = () => {
setAviso(null);
if (!marcadas.length || !val.ok) return;
const resumen = TIPOS_AGENDADOR.map((t) => [t, marcadas.filter((i) => i.tipo === t).length]).filter(([, n]) => n).map(([t, n]) => `${n} ${NOMBRE_PLURAL[t]}`).join(", ");
const nGV = marcadas.filter((i) => i.gv).length;
const textoGV = nGV ? ` ${nGV} llevan a Gerencia Comercial (GV): se marca su participación en la oportunidad${marcadas.some((i) => i.gv && i.tipo === "Cita") ? " y las visitas se envían como invitación a Marco" : ""}.` : "";
if (!window.confirm(`Se crearán en Dynamics ${marcadas.length} actividades (${resumen}) para ${ownerName}, a su nombre.${textoGV} ¿Continuar?`)) return;
const enviadas = marcadas;
empezar(async () => {
const r = await crearLoteAction({
ownerEmail,
fecha,
items: enviadas.map((i) => ({ oppId: i.oppId, nombre: i.nombre, cliente: i.cliente, tipo: i.tipo, objetivo: i.objetivo, dia: i.dia, hora: i.hora, gv: !!i.gv })),
});
if (!r.ok) { setAviso({ mal: true, texto: r.error }); return; }
const hechas = new Map(r.resultados.filter((x) => x.estado === "creada").map((x) => [x.oppId, x]));
setCreadas((p) => [...enviadas.filter((f) => hechas.has(f.oppId)).map((f) => ({ ...f, incluir: false, creada: hechas.get(f.oppId) })), ...p]);
setEdits((p) => Object.fromEntries(Object.entries(p).filter(([id]) => !hechas.has(id))));
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.oppRestauradas ? `, ${r.oppRestauradas} oportunidad(es) sin la marca de GV que puso la tanda` : ""}${r.errores ? `, ${r.errores} con error` : ""}.` } : { mal: true, texto: r.error });
router.refresh();
});
};
const hayFiltros = FILTROS.some((f) => filtros[f.k].length);
const hayCitas = marcadas.some((i) => i.tipo === "Cita");
const nGV = marcadas.filter((i) => i.gv).length;
const sinCupo = filas.filter((i) => i.sinCupo && !i.dia).length;
const fueraDeFiltro = filas.filter((f) => f.fueraDelFiltro).length;
const filasTabla = [...creadas, ...filas];
const nMalos = marcadas.filter((i) => (val.porItem[i.key] || []).length).length;
const nExtra = FILTROS.filter((f) => !f.visible).reduce((n, f) => n + filtros[f.k].length, 0);
const quitarTodo = () => { setFiltros(SIN_FILTROS); setBusqueda(""); setOcultarConAct(false); };
const nTipo = (t) => marcadas.filter((i) => i.tipo === t).length;
// Un menú de filtro (botón + lista de opciones con casillas).
const menuFiltro = (f) => {
const sel = filtros[f.k];
const resumen = sel.length === 0 ? "Todos" : sel.length === 1 ? sel[0] : `${sel.length} seleccionados`;
return (
<div key={f.k} className={`agd-filtro${abierto === f.k ? " abierto" : ""}`}>
<button type="button" className="agd-filtro-b agd-filtro-c" aria-expanded={abierto === f.k} onClick={() => setAbierto(abierto === f.k ? null : f.k)}>
<span className="agd-filtro-l">{f.lbl}:</span> <b>{resumen}</b>
</button>
{abierto === f.k && (
<div className="agd-opts" role="menu">
{opciones[f.k].map(([v, n]) => {
const activo = sel.includes(v);
return (
<label key={v} className={n === 0 && !activo ? "agd-opt-0" : ""}>
<input type="checkbox" checked={activo} onChange={() => setFiltros((p) => ({ ...p, [f.k]: activo ? sel.filter((x) => x !== v) : [...sel, v] }))} /> {v} <span className="agd-n">({n})</span>
</label>
);
})}
{sel.length > 0 && <button type="button" className="agd-btn-sec" onClick={() => setFiltros((p) => ({ ...p, [f.k]: [] }))}>Quitar este filtro</button>}
</div>
)}
</div>
);
};
// Aviso en línea bajo la fila: solo si hay algo que decir.
const avisoDe = (it, probs) => {
if (it.creada) {
return (
<span className="agd-ok">
✓ Creada{it.creada.gv ? " con GV" : ""} ·{" "}
<a href={actividadUrl({ tipo: it.creada.tipo, id: it.creada.activityId })} target="_blank" rel="noreferrer">abrir en CRM</a>
{it.creada.avisoOpp ? <span className="agd-mal"> · {it.creada.avisoOpp}</span> : null}
</span>
);
}
if (it.conActividad) return { info: `Ya tiene una actividad agendada el ${fechaLarga(it.conActividad)}.` };
if (it.sinCupo && !it.dia) return { info: "Sin cupo en esos días con estos máximos: elige un día a mano." };
if (it.incluir && probs.length) return { mal: `⚠ ${probs.join(" ")}` };
if (it.fueraDelFiltro) return { info: "Marcada; no coincide con el filtro actual." };
if (it.incluir && it.gv) {
return { info: it.tipo === "Cita" ? "Con GV: Marco recibe la invitación en su calendario y se marca «Participación de GV» en la oportunidad." : "Con GV: Gerencia Comercial queda como participante y se marca «Participación de GV» en la oportunidad." };
}
return null;
};
return (
<section className="plan-agd agd-pag no-print">
<details className="agd-ayuda-d">
<summary>
<span className="agd-ayuda-i">ⓘ</span>
<span><b>Elige la fecha → marca las oportunidades → «Crear».</b> Nada se crea hasta ese paso y queda a nombre del dueño de la oportunidad.</span>
<span className="agd-ayuda-lk">¿Cómo funciona?</span>
</summary>
<div className="agd-ayuda">
<ol>
<li><b>Elige la fecha</b> desde la que quieres agendar (hasta 30 días) y, si quieres, <b>busca o filtra</b> las oportunidades.</li>
<li><b>Marca</b> las que vas a agendar y ajusta el tipo, el día, la hora o el objetivo. Con «👥 Con GV» invitas a Gerencia Comercial.</li>
<li>Pulsa <b>«Crear … en Dynamics»</b>. No se crea nada hasta ese paso, y las actividades quedan a nombre del propietario de la oportunidad.</li>
</ol>
<p>
<b>Reglas:</b> de lunes a viernes, {textoHorario()}. Llamadas de {AGENDADOR.duracion.Llamada} min (horas cada {AGENDADOR.paso.Llamada} min) y visitas de {AGENDADOR.duracion.Cita} min (horas cada {AGENDADOR.paso.Cita} min).
Máximo por día: {AGENDADOR.topes.Llamada} llamadas, {AGENDADOR.topes.Cita} visitas y {AGENDADOR.topes.Tarea} tareas (las tareas vencen a las {minAHora(AGENDADOR.horaTarea)}).
Se muestran <b>todas las oportunidades abiertas</b> del ejecutivo, sin importar su fecha de cierre.
</p>
<p>
<b>Qué se escribe en Dynamics:</b> las visitas salen con lugar «Oficina del cliente»; otros participantes se agregan en el CRM.
Con «Con GV», la actividad lleva a Gerencia Comercial como participante y la oportunidad queda con «Participación de GV» (que suma a su puntuación); en las visitas, además, Marco recibe la invitación en su calendario de Outlook.
Al «Deshacer» la tanda se cancelan las actividades abiertas y la oportunidad vuelve a su valor anterior.
</p>
</div>
</details>
{candidatos.length === 0 && creadas.length === 0 ? (
<p className="agd-vacio">{ownerName} no tiene oportunidades abiertas con fecha de cierre estimada.</p>
) : (
<>
<div className="agd-paso">
<h4>1 · ¿Desde qué día agendas?</h4>
<div className="agd-fecha">
<input id="agd-fecha-i" type="date" value={fecha} min={hoy} max={maxFecha} onChange={(e) => cambiarFecha(e.target.value)} disabled={pendiente} aria-label="Agendar a partir del" />
<span className="hint">Se reparte de <b>{dias.length ? `${diaCorto(dias[0])} a ${diaCorto(dias[dias.length - 1])}` : "—"}</b> · puedes elegir hasta el {fechaLarga(maxFecha)}</span>
</div>
<div className="agd-capg">
{dias.map((d) => {
const c = val.porDia[d] || { Llamada: 0, Cita: 0, Tarea: 0, ...(existentes[d] || {}) };
return (
<div key={d} className="agd-capd" title="Lo que ya tiene agendado ese día más lo que marcaste">
<b className="agd-capd-t">{diaCorto(d)}</b>
{TIPOS_AGENDADOR.map((t) => {
const tope = AGENDADOR.topes[t];
const n = c[t] || 0;
return (
<div key={t} className={`agd-cap${n >= tope ? " lleno" : ""}`}>
<span className="agd-cap-k">{t === "Cita" ? "Visitas" : `${t}s`}</span>
<span className="agd-cap-b"><i style={{ width: `${Math.min(100, Math.round((n / tope) * 100))}%` }} /></span>
<span className="agd-cap-v">{n}/{tope}</span>
</div>
);
})}
</div>
);
})}
</div>
</div>
<div className="agd-paso">
<h4>2 · ¿Qué oportunidades?</h4>
<div className="agd-franja">
<input
type="search"
className="agd-busca"
value={busqueda}
onChange={(e) => setBusqueda(e.target.value)}
placeholder="🔍 Buscar cliente u oportunidad…"
aria-label="Buscar cliente u oportunidad"
/>
{FILTROS.filter((f) => f.visible).map(menuFiltro)}
<label className="agd-check">
<input type="checkbox" checked={ocultarConAct} onChange={(e) => setOcultarConAct(e.target.checked)} /> Ocultar las que ya tienen actividad
</label>
<button type="button" className="agd-mas" aria-expanded={masFiltros} onClick={() => setMasFiltros((v) => !v)}>
{masFiltros ? "- Menos filtros" : "+ Más filtros"}{!masFiltros && nExtra ? ` (${nExtra})` : ""}
</button>
</div>
{masFiltros && <div className="agd-franja agd-franja-mas">{FILTROS.filter((f) => !f.visible).map(menuFiltro)}</div>}
{hayFiltros && (
<div className="agd-chips">
{FILTROS.flatMap((f) => filtros[f.k].map((v) => (
<button key={f.k + v} type="button" className="agd-chip" title={`Quitar «${v}»`} onClick={() => setFiltros((p) => ({ ...p, [f.k]: p[f.k].filter((x) => x !== v) }))}>
{v} ✕
</button>
)))}
<button type="button" className="agd-btn-sec" onClick={() => setFiltros(SIN_FILTROS)}>Limpiar filtros</button>
</div>
)}
</div>
<div className="agd-paso">
<h4>3 · Marca y ajusta</h4>
{coinciden.length === 0 && filas.length === 0 && creadas.length === 0 ? (
<p className="agd-mal agd-grande">
Ninguna oportunidad coincide con la búsqueda y los filtros.{" "}
<button type="button" className="agd-btn-sec" onClick={quitarTodo}>Quitar filtros y búsqueda</button>
</p>
) : (
<>
<div className="agd-acc">
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(true)} disabled={pendiente || !filas.length}>Marcar todas ({filas.filter((f) => f.dia && !f.conActividad).length})</button>
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(false)} disabled={pendiente || !marcadas.length}>Desmarcar</button>
<button type="button" className="agd-btn-sec" onClick={restablecer} disabled={pendiente} title="Deshace tus cambios manuales en las filas no marcadas">Restablecer propuesta</button>
<button type="button" className="agd-btn-sec" onClick={marcarGV} disabled={pendiente || !marcadas.some((m) => m.tipo !== "Tarea")} title="Pone «Con GV» en las llamadas y visitas marcadas">👥 Marcar GV en las seleccionadas</button>
<label className="agd-tipo-todas">
<span className="hint">Tipo para las no tocadas:</span>
<select id="agd-tipo" value={tipoTodas} onChange={(e) => setTipoTodas(e.target.value)} disabled={pendiente} title="Aplica a las filas que no has tocado a mano">
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
</label>
<span className="hint agd-acc-r">
Mostrando {coinciden.length} de {disponibles.length} abiertas
{(hayFiltros || q || ocultarConAct) && <> · <button type="button" className="agd-btn-sec" onClick={quitarTodo}>Quitar filtros y búsqueda</button></>}
{fueraDeFiltro > 0 && ` · ${fueraDeFiltro} marcada${fueraDeFiltro === 1 ? "" : "s"} fuera del filtro (se conservan)`}
{sinCupo > 0 && ` · ${sinCupo} sin cupo`}
</span>
</div>
<div className="agd-t7-w">
<table className="agd-t7">
<colgroup>
<col style={{ width: "4%" }} />
<col style={{ width: "28%" }} />
<col style={{ width: "9%" }} />
<col style={{ width: "14%" }} />
<col style={{ width: "8%" }} />
<col style={{ width: "25%" }} />
<col style={{ width: "12%" }} />
</colgroup>
<thead>
<tr>
<th></th>
<th><button type="button" className="agd-th-b" onClick={() => ordenarPor("cliente")}>Cliente / oportunidad{flecha("cliente")}</button></th>
<th><button type="button" className="agd-th-b" onClick={() => ordenarPor("prio")} title="Ordenar por prioridad sugerida">Prioridad{flecha("prio")}</button></th>
<th>
<button type="button" className="agd-th-b" onClick={() => ordenarPor("cierre")}>Cierre{flecha("cierre")}</button>
{" · "}
<button type="button" className="agd-th-b" onClick={() => ordenarPor("forecast")} title="Ordenar por categoría de previsión">Previsión{flecha("forecast")}</button>
</th>
<th className="num"><button type="button" className="agd-th-b" onClick={() => ordenarPor("valor")}>Valor{flecha("valor")}</button></th>
<th>Propuesta</th>
<th>Objetivo</th>
</tr>
</thead>
<tbody>
{filasTabla.map((it) => {
const hecha = !!it.creada;
const bloqueada = !!it.conActividad;
const probs = hecha ? [] : val.porItem[it.key] || [];
const horas = horasDe(it.tipo).map(minAHora);
const vencida = it.cierre && it.cierre < hoy;
const av = avisoDe(it, probs);
const apagada = hecha || bloqueada || pendiente;
return (
<Fragment key={it.key}>
<tr className={`agd-f${hecha ? " agd-hecha" : it.incluir ? " agd-marcada" : bloqueada ? " agd-con-act" : ""}${av ? " agd-tiene-aviso" : ""}`}>
<td>
<input type="checkbox" checked={!!it.incluir && !hecha} disabled={apagada || (!it.dia && !it.incluir)} onChange={(e) => marcar(it, e.target.checked)} aria-label="Agendar esta oportunidad" title={bloqueada ? "Ya tiene una actividad agendada en esos días" : !it.dia && !it.incluir ? "Elige primero un día" : undefined} />
</td>
<td>
<strong>{it.cliente || it.nombre}</strong>
{it.cliente && <div className="agd-sub">{it.nombre}</div>}
<div className="agd-sub">{it.tipoOpp || "—"} · {it.plan || "Sin plan de cierre"}</div>
</td>
<td>
{it.prioNivel && (
<span className={`agd-prio p-${NIVELES_PRIO.indexOf(it.prioNivel)}`} title={(it.prioMotivos || []).join(" · ") || undefined}>{it.prioNivel}</span>
)}
</td>
<td className={vencida ? "agd-venc" : undefined}>
{it.cierre ? fechaCorta(it.cierre) : "—"}
{vencida && " · vencida"}
<div className="agd-sub">{it.forecast || "Sin previsión"}</div>
</td>
<td className="num">{money(it.valor)}</td>
<td>
<div className="agd-prop">
<select className="agd-s-tipo" aria-label="Tipo de actividad" value={it.tipo} disabled={apagada} onChange={(e) => cambiarTipo(it, e.target.value)}>
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
<select className="agd-s-dia" aria-label="Día" value={it.dia || ""} disabled={apagada} onChange={(e) => cambiarDia(it, e.target.value)}>
<option value="">— día —</option>
{dias.map((d) => <option key={d} value={d}>{diaCorto(d)}</option>)}
</select>
{it.tipo === "Tarea" ? (
<span className="agd-vence" title={`Las tareas vencen a las ${minAHora(AGENDADOR.horaTarea)}`}>vence {minAHora(AGENDADOR.horaTarea)}</span>
) : (
<select className="agd-s-hora" aria-label="Hora" value={it.hora || ""} disabled={apagada || !it.dia} onChange={(e) => editar(it, { hora: e.target.value })}>
<option value="">—</option>
{horas.map((h) => <option key={h} value={h}>{h}</option>)}
</select>
)}
</div>
{it.tipo !== "Tarea" && !hecha && !bloqueada && (
<label className="agd-gv" title="Gerencia Comercial (Marco) participa en esta actividad">
<input type="checkbox" checked={!!it.gv} disabled={pendiente} onChange={(e) => editar(it, { gv: e.target.checked })} /> 👥 Con GV
</label>
)}
</td>
<td>
<select aria-label="Objetivo" value={it.objetivo} disabled={apagada} onChange={(e) => editar(it, { objetivo: e.target.value })}>
<option value="">— elegir —</option>
{OBJETIVOS_AGENDADOR.map((o) => <option key={o} value={o}>{o}</option>)}
</select>
</td>
</tr>
{av && (
<tr className={`agd-aviso${av.mal ? " mal" : av.info ? " info" : " ok"}`}>
<td colSpan={7}>{av.mal || av.info || av}</td>
</tr>
)}
</Fragment>
);
})}
</tbody>
</table>
</div>
{hayCitas && <p className="hint">Las visitas se crean con lugar «Oficina del cliente»; otros participantes e invitados se agregan en el CRM.</p>}
<div className="agd-pie-fijo">
<span className="agd-pie-r">
<b>{marcadas.length} actividad{marcadas.length === 1 ? "" : "es"}</b> · {nGV} con GV
{marcadas.length > 0 && <> · {nTipo("Llamada")} llamada{nTipo("Llamada") === 1 ? "" : "s"} · {nTipo("Cita")} visita{nTipo("Cita") === 1 ? "" : "s"} · {nTipo("Tarea")} tarea{nTipo("Tarea") === 1 ? "" : "s"}</>}
</span>
{nMalos > 0 && <span className="agd-pie-mal">{nMalos} aviso{nMalos === 1 ? "" : "s"} por corregir</span>}
{marcadas.length === 0 && <span className="agd-pie-sub">Marca al menos una oportunidad para poder crear.</span>}
<button type="button" className="agd-pie-btn" disabled={pendiente || !marcadas.length || !val.ok} onClick={crear}>
{pendiente ? "Trabajando…" : `Crear ${marcadas.length} actividad${marcadas.length === 1 ? "" : "es"} en Dynamics`}
</button>
</div>
</>
)}
</div>
</>
)}
{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.conGV ? ` (${resultado.conGV} con GV)` : ""}{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>
))}
{resultado.resultados.filter((x) => x.estado === "creada" && x.avisoOpp).map((x) => (
<div key={x.oppId} className="agd-mal">{x.nombre || x.oppId}: {x.avisoOpp}</div>
))}
</div>
)}
{lotes.length > 0 && (
<details className="agd-lotes">
<summary>Tandas recientes ({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.items.some((x) => x.gv && x.estado === "creada") ? ` (${l.items.filter((x) => x.gv && x.estado === "creada").length} con GV)` : ""} · {fechaCorta(l.desde)} – {fechaCorta(l.hasta)}
{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>
);
}