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

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

3 changed files +696 −9

modified src/api/kapdf.py +398 −8

+ # Date     : 2026-08-19
+ # ============================================
+ # 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 src/api/routes/stats.py +55 −1

+ from zoneinfo import ZoneInfo
+ import httpx
++from fastapi import APIRouter, Body, Depends, HTTPException, Query, Response
+ from sqlalchemy import func, select
+ from sqlalchemy.orm import Session
+     )
++@router.get("/catalog")
++def stats_catalog(
++    period: str = Query("30j", description="auj, 7j, 30j, 3m, 6m, 12m, annee, tout"),
++    date_from: datetime.date | None = Query(None, alias="from"),
++    date_to: datetime.date | None = Query(None, alias="to"),
++    db: Session = Depends(get_db),
++) -> dict[str, Any]:
++    """v3 — blocs composables pour le constructeur de rapports personnalisés."""
++    dash = _dashboard_cached(db, period, date_from, date_to)
++    return {
++        "updated": dash.get("updated"),
++        "period": dash.get("period"),
++        "blocks": kapdf.catalog(dash),
++    }
++
++
++@router.post("/report/custom")
++def stats_report_custom(
++    spec: dict = Body(...),
++    db: Session = Depends(get_db),
++) -> Response:
++    """v3 — rapport PDF personnalisé : ``{"title", "period", "from", "to",
++    "blocks": [{"key": "series:…", "render": "bar"}, …]}`` (SPEC.md §3bis)."""
++    period = str(spec.get("period") or "30j")
++    if period not in PERIOD_LABELS:
++        period = "30j"
++
++    def _date(v: Any) -> datetime.date | None:
++        try:
++            return datetime.date.fromisoformat(str(v)) if v else None
++        except ValueError:
++            return None
++
++    dash = _dashboard_cached(db, period, _date(spec.get("from")), _date(spec.get("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_bytes = kapdf.GroupeKAReport(
++        site=SITE,
++        dashboard=dash,
++        mode=kapdf.CUSTOM_MODE,
++        spec={"title": str(spec.get("title") or "")[:80], "blocks": blocks},
++    ).build()
++    fname = kapdf.filename(PLATFORM_ID, period, kapdf.CUSTOM_MODE)
++    return Response(
++        content=pdf_bytes,
++        media_type="application/pdf",
++        headers={"Content-Disposition": f'attachment; filename="{fname}"'},
++    )
++
++
+ # ------------------------------------------------- rapport écosystème (PDF)
+ async def _fetch_satellite_dashboard(
+     client: httpx.AsyncClient, site: dict, period: str

modified src/api/web/stats.html +243 −0

+ .sec-gap{margin-top:30px}
+ @media(max-width:767px){section{padding:32px 0}.hero-s{padding:40px 0 32px}}
+ @media(prefers-reduced-motion:reduce){*{transition:none!important}}
++/* ---------- v3 : constructeur de rapports personnalisés ---------- */
++.stb-overlay{position:fixed;inset:0;z-index:var(--z-modal,900);background:rgba(20,24,20,.45);
++  display:flex;align-items:flex-start;justify-content:center;padding:4vh 14px;overflow:auto}
++.stb-panel{background:var(--surface);border:1px solid var(--ink);border-radius:12px;
++  width:min(980px,100%);max-height:92vh;display:flex;flex-direction:column;
++  box-shadow:0 18px 48px rgba(20,24,20,.3)}
++.stb-head{display:flex;justify-content:space-between;align-items:center;gap:10px;
++  padding:16px 20px;border-bottom:1px solid var(--line)}
++.stb-head h2{margin:0;font-size:18px}
++.stb-body{display:grid;grid-template-columns:1fr 1fr;gap:0;overflow:auto;flex:1}
++@media(max-width:760px){.stb-body{grid-template-columns:1fr}}
++.stb-col{padding:14px 20px;min-width:0}
++.stb-col+.stb-col{border-left:1px solid var(--line)}
++@media(max-width:760px){.stb-col+.stb-col{border-left:0;border-top:1px solid var(--line)}}
++.stb-col h3{margin:4px 0 10px;font-size:12px;font-family:var(--font-mono);
++  text-transform:uppercase;letter-spacing:.06em;color:var(--ink-3)}
++.stb-group{margin:0 0 6px;font-family:var(--font-mono);font-size:10.5px;font-weight:700;
++  text-transform:uppercase;letter-spacing:.06em;color:var(--ink-2);margin-top:12px}
++.stb-av{display:flex;justify-content:space-between;align-items:center;gap:8px;
++  padding:7px 10px;border:1px solid var(--line);border-radius:8px;margin-bottom:6px;font-size:13px}
++.stb-av button{flex:none}
++.stb-av.stb-in{opacity:.45}
++.stb-item{display:flex;align-items:center;gap:8px;padding:8px 10px;border:1px solid var(--ink);
++  border-radius:8px;margin-bottom:6px;background:var(--surface-2);font-size:13px}
++.stb-item .t{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
++.stb-item select{border:1px solid var(--line);border-radius:6px;background:var(--surface);
++  padding:4px 6px;font-size:12px;max-width:150px}
++.stb-item .mv{border:0;background:none;cursor:pointer;font-size:14px;padding:2px 4px;min-height:0}
++.stb-item .mv:disabled{opacity:.25;cursor:default}
++.stb-foot{display:flex;justify-content:space-between;align-items:center;gap:10px;flex-wrap:wrap;
++  padding:14px 20px;border-top:1px solid var(--line)}
++.stb-tpl{display:flex;gap:8px;align-items:center;flex-wrap:wrap}
++.stb-err{color:var(--danger);font-size:12.5px;margin:6px 0 0}
++.stb-empty{border:1px dashed var(--line);border-radius:8px;padding:16px;color:var(--ink-3);
++  font-size:13px;text-align:center}
++.hidden{display:none!important}
+ </style>
+ <link rel="canonical" href="https://www.api-ka.com/stats">
+ <link rel="alternate" hreflang="fr-ca" href="https://www.api-ka.com/stats">
+         <button type="button" data-mode="donnees" role="menuitem">Données détaillées<small>Tous les tableaux en version longue</small></button>
+       </span>
+     </span>
++    <button type="button" class="btn btn-ghost" id="st-custom-btn">🛠 Rapport personnalisé</button>
+     <span id="pdf-busy" role="status"></span>
+   </div>
+   <p class="fresh" style="margin-top:18px">
+   renderRecords(dash.records);
+ }
+ load();
++
++/* ==================== v3 : constructeur de rapports personnalisés ==========
++   Compose un PDF bloc par bloc : choix des données (catalogue du dashboard),
++   du rendu par bloc (courbe/aire/barres/anneau/heatmap/tableau…), de l'ordre,
++   et modèles sauvegardés (localStorage, propre au site = origine). */
++const $ = id => document.getElementById(id);
++function sbParams(){
++  const p = new URLSearchParams({period: state.period});
++  if(state.from && state.to){ p.set("from", state.from); p.set("to", state.to); }
++  return p.toString();
++}
++const SB = { cat:null, sel:[], title:"", busy:false, err:"" };
++const SB_TPL_KEY = "ka-stats-rapports";
++const SB_RENDERS = { 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 SB_SECTIONS = { 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" };
++
++function sbTemplates(){
++  try{ return JSON.parse(localStorage.getItem(SB_TPL_KEY) || "[]"); }
++  catch(e){ return []; }
++}
++function sbSaveTemplates(t){ localStorage.setItem(SB_TPL_KEY, JSON.stringify(t)); }
++
++async function sbOpen(){
++  let ov = $("st-builder");
++  if(!ov){
++    ov = document.createElement("div");
++    ov.id = "st-builder";
++    ov.className = "stb-overlay hidden";
++    ov.onclick = e => { if(e.target === ov) sbClose(); };
++    document.body.appendChild(ov);
++  }
++  ov.classList.remove("hidden");
++  document.body.style.overflow = "hidden";
++  SB.err = "";
++  if(!SB.cat){
++    ov.innerHTML = `<div class="stb-panel"><div class="stb-head">
++      <h2>Rapport personnalisé</h2></div>
++      <div class="stb-col"><p class="klabel">Chargement du catalogue…</p></div></div>`;
++    try{
++      SB.cat = (await (await fetch(`/api/stats/catalog?${sbParams()}`)).json()).blocks || [];
++    }catch(e){
++      ov.innerHTML = `<div class="stb-panel"><div class="stb-head"><h2>Rapport personnalisé</h2>
++        <button type="button" class="btn btn-ghost" onclick="sbClose()">✕ Fermer</button></div>
++        <div class="stb-col"><p class="stb-err">Catalogue indisponible — réessayez plus tard.</p></div></div>`;
++      return;
++    }
++  }
++  sbRender();
++}
++function sbClose(){
++  const ov = $("st-builder");
++  if(ov) ov.classList.add("hidden");
++  document.body.style.overflow = "";
++}
++
++function sbAdd(key){
++  const b = SB.cat.find(x => x.key === key);
++  if(!b || SB.sel.some(s => s.key === key && s.render === b.default_render)) return;
++  SB.sel.push({ key, render: b.default_render });
++  sbRender();
++}
++function sbDel(i){ SB.sel.splice(i, 1); sbRender(); }
++function sbMove(i, d){
++  const j = i + d;
++  if(j < 0 || j >= SB.sel.length) return;
++  [SB.sel[i], SB.sel[j]] = [SB.sel[j], SB.sel[i]];
++  sbRender();
++}
++function sbAll(){
++  SB.sel = SB.cat.map(b => ({ key: b.key, render: b.default_render }));
++  sbRender();
++}
++
++function sbRender(){
++  const ov = $("st-builder");
++  const groups = {};
++  SB.cat.forEach(b => (groups[b.section] = groups[b.section] || []).push(b));
++  const selKeys = new Set(SB.sel.map(s => s.key));
++  const perLabel = (state.from && state.to) ? `${state.from} → ${state.to}`
++    : (PERIODS.find(p => p.id === state.period) || {label:"30 jours"}).label;
++  const tpls = sbTemplates();
++
++  ov.innerHTML = `<div class="stb-panel">
++    <div class="stb-head">
++      <h2>Rapport personnalisé <span class="klabel">· période : ${esc(perLabel)}</span></h2>
++      <button type="button" class="btn btn-ghost" id="stb-close">✕ Fermer</button>
++    </div>
++    <div class="stb-body">
++      <div class="stb-col">
++        <h3>Blocs disponibles (${SB.cat.length})</h3>
++        <p class="klabel" style="margin:0 0 10px">Cliquez « + » pour ajouter un bloc au rapport.
++          Un même bloc peut être ajouté sous plusieurs rendus.</p>
++        ${Object.entries(groups).map(([sec, bs]) => `
++          <p class="stb-group">${esc(SB_SECTIONS[sec] || sec)}</p>
++          ${bs.map(b => `<div class="stb-av${selKeys.has(b.key) ? " stb-in" : ""}">
++            <span style="min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap"
++              title="${esc(b.title)}">${esc(b.title)}</span>
++            <button type="button" class="btn btn-ghost" data-add="${esc(b.key)}"
++              aria-label="Ajouter ${esc(b.title)}">+</button></div>`).join("")}`).join("")}
++      </div>
++      <div class="stb-col">
++        <h3>Composition du rapport (${SB.sel.length})</h3>
++        <label class="klabel" for="stb-title">Titre du rapport</label>
++        <input class="input" id="stb-title" style="width:100%;margin:4px 0 12px"
++          maxlength="80" placeholder="Ex. : Revue mensuelle" value="${esc(SB.title)}">
++        ${SB.sel.length ? SB.sel.map((s, i) => {
++          const b = SB.cat.find(x => x.key === s.key) || { title: s.key, renders: [s.render] };
++          return `<div class="stb-item">
++            <button type="button" class="mv" data-up="${i}" ${i === 0 ? "disabled" : ""} aria-label="Monter">▲</button>
++            <button type="button" class="mv" data-dn="${i}" ${i === SB.sel.length - 1 ? "disabled" : ""} aria-label="Descendre">▼</button>
++            <span class="t" title="${esc(b.title)}"><b>${i + 1}.</b> ${esc(b.title)}</span>
++            ${b.renders.length > 1 ? `<select data-rd="${i}" aria-label="Rendu">
++              ${b.renders.map(r => `<option value="${r}"${r === s.render ? " selected" : ""}>${SB_RENDERS[r] || r}</option>`).join("")}
++            </select>` : `<span class="klabel">${SB_RENDERS[s.render] || s.render}</span>`}
++            <button type="button" class="mv" data-del="${i}" aria-label="Retirer">✕</button>
++          </div>`;
++        }).join("") : `<div class="stb-empty">Aucun bloc — ajoutez des blocs depuis la colonne de gauche,
++          ou chargez un modèle ci-dessous.</div>`}
++        <p style="display:flex;gap:8px;margin:10px 0 0">
++          <button type="button" class="btn btn-ghost" id="stb-all">Tout ajouter</button>
++          <button type="button" class="btn btn-ghost" id="stb-clear" ${SB.sel.length ? "" : "disabled"}>Vider</button>
++        </p>
++        ${SB.err ? `<p class="stb-err">${esc(SB.err)}</p>` : ""}
++      </div>
++    </div>
++    <div class="stb-foot">
++      <span class="stb-tpl">
++        <select class="input" id="stb-tpl" aria-label="Modèles sauvegardés" style="max-width:210px">
++          <option value="">Modèles (${tpls.length})…</option>
++          ${tpls.map((t, i) => `<option value="${i}">${esc(t.name)}</option>`).join("")}
++        </select>
++        <button type="button" class="btn btn-ghost" id="stb-save" ${SB.sel.length ? "" : "disabled"}>💾 Sauvegarder</button>
++        <button type="button" class="btn btn-ghost" id="stb-tpl-del" ${tpls.length ? "" : "disabled"}>🗑 Supprimer</button>
++      </span>
++      <button type="button" class="btn btn-primary" id="stb-go" ${SB.sel.length && !SB.busy ? "" : "disabled"}>
++        ${SB.busy ? "Génération…" : "⬇ Générer le PDF"}</button>
++    </div>
++  </div>`;
++
++  $("stb-close").onclick = sbClose;
++  $("stb-all").onclick = sbAll;
++  $("stb-clear").onclick = () => { SB.sel = []; sbRender(); };
++  $("stb-title").oninput = e => { SB.title = e.target.value; };
++  ov.querySelectorAll("[data-add]").forEach(b => b.onclick = () => sbAdd(b.dataset.add));
++  ov.querySelectorAll("[data-up]").forEach(b => b.onclick = () => sbMove(+b.dataset.up, -1));
++  ov.querySelectorAll("[data-dn]").forEach(b => b.onclick = () => sbMove(+b.dataset.dn, 1));
++  ov.querySelectorAll("[data-del]").forEach(b => b.onclick = () => sbDel(+b.dataset.del));
++  ov.querySelectorAll("[data-rd]").forEach(sl => sl.onchange = () => {
++    SB.sel[+sl.dataset.rd].render = sl.value;
++  });
++  $("stb-save").onclick = () => {
++    const name = prompt("Nom du modèle :", SB.title || "Mon rapport");
++    if(!name) return;
++    const tpl = sbTemplates().filter(t => t.name !== name);
++    tpl.push({ name, title: SB.title, blocks: SB.sel.map(s => ({...s})) });
++    sbSaveTemplates(tpl);
++    sbRender();
++  };
++  $("stb-tpl").onchange = e => {
++    const t = sbTemplates()[+e.target.value];
++    if(!t) return;
++    SB.title = t.title || t.name;
++    SB.sel = (t.blocks || []).filter(s => SB.cat.some(b => b.key === s.key)).map(s => ({...s}));
++    sbRender();
++  };
++  $("stb-tpl-del").onclick = () => {
++    const sel = $("stb-tpl");
++    const t = sbTemplates()[+sel.value];
++    if(!t || !confirm(`Supprimer le modèle « ${t.name} » ?`)) return;
++    sbSaveTemplates(sbTemplates().filter(x => x.name !== t.name));
++    sbRender();
++  };
++  $("stb-go").onclick = sbGenerate;
++}
++
++async function sbGenerate(){
++  if(SB.busy || !SB.sel.length) return;
++  SB.busy = true; SB.err = ""; sbRender();
++  try{
++    const body = { title: SB.title, period: state.period, blocks: SB.sel };
++    if(state.from && state.to){ body.from = state.from; body.to = state.to; }
++    const r = await fetch("/api/stats/report/custom", {
++      method: "POST", headers: { "Content-Type": "application/json" },
++      body: JSON.stringify(body) });
++    if(!r.ok) throw new Error(`HTTP ${r.status}`);
++    const blob = await r.blob();
++    const cd = r.headers.get("Content-Disposition") || "";
++    const m = cd.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(e){
++    SB.err = "La génération a échoué — réessayez.";
++  }
++  SB.busy = false; sbRender();
++}
++
++$("st-custom-btn").onclick = () => { SB.cat = null; SB.err = ""; sbOpen(); };
+ </script>
+ <script>window.KA_AGENT={site:"api-ka"}</script>
+ <script src="/ka-agent.js" defer></script>

spb/api-ka

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

Theme