stats v3 : rapports PDF personnalisés (catalogue, rendu au choix, ReportBuilder)

Simon-Pierre Boucher committed 2 mo ago (Aug 23, 2026) parent 23651d0 Browse files

4 changed files +718 −12

modified frontend/src/ka/stats/SPEC.md +62 −1

++# ka-stats — module Stats commun Groupe KA (spec v3)
+ Contrat partagé par les plateformes pour leurs pages **/stats** (tableau de
+ bord analytique) et les **exports PDF** estampillés Groupe-KA. Le visuel suit
+ rapports PDF** au lieu de 2. Tous les nouveaux champs sont **optionnels** :
+ un dashboard v1 reste valide et se rend tel quel.
++**v3 (2026-08-23)** : **rapports personnalisés** — l'utilisateur compose son
++propre rapport PDF bloc par bloc : choix des données (catalogue dérivé du
++dashboard), du **rendu par bloc** (courbe/aire/barres/anneau/histogramme/
++heatmap/tableau…), de l'ordre, avec **modèles sauvegardés** (localStorage du
++site). Deux endpoints (`/api/stats/catalog`, `POST /api/stats/report/custom`,
++voir §3bis) + un constructeur dans la page /stats (`ReportBuilder` du kit —
++bouton « 🛠 Rapport personnalisé » à côté du menu PDF). Le PDF garde le
++gabarit estampillé Groupe-KA avec l'accent de la plateforme. v2 inchangée.
++
+ ## 1. Page /stats — structure obligatoire (dans cet ordre)
+. **Bandeau KPI** : 6–10 grandes cartes (`KpiCard`) — valeur, libellé,
+ - A4 portrait, marges 18 mm, typo : Helvetica (fallback sûr) ou fonts TTF du
+   DS si présentes.
++## 3bis. Rapports personnalisés (v3)
++
++### Catalogue
++
++`GET /api/stats/catalog?period=…&from=&to=` →
++
++```jsonc
++{ "updated": "…", "period": { … },
++  "blocks": [ { "key": "series:ajouts",      // section[:id] — clé stable
++                "section": "series",
++                "title": "Événements ajoutés par jour",
++                "renders": ["line","area","bar","table"], // rendus compatibles
++                "default_render": "line",
++                "count": 30 } ] }             // taille indicative (optionnel)
++```
++
++Sections → rendus : `kpis` cards|table · `gauges` gauges|table ·
++`series:<id>` line|area|bar|table · `multiseries:<id>` lines|table ·
++`stacked:<id>` stacked|table · `breakdowns:<id>` donut|bars|table ·
++`distributions:<id>` histogram|table · `geo` bars|table ·
++`heatmap` heatmap|table · `hourly` heatmap|table · `tables:<id>` table ·
++`records` cards|table. **Toute donnée a un équivalent tableau.** Le catalogue
++est dérivé du dashboard (implémentation : `kapdf.catalog(dash)` /
++`catalogFromDashboard()` en TS) — zéro maintenance quand une métrique s'ajoute.
++
++### Génération
++
++`POST /api/stats/report/custom` — corps JSON :
++
++```jsonc
++{ "title": "Revue mensuelle",                 // ≤ 80 car., affiché en couverture
++  "period": "30j", "from": "", "to": "",     // mêmes règles que le dashboard
++  "blocks": [ { "key": "kpis", "render": "cards" },
++              { "key": "series:ajouts", "render": "bar" } ] }  // ordre = ordre du PDF
++```
++
++→ `application/pdf`, filename `groupe-ka_<plateforme>_stats_<periode>_personnalise_<date>.pdf`.
++Clés inconnues ignorées ; rendu incompatible → rendu par défaut ; aucun bloc
++valide → **400**. Maximum 40 blocs. Couverture : type = « Rapport
++personnalisé — {title} » ; sommaire ; page de fin habituelle. Un même bloc
++peut apparaître plusieurs fois (ex. graphique + tableau).
++
++### Constructeur (front, kit)
++
++`ReportBuilder` (kacharts.tsx ; port vanilla pour les SPA sans React) :
++panneau modal 2 colonnes — catalogue groupé par section à gauche, composition
++ordonnée à droite (↑ ↓ ✕, sélecteur de rendu par bloc, titre). **Modèles** :
++sauvegarde/chargement/suppression nommés en localStorage (clé
++`ka-stats-rapports`, propre à l'origine du site). Bouton « Générer le PDF »
++→ POST + téléchargement blob. États busy/erreur propres, tactile ≥ 44 px,
++z-index `var(--z-modal, 900)`.
++
+ ## 4. Spécifique par plateforme (sections métier attendues)
+ - **groupe-ka** : tableau de bord maître — consolidation des plateformes

modified frontend/src/ka/stats/kacharts.tsx +214 −2

+       {hi !== null && (
+         <p className="chip" style={{ marginTop: 8, display: "inline-flex", gap: 12, flexWrap: "wrap" }}>
+           <b>{ref[hi]?.t}</b>
++          {shown.map((s) => (
+             <span key={s.label}>{s.label} : <b>{s.points[hi] ? fmtNum(s.points[hi].v) : "—"}{ms.unit ? ` ${ms.unit}` : ""}</b></span>
+           ))}
+         </p>
+   );
+ }
++/* ---------- Menu de rapports PDF (5 rapports + personnalisé v3) ---------- */
+ export function PdfButton({ period, from, to, endpoint = "/api/stats/report" }: { period: string; from?: string; to?: string; endpoint?: string }) {
+   const [open, setOpen] = useState(false);
+   const [busy, setBusy] = useState<string | null>(null);
++  const [builder, setBuilder] = useState(false);
+   const box = useRef<HTMLSpanElement>(null);
+   useEffect(() => {
+     if (!open) return;
+         aria-haspopup="menu" aria-expanded={open}>
+         Autres rapports ▾
+       </button>
++      <button type="button" className="btn btn-ghost" onClick={() => setBuilder(true)} disabled={!!busy}>
++        🛠 Rapport personnalisé
++      </button>
++      {builder && (
++        <ReportBuilder period={period} from={from} to={to} endpoint={endpoint}
++          onClose={() => setBuilder(false)} />
++      )}
+       {open && (
+         <div role="menu" className="card" style={{ position: "absolute", top: "calc(100% + 6px)", right: 0, zIndex: 50, minWidth: 300, padding: 6, background: "var(--surface)", boxShadow: "0 10px 28px rgba(20,24,20,0.18)" }}>
+           {REPORT_MODES.map((m) => (
+   );
+ }
++/* ---------- v3 : constructeur de rapports personnalisés ----------
++   Compose un PDF bloc par bloc : catalogue dérivé du dashboard
++   (GET /api/stats/catalog), rendu au choix par bloc, ordre libre, modèles
++   sauvegardés en localStorage (clé ka-stats-rapports, propre au site).
++   Contrat : SPEC.md §3bis. Rendu dans PdfButton — aucune modif des pages. */
++export type CatalogBlock = {
++  key: string; section: string; title: string;
++  renders: string[]; default_render: string; count?: number;
++};
++type BuilderSel = { key: string; render: string };
++type BuilderTpl = { name: string; title: string; blocks: BuilderSel[] };
++
++const RENDER_LABELS: Record<string, string> = {
++  line: "Courbe", area: "Aire", bar: "Barres verticales",
++  bars: "Barres horizontales", donut: "Anneau", lines: "Multi-courbes",
++  stacked: "Barres empilées", histogram: "Histogramme", heatmap: "Heatmap",
++  cards: "Cartes", gauges: "Jauges", table: "Tableau",
++};
++const SECTION_LABELS: Record<string, string> = {
++  kpis: "Indicateurs", gauges: "Jauges", series: "Évolution",
++  multiseries: "Multi-courbes", stacked: "Compositions",
++  breakdowns: "Répartitions", distributions: "Distributions",
++  geo: "Géographie", heatmap: "Calendrier", hourly: "Activité horaire",
++  tables: "Tableaux", records: "Records",
++};
++const TPL_KEY = "ka-stats-rapports";
++
++function loadTemplates(): BuilderTpl[] {
++  try { return JSON.parse(localStorage.getItem(TPL_KEY) ?? "[]"); }
++  catch { return []; }
++}
++function saveTemplates(t: BuilderTpl[]) {
++  try { localStorage.setItem(TPL_KEY, JSON.stringify(t)); } catch { /* plein/privé */ }
++}
++
++export function ReportBuilder({
++  period, from, to, endpoint = "/api/stats/report", onClose,
++}: {
++  period: string; from?: string; to?: string; endpoint?: string; onClose: () => void;
++}) {
++  const [cat, setCat] = useState<CatalogBlock[] | null>(null);
++  const [err, setErr] = useState("");
++  const [sel, setSel] = useState<BuilderSel[]>([]);
++  const [title, setTitle] = useState("");
++  const [busy, setBusy] = useState(false);
++  const [tpls, setTpls] = useState<BuilderTpl[]>(loadTemplates);
++  const catalogUrl = endpoint.replace(/\/report$/, "/catalog");
++
++  useEffect(() => {
++    const p = new URLSearchParams({ period });
++    if (from) p.set("from", from);
++    if (to) p.set("to", to);
++    fetch(`${catalogUrl}?${p}`)
++      .then((r) => (r.ok ? r.json() : Promise.reject(r.status)))
++      .then((d) => setCat(d.blocks ?? []))
++      .catch(() => setErr("Catalogue indisponible — réessayez plus tard."));
++  }, [period, from, to, catalogUrl]);
++
++  useEffect(() => {
++    const esc = (e: KeyboardEvent) => { if (e.key === "Escape") onClose(); };
++    document.addEventListener("keydown", esc);
++    const prev = document.body.style.overflow;
++    document.body.style.overflow = "hidden";
++    return () => { document.removeEventListener("keydown", esc); document.body.style.overflow = prev; };
++  }, [onClose]);
++
++  const add = (b: CatalogBlock) =>
++    setSel((s) => s.some((x) => x.key === b.key && x.render === b.default_render)
++      ? s : [...s, { key: b.key, render: b.default_render }]);
++  const move = (i: number, d: number) => setSel((s) => {
++    const j = i + d;
++    if (j < 0 || j >= s.length) return s;
++    const n = [...s]; [n[i], n[j]] = [n[j], n[i]]; return n;
++  });
++
++  const generate = async () => {
++    if (busy || !sel.length) return;
++    setBusy(true); setErr("");
++    try {
++      const body: Record<string, unknown> = { title, period, blocks: sel };
++      if (from && to) { body.from = from; body.to = to; }
++      const r = await fetch(`${endpoint}/custom`, {
++        method: "POST", headers: { "Content-Type": "application/json" },
++        body: JSON.stringify(body),
++      });
++      if (!r.ok) throw new Error(String(r.status));
++      const blob = await r.blob();
++      const m = (r.headers.get("Content-Disposition") ?? "").match(/filename="?([^";]+)/);
++      const a = document.createElement("a");
++      a.href = URL.createObjectURL(blob);
++      a.download = m ? m[1] : "rapport-personnalise.pdf";
++      document.body.appendChild(a); a.click(); a.remove();
++      setTimeout(() => URL.revokeObjectURL(a.href), 4000);
++    } catch {
++      setErr("La génération a échoué — réessayez.");
++    }
++    setBusy(false);
++  };
++
++  const groups: [string, CatalogBlock[]][] = [];
++  for (const b of cat ?? []) {
++    const g = groups.find(([s]) => s === b.section);
++    if (g) g[1].push(b); else groups.push([b.section, [b]]);
++  }
++  const selKeys = new Set(sel.map((s) => s.key));
++  const mono: React.CSSProperties = { fontFamily: "var(--font-mono)", fontSize: 10.5, fontWeight: 700, textTransform: "uppercase", letterSpacing: "0.06em" };
++
++  return (
++    <div role="dialog" aria-modal="true" aria-label="Rapport personnalisé"
++      onClick={(e) => { if (e.target === e.currentTarget) onClose(); }}
++      style={{ position: "fixed", inset: 0, zIndex: "var(--z-modal, 900)" as never, background: "rgba(20,24,20,0.45)", display: "flex", alignItems: "flex-start", justifyContent: "center", padding: "4vh 14px", overflow: "auto" }}>
++      <div className="card" style={{ width: "min(980px,100%)", maxHeight: "92vh", display: "flex", flexDirection: "column", background: "var(--surface)", padding: 0, textAlign: "left", cursor: "default" }}>
++        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", gap: 10, padding: "16px 20px", borderBottom: "1px solid var(--line)" }}>
++          <b style={{ fontFamily: "var(--font-display)", fontSize: 18 }}>
++            Rapport personnalisé <span className="klabel">· période : {from && to ? `${from} → ${to}` : (PERIODS.find((p) => p.id === period)?.label ?? period)}</span>
++          </b>
++          <button type="button" className="btn btn-ghost" onClick={onClose}>✕ Fermer</button>
++        </div>
++        <div style={{ display: "grid", gridTemplateColumns: "repeat(auto-fit, minmax(300px, 1fr))", overflow: "auto", flex: 1 }}>
++          <div style={{ padding: "14px 20px", minWidth: 0, borderRight: "1px solid var(--line)" }}>
++            <h3 style={{ ...mono, color: "var(--ink-3)", margin: "4px 0 10px" }}>Blocs disponibles ({cat?.length ?? "…"})</h3>
++            {!cat && !err && <p className="klabel">Chargement du catalogue…</p>}
++            {groups.map(([secId, bs]) => (
++              <div key={secId}>
++                <p style={{ ...mono, color: "var(--ink-2)", margin: "12px 0 6px" }}>{SECTION_LABELS[secId] ?? secId}</p>
++                {bs.map((b) => (
++                  <div key={b.key} style={{ display: "flex", justifyContent: "space-between", alignItems: "center", gap: 8, padding: "7px 10px", border: "1px solid var(--line)", borderRadius: 8, marginBottom: 6, fontSize: 13, opacity: selKeys.has(b.key) ? 0.45 : 1 }}>
++                    <span style={{ minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }} title={b.title}>{b.title}</span>
++                    <button type="button" className="btn btn-ghost" onClick={() => add(b)} aria-label={`Ajouter ${b.title}`} style={{ flex: "none" }}>+</button>
++                  </div>
++                ))}
++              </div>
++            ))}
++          </div>
++          <div style={{ padding: "14px 20px", minWidth: 0 }}>
++            <h3 style={{ ...mono, color: "var(--ink-3)", margin: "4px 0 10px" }}>Composition du rapport ({sel.length})</h3>
++            <label className="klabel" htmlFor="rb-title">Titre du rapport</label>
++            <input id="rb-title" className="input" style={{ width: "100%", margin: "4px 0 12px", boxSizing: "border-box" }}
++              maxLength={80} placeholder="Ex. : Revue mensuelle" value={title} onChange={(e) => setTitle(e.target.value)} />
++            {sel.length ? sel.map((s, i) => {
++              const b = (cat ?? []).find((x) => x.key === s.key) ?? { title: s.key, renders: [s.render] } as CatalogBlock;
++              return (
++                <div key={`${s.key}:${s.render}:${i}`} style={{ display: "flex", alignItems: "center", gap: 8, padding: "8px 10px", border: "1px solid var(--ink)", borderRadius: 8, marginBottom: 6, background: "var(--surface-2)", fontSize: 13 }}>
++                  <button type="button" onClick={() => move(i, -1)} disabled={i === 0} aria-label="Monter" style={{ border: 0, background: "none", cursor: "pointer", opacity: i === 0 ? 0.25 : 1 }}>▲</button>
++                  <button type="button" onClick={() => move(i, 1)} disabled={i === sel.length - 1} aria-label="Descendre" style={{ border: 0, background: "none", cursor: "pointer", opacity: i === sel.length - 1 ? 0.25 : 1 }}>▼</button>
++                  <span style={{ flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }} title={b.title}><b>{i + 1}.</b> {b.title}</span>
++                  {b.renders.length > 1 ? (
++                    <select className="input" value={s.render} aria-label="Rendu" style={{ maxWidth: 150, padding: "4px 6px", fontSize: 12 }}
++                      onChange={(e) => setSel((xs) => xs.map((x, j) => j === i ? { ...x, render: e.target.value } : x))}>
++                      {b.renders.map((r) => <option key={r} value={r}>{RENDER_LABELS[r] ?? r}</option>)}
++                    </select>
++                  ) : <span className="klabel">{RENDER_LABELS[s.render] ?? s.render}</span>}
++                  <button type="button" onClick={() => setSel((xs) => xs.filter((_, j) => j !== i))} aria-label="Retirer" style={{ border: 0, background: "none", cursor: "pointer" }}>✕</button>
++                </div>
++              );
++            }) : (
++              <div style={{ border: "1px dashed var(--line)", borderRadius: 8, padding: 16, color: "var(--ink-3)", fontSize: 13, textAlign: "center" }}>
++                Aucun bloc — ajoutez des blocs depuis la colonne de gauche, ou chargez un modèle ci-dessous.
++              </div>
++            )}
++            <p style={{ display: "flex", gap: 8, margin: "10px 0 0" }}>
++              <button type="button" className="btn btn-ghost" disabled={!cat?.length}
++                onClick={() => setSel((cat ?? []).map((b) => ({ key: b.key, render: b.default_render })))}>Tout ajouter</button>
++              <button type="button" className="btn btn-ghost" disabled={!sel.length} onClick={() => setSel([])}>Vider</button>
++            </p>
++            {err && <p style={{ color: "var(--danger)", fontSize: 12.5, margin: "6px 0 0" }}>{err}</p>}
++          </div>
++        </div>
++        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", gap: 10, flexWrap: "wrap", padding: "14px 20px", borderTop: "1px solid var(--line)" }}>
++          <span style={{ display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}>
++            <select className="input" aria-label="Modèles sauvegardés" style={{ maxWidth: 210 }} value=""
++              onChange={(e) => {
++                const t = tpls[Number(e.target.value)];
++                if (!t) return;
++                setTitle(t.title || t.name);
++                setSel((t.blocks ?? []).filter((s) => (cat ?? []).some((b) => b.key === s.key)).map((s) => ({ ...s })));
++              }}>
++              <option value="">Modèles ({tpls.length})…</option>
++              {tpls.map((t, i) => <option key={t.name} value={i}>{t.name}</option>)}
++            </select>
++            <button type="button" className="btn btn-ghost" disabled={!sel.length}
++              onClick={() => {
++                const name = window.prompt("Nom du modèle :", title || "Mon rapport");
++                if (!name) return;
++                const next = [...tpls.filter((t) => t.name !== name), { name, title, blocks: sel.map((s) => ({ ...s })) }];
++                setTpls(next); saveTemplates(next);
++              }}>💾 Sauvegarder</button>
++            <button type="button" className="btn btn-ghost" disabled={!tpls.length}
++              onClick={() => {
++                const name = window.prompt(`Nom du modèle à supprimer :\n${tpls.map((t) => `· ${t.name}`).join("\n")}`);
++                if (!name) return;
++                const next = tpls.filter((t) => t.name !== name);
++                setTpls(next); saveTemplates(next);
++              }}>🗑 Supprimer</button>
++          </span>
++          <button type="button" className="btn btn-primary" disabled={!sel.length || busy} onClick={generate}>
++            {busy ? "Génération…" : "⬇ Générer le PDF"}
++          </button>
++        </div>
++      </div>
++    </div>
++  );
++}
++
+ /* ---------- États ---------- */
+ export function EmptyBlock({ title }: { title: string }) {
+   return (

modified restoka/kapdf.py +398 −8

+ # Auteur : Simon-Pierre Boucher — contact@spboucher.ai
++# ka-ui/stats/kapdf.py — moteur PDF commun Groupe KA (fpdf2). v3
+ # Consomme le JSON du contrat /api/stats/dashboard (voir SPEC.md) et produit
++# les rapports estampillés Groupe-KA. 5 modes fixes :
+ #   complet      — toutes les sections (KPI, jauges, séries + stats, multi-
+ #                  séries, empilées, distributions, répartitions, géo,
+ #                  heatmap horaire, tableaux, records)
+ #   tendances    — KPI + toutes les séries temporelles + stats de séries
+ #   repartitions — breakdowns, distributions, géo, activité horaire
+ #   donnees      — tous les tableaux en version longue (400 lignes max)
++# v3 : mode « personnalise » — l'utilisateur compose son rapport bloc par
++# bloc (choix des données ET du rendu par bloc : courbe/aire/barres/anneau/
++# heatmap/tableau…). catalog(dash) expose les blocs disponibles ; le rapport
++# suit une spec {"title": str, "blocks": [{"key": "series:ajouts",
++# "render": "bar"}, …]} et respecte l'ordre demandé.
+ # Graphiques VECTORIELS uniquement (primitives fpdf), accent de la marque.
+ # Usage :
++#   from kapdf import GroupeKAReport, REPORT_MODES, catalog, filename
+ #   pdf_bytes = GroupeKAReport(site={"wordmark":"Lou·Ka","accent":"#ff6a00",
+ #       "domain":"www.lou-ka.com","tagline":"…"}, dashboard=dash_json,
+ #       mode="complet").build()
++#   pdf_bytes = GroupeKAReport(site=SITE, dashboard=dash, mode="personnalise",
++#       spec={"title": "Mon rapport", "blocks": [...]}).build()
+ # Dépendance : pip install fpdf2  (aucune autre)
+ from __future__ import annotations
+     "repartitions": "Répartitions & géographie",
+     "donnees": "Données détaillées",
+ }
++# v3 — mode composé par l'utilisateur (jamais dans le menu des modes fixes)
++CUSTOM_MODE = "personnalise"
++CUSTOM_LABEL = "Rapport personnalisé"
++
++# v3 — rendus proposés par type de bloc (le 1er est le rendu par défaut ;
++# « table » est toujours offert : toute donnée a un équivalent tableau)
++RENDER_LABELS = {
++    "line": "Courbe", "area": "Aire", "bar": "Barres verticales",
++    "bars": "Barres horizontales", "donut": "Anneau",
++    "lines": "Multi-courbes", "stacked": "Barres empilées",
++    "histogram": "Histogramme", "heatmap": "Heatmap",
++    "cards": "Cartes", "gauges": "Jauges", "table": "Tableau",
++}
++SECTION_LABELS = {
++    "kpis": "Indicateurs", "gauges": "Taux & couvertures",
++    "series": "Évolution", "multiseries": "Comparaisons",
++    "stacked": "Compositions", "breakdowns": "Répartitions",
++    "distributions": "Distributions", "geo": "Géographie",
++    "heatmap": "Calendrier", "hourly": "Activité horaire",
++    "tables": "Tableaux", "records": "Records",
++}
++
++
++def catalog(dash: dict) -> list[dict]:
++    """v3 — blocs composables d'un dashboard : ce que le constructeur de
++    rapports personnalisés peut inclure, avec les rendus compatibles.
++    key = section[:id] ; l'ordre renvoyé = ordre naturel du dashboard."""
++    out: list[dict] = []
++
++    def add(key, title, renders, default=None, count=None):
++        b = {"key": key, "section": key.split(":")[0], "title": title,
++             "renders": renders, "default_render": default or renders[0]}
++        if count is not None:
++            b["count"] = count
++        out.append(b)
++
++    if dash.get("kpis"):
++        add("kpis", "Indicateurs clés (KPI)", ["cards", "table"],
++            count=len(dash["kpis"]))
++    gs = [g for g in (dash.get("gauges") or [])
++          if isinstance(g.get("value"), (int, float)) and g.get("max")]
++    if gs:
++        add("gauges", "Taux & couvertures (jauges)", ["gauges", "table"],
++            count=len(gs))
++    for s in dash.get("series") or []:
++        if len(s.get("points") or []) < 2:
++            continue
++        kind = s.get("kind") or "line"
++        default = kind if kind in ("line", "area", "bar") else "line"
++        add(f"series:{s.get('id')}", s.get("title", ""),
++            ["line", "area", "bar", "table"], default,
++            len(s.get("points") or []))
++    for ms in dash.get("multiseries") or []:
++        if not (ms.get("series") or []):
++            continue
++        add(f"multiseries:{ms.get('id')}", ms.get("title", ""),
++            ["lines", "table"], count=len(ms["series"]))
++    for st in dash.get("stacked") or []:
++        if not (st.get("points") or []):
++            continue
++        add(f"stacked:{st.get('id')}", st.get("title", ""),
++            ["stacked", "table"], count=len(st.get("keys") or []))
++    for b in dash.get("breakdowns") or []:
++        if not (b.get("items") or []):
++            continue
++        default = "donut" if b.get("kind") == "donut" else "bars"
++        add(f"breakdowns:{b.get('id')}", b.get("title", ""),
++            ["donut", "bars", "table"], default, len(b["items"]))
++    for d in dash.get("distributions") or []:
++        if not (d.get("bins") or []):
++            continue
++        add(f"distributions:{d.get('id')}", d.get("title", ""),
++            ["histogram", "table"], count=len(d["bins"]))
++    geo = dash.get("geo") or {}
++    if geo.get("items"):
++        add("geo", geo.get("title", "Répartition géographique"),
++            ["bars", "table"], count=len(geo["items"]))
++    hm = dash.get("heatmap") or {}
++    if hm.get("cells"):
++        add("heatmap", hm.get("title", "Calendrier d'activité"),
++            ["heatmap", "table"])
++    hr = dash.get("hourly") or {}
++    if hr.get("cells"):
++        add("hourly", hr.get("title", "Activité par jour et heure"),
++            ["heatmap", "table"])
++    for t in dash.get("tables") or []:
++        if not (t.get("rows") or []):
++            continue
++        add(f"tables:{t.get('id')}", t.get("title", ""), ["table"],
++            count=len(t["rows"]))
++    if dash.get("records"):
++        add("records", "Records & faits marquants", ["cards", "table"],
++            count=len(dash["records"]))
++    return out
+ EMAILS = [
+     ("contact@groupe-ka.com", "Projets, partenariats & données"),
+ class GroupeKAReport:
++    def __init__(self, site: dict, dashboard: dict, mode: str = "complet",
++                 spec: dict | None = None):
+         self.site = site
+         self.d = dashboard
++        self.mode = mode if (mode in REPORT_MODES or mode == CUSTOM_MODE) else "complet"
++        self.spec = spec or {}
+         self.accent = _hex(site.get("accent", "#d9f26b"))
+         period = dashboard.get("period", {}) or {}
+         self.period_label = period.get("label") or "toute la période"
+         self.pdf = _PDF(site.get("wordmark", ""), self.accent, self.period_label)
+         self.toc: list[tuple[str, int]] = []
++    @property
++    def mode_label(self) -> str:
++        if self.mode == CUSTOM_MODE:
++            t = str(self.spec.get("title") or "").strip()
++            return f"{CUSTOM_LABEL} — {t}" if t else CUSTOM_LABEL
++        return REPORT_MODES[self.mode]
++
+     # ---------- primitives ----------
+     def _card(self, x, y, w, h, fill=WHITE):
+         p = self.pdf
+         p.set_xy(24, 100)
+         p.set_font("helvetica", "", 13)
+         p.set_text_color(*INK2)
++        p.multi_cell(150, 7, f"{self.mode_label} — {wm}")
+         now = datetime.now(ZoneInfo("America/Toronto"))
+         per = self.d.get("period", {}) or {}
+         p.set_xy(24, 125)
+             ("Période couverte", self.period_label + (f" ({per.get('from')} → {per.get('to')})" if per.get("from") else "")),
+             ("Généré le", now.strftime("%Y-%m-%d à %H:%M") + " (heure de l'Est)"),
+             ("Plateforme", "https://" + self.site.get("domain", "")),
++            ("Type de rapport", self.mode_label),
+         ]
+         y = 128
+         for k, v in rows:
+                 p.rect(x0 + lx + h * cw, y0 + ly + d * chh, cw - 0.5, chh - 0.5, style="DF")
+         p.set_y(y0 + ly + 7 * chh + 5)
++    def _calheat(self, hm):
++        """v3 — calendrier de chaleur 26 semaines (équivalent PDF du
++        CalendarHeatmap du kit front) : colonnes = semaines, lignes = jours."""
++        from datetime import date as _date, timedelta as _td
++        cells = hm.get("cells") or []
++        vals = {c.get("date"): c.get("value") or 0 for c in cells if c.get("date")}
++        if not vals:
++            return
++        p = self.pdf
++        if p.get_y() > 215:
++            p.add_page()
++        self._chart_title(hm.get("title", "Calendrier d'activité"))
++        try:
++            end = _date.fromisoformat(max(vals))
++        except ValueError:
++            return
++        weeks = 26
++        start = end - _td(days=weeks * 7 - 1)
++        start -= _td(days=start.weekday())  # lundi
++        vmax = max(vals.values()) or 1
++        x0, y0 = p.l_margin, p.get_y()
++        cw, lx, ly = 6.3, 10, 4
++        dows = ["Lun", "", "Mer", "", "Ven", "", "Dim"]
++        p.set_font("helvetica", "", 5.8)
++        p.set_text_color(*INK3)
++        for d in range(7):
++            if dows[d]:
++                p.set_xy(x0, y0 + ly + d * cw + 1.2)
++                p.cell(lx - 1, 3, dows[d], align="R")
++        for w in range(weeks):
++            monday = start + _td(days=7 * w)
++            if monday.day <= 7:  # étiquette de mois à la 1re semaine du mois
++                p.set_xy(x0 + lx + w * cw, y0)
++                p.cell(cw * 4, 3, monday.strftime("%m"))
++            for d in range(7):
++                day = monday + _td(days=d)
++                v = vals.get(day.isoformat(), 0)
++                f = 0.15 + 0.85 * (v / vmax) if v else 0.0
++                col = (tuple(int(PAPER[j] + (self.accent[j] - PAPER[j]) * f)
++                             for j in range(3)) if v else (235, 233, 228))
++                p.set_fill_color(*col)
++                p.set_draw_color(215, 213, 207)
++                p.set_line_width(0.1)
++                p.rect(x0 + lx + w * cw, y0 + ly + d * cw, cw - 0.5, cw - 0.5,
++                       style="DF")
++        p.set_y(y0 + ly + 7 * cw + 5)
++
++    # ---------- v3 : conversions bloc → tableau ----------
++    @staticmethod
++    def _serie_as_table(s):
++        unit = s.get("unit") or "Valeur"
++        cols = ["Date", unit.capitalize()]
++        cmp_ = s.get("compare") or []
++        if cmp_:
++            cols.append("Période comparée")
++        rows = []
++        for i, pt in enumerate(s.get("points") or []):
++            row = [str(pt.get("t", "")), pt.get("v", "")]
++            if cmp_:
++                row.append(cmp_[i]["v"] if i < len(cmp_) else "")
++            rows.append(row)
++        return {"id": s.get("id"), "title": s.get("title", ""),
++                "columns": cols, "rows": rows}
++
++    @staticmethod
++    def _multi_as_table(ms):
++        labels = [s.get("label", "") for s in (ms.get("series") or [])][:4]
++        by_t: dict[str, dict] = {}
++        for s in (ms.get("series") or [])[:4]:
++            for pt in s.get("points") or []:
++                by_t.setdefault(str(pt.get("t", "")), {})[s.get("label", "")] = pt.get("v")
++        rows = [[t] + [by_t[t].get(lbl, "") for lbl in labels]
++                for t in sorted(by_t)]
++        return {"id": ms.get("id"), "title": ms.get("title", ""),
++                "columns": ["Date"] + labels, "rows": rows}
++
++    @staticmethod
++    def _stacked_as_table(st):
++        keys = (st.get("keys") or [])[:6]
++        rows = []
++        for pt in st.get("points") or []:
++            vs = [(pt.get("values") or [])[j] if j < len(pt.get("values") or []) else 0
++                  for j in range(len(keys))]
++            rows.append([str(pt.get("t", ""))] + vs + [sum(v or 0 for v in vs)])
++        return {"id": st.get("id"), "title": st.get("title", ""),
++                "columns": ["Date"] + list(keys) + ["Total"], "rows": rows}
++
++    @staticmethod
++    def _items_as_table(id_, title, items, label_col="Libellé"):
++        items = items or []
++        with_delta = any(it.get("delta_pct") is not None for it in items)
++        cols = [label_col, "Valeur"] + (["delta %"] if with_delta else [])
++        rows = []
++        for it in items:
++            row = [str(it.get("label", "")), it.get("value", "")]
++            if with_delta:
++                d = it.get("delta_pct")
++                row.append("" if d is None else f"{'+' if d >= 0 else ''}{d} %")
++            rows.append(row)
++        return {"id": id_, "title": title, "columns": cols, "rows": rows}
++
++    def _kpis_as_table(self):
++        rows = []
++        for k in self.d.get("kpis") or []:
++            v = k.get("value")
++            val = (_fr(v) if isinstance(v, (int, float)) else str(v)) + \
++                  ((" " + k["unit"]) if k.get("unit") else "")
++            d = k.get("delta_pct")
++            rows.append([str(k.get("label", "")), val,
++                         "" if d is None else f"{'+' if d >= 0 else ''}{d} %"])
++        return {"id": "kpis", "title": "Indicateurs clés",
++                "columns": ["Indicateur", "Valeur", "delta %"], "rows": rows}
++
++    def _gauges_as_table(self):
++        rows = [[str(g.get("label", "")),
++                 f"{_fr(g['value'])}{' ' + g['unit'] if g.get('unit') else ''}",
++                 _fr(g["max"]), f"{100.0 * g['value'] / g['max']:.0f} %"]
++                for g in self.d.get("gauges") or []
++                if isinstance(g.get("value"), (int, float)) and g.get("max")]
++        return {"id": "gauges", "title": "Taux & couvertures",
++                "columns": ["Mesure", "Valeur", "Max", "Part"], "rows": rows}
++
++    def _records_as_table(self):
++        rows = [[str(r.get("label", "")), str(r.get("value", "")),
++                 str(r.get("date", "") or "")]
++                for r in self.d.get("records") or []]
++        return {"id": "records", "title": "Records & faits marquants",
++                "columns": ["Fait marquant", "Valeur", "Date"], "rows": rows}
++
++    @staticmethod
++    def _heatmap_as_table(hm, title):
++        cells = sorted((hm.get("cells") or []),
++                       key=lambda c: -(c.get("value") or 0))[:40]
++        return {"id": "heatmap", "title": title + " — jours les plus chargés",
++                "columns": ["Date", "Valeur"],
++                "rows": [[c.get("date", ""), c.get("value") or 0] for c in cells]}
++
++    @staticmethod
++    def _hourly_as_table(hr, title):
++        days = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi",
++                "Dimanche"]
++        cells = sorted((hr.get("cells") or []),
++                       key=lambda c: -(c.get("value") or 0))[:40]
++        return {"id": "hourly", "title": title + " — créneaux les plus actifs",
++                "columns": ["Jour", "Heure", "Valeur"],
++                "rows": [[days[c["dow"]] if 0 <= c.get("dow", -1) <= 6 else "?",
++                          f"{c.get('hour', '?')} h", c.get("value") or 0]
++                         for c in cells]}
++
++    # ---------- v3 : rendu d'un bloc du rapport personnalisé ----------
++    def _find(self, coll: str, id_: str):
++        for it in self.d.get(coll) or []:
++            if str(it.get("id")) == id_:
++                return it
++        return None
++
++    def _toc_mark(self, title: str):
++        """Blocs graphiques du mode personnalisé : entrée de sommaire sans
++        _section_title (le graphique porte déjà son titre)."""
++        if self.pdf.get_y() > 235:
++            self.pdf.add_page()
++        self.toc.append((title, self.pdf.page_no()))
++
++    def _render_block(self, key: str, render: str):
++        section, _, id_ = key.partition(":")
++        if section == "kpis":
++            self._table(self._kpis_as_table()) if render == "table" else self._kpis()
++        elif section == "gauges":
++            self._table(self._gauges_as_table()) if render == "table" else self._gauges()
++        elif section == "records":
++            self._table(self._records_as_table()) if render == "table" else self._records()
++        elif section == "series":
++            s = self._find("series", id_)
++            if not s:
++                return
++            if render == "table":
++                self._table(self._serie_as_table(s), max_rows=400)
++            else:
++                s2 = dict(s)
++                if render in ("line", "area", "bar"):
++                    s2["kind"] = render
++                self._toc_mark(s2.get("title", ""))
++                if s2.get("kind") == "bar":
++                    self._vbars(s2)
++                else:
++                    self._line_chart(s2, with_stats=True)
++        elif section == "multiseries":
++            ms = self._find("multiseries", id_)
++            if not ms:
++                return
++            if render == "table":
++                self._table(self._multi_as_table(ms), max_rows=400)
++            else:
++                self._toc_mark(ms.get("title", ""))
++                self._multiline(ms)
++        elif section == "stacked":
++            st = self._find("stacked", id_)
++            if not st:
++                return
++            if render == "table":
++                self._table(self._stacked_as_table(st), max_rows=400)
++            else:
++                self._toc_mark(st.get("title", ""))
++                self._stacked(st)
++        elif section == "breakdowns":
++            b = self._find("breakdowns", id_)
++            if not b:
++                return
++            if render == "table":
++                self._table(self._items_as_table(id_, b.get("title", ""),
++                                                 b.get("items")), max_rows=400)
++            else:
++                self._toc_mark(b.get("title", ""))
++                if render == "donut":
++                    self._donut(b)
++                else:
++                    self._bars(b.get("title", ""), b.get("items"))
++        elif section == "distributions":
++            d = self._find("distributions", id_)
++            if not d:
++                return
++            if render == "table":
++                bins = [{"label": bn.get("label"), "value": bn.get("value")}
++                        for bn in d.get("bins") or []]
++                self._table(self._items_as_table(id_, d.get("title", ""), bins,
++                                                 label_col="Tranche"))
++            else:
++                self._toc_mark(d.get("title", ""))
++                self._vbars(d)
++        elif section == "geo":
++            geo = self.d.get("geo") or {}
++            if not geo.get("items"):
++                return
++            title = geo.get("title", "Répartition géographique")
++            if render == "table":
++                self._table(self._items_as_table("geo", title, geo["items"],
++                                                 label_col="Zone"), max_rows=400)
++            else:
++                self._toc_mark(title)
++                self._bars(title, geo["items"])
++        elif section == "heatmap":
++            hm = self.d.get("heatmap") or {}
++            if not hm.get("cells"):
++                return
++            title = hm.get("title", "Calendrier d'activité")
++            if render == "table":
++                self._table(self._heatmap_as_table(hm, title))
++            else:
++                self._toc_mark(title)
++                self._calheat(hm)
++        elif section == "hourly":
++            hr = self.d.get("hourly") or {}
++            if not hr.get("cells"):
++                return
++            title = hr.get("title", "Activité par jour et heure")
++            if render == "table":
++                self._table(self._hourly_as_table(hr, title))
++            else:
++                self._toc_mark(title)
++                self._hourly()
++        elif section == "tables":
++            t = self._find("tables", id_)
++            if t:
++                self._table(t, max_rows=400)
++
+     def _table(self, t, max_rows=200):
+         p = self.pdf
+         cols = t.get("columns") or []
+         p = self.pdf
+         p.alias_nb_pages()
+         self._cover()
++        with_toc = self.mode in ("complet", "donnees", CUSTOM_MODE)
+         toc_page_no = None
+         if self.mode == "synthese":
+             p.add_page()
+             for t in self.d.get("tables") or []:
+                 self._table(t, max_rows=400)
+             self._final_page()
++        elif self.mode == CUSTOM_MODE:
++            p.add_page()
++            toc_page_no = p.page_no()
++            p.add_page()
++            known = {b["key"]: b for b in catalog(self.d)}
++            for blk in self.spec.get("blocks") or []:
++                key = str(blk.get("key", ""))
++                b = known.get(key)
++                if not b:
++                    continue
++                render = str(blk.get("render") or "")
++                if render not in b["renders"]:
++                    render = b["default_render"]
++                self._render_block(key, render)
++            self._final_page()
+         else:  # complet
+             p.add_page()
+             toc_page_no = p.page_no()

modified restoka/web.py +44 −1

+ import threading
+ from pathlib import Path
++from fastapi import BackgroundTasks, Body, FastAPI, HTTPException, Query
+ from fastapi.middleware.cors import CORSMiddleware
+ from fastapi.middleware.gzip import GZipMiddleware
+ from fastapi.responses import FileResponse, Response
+                              f'attachment; filename="{fname}"'})
++@app.get("/api/stats/catalog")
++def stats_catalog(
++    period: str = "30j",
++    from_: str | None = Query(None, alias="from"),
++    to: str | None = Query(None),
++):
++    """v3 — blocs composables pour le constructeur de rapports personnalisés."""
++    from . import kapdf
++    from . import stats as kastats
++    if period not in kastats.PERIOD_LABELS and not (from_ and to):
++        period = "30j"
++    dash = kastats.dashboard(period, from_, to)
++    return {"updated": dash.get("updated"), "period": dash.get("period"),
++            "blocks": kapdf.catalog(dash)}
++
++
++@app.post("/api/stats/report/custom")
++def stats_report_custom(spec: dict = Body(...)):
++    """v3 — rapport PDF personnalisé : {"title", "period", "from", "to",
++    "blocks": [{"key": "series:…", "render": "bar"}, …]} (SPEC.md §3bis)."""
++    from . import kapdf
++    from . import stats as kastats
++    period = str(spec.get("period") or "30j")
++    from_ = str(spec.get("from") or "") or None
++    to = str(spec.get("to") or "") or None
++    if period not in kastats.PERIOD_LABELS and not (from_ and to):
++        period = "30j"
++    dash = kastats.dashboard(period, from_, to)
++    known = {b["key"] for b in kapdf.catalog(dash)}
++    blocks = [b for b in (spec.get("blocks") or [])
++              if isinstance(b, dict) and b.get("key") in known][:40]
++    if not blocks:
++        raise HTTPException(400, "Aucun bloc valide dans la composition")
++    pdf = kapdf.GroupeKAReport(
++        site=_SITE, dashboard=dash, mode=kapdf.CUSTOM_MODE,
++        spec={"title": str(spec.get("title") or "")[:80], "blocks": blocks},
++    ).build()
++    fname = kapdf.filename("resto-ka", period, kapdf.CUSTOM_MODE)
++    return Response(content=pdf, media_type="application/pdf",
++                    headers={"Content-Disposition":
++                             f'attachment; filename="{fname}"'})
++
++
+ @app.get("/api/stats")
+ def stats():
+     con = db.connect()

spb/resto-ka

stats v3 : rapports PDF personnalisés (catalogue, rendu au choix, ReportBuilder)

Theme