feat: add report_export widget and enhance report generation capabilities
- Introduced the `report_export` widget to the dashboard, allowing users to generate structured PDF reports. - Updated widget configuration to include `report_export` in the allowed widgets and added validation for its configuration. - Enhanced the widget catalog with details for the new `report_export` entry. - Implemented API endpoints for managing report profiles and generating PDFs. - Added frontend components for configuring and displaying report settings. - Updated tests to ensure proper validation and functionality of the new report generation features. - Bumped application version to reflect the addition of the new widget and related functionalities.
This commit is contained in:
1 parent
141df021c1
commit
62729d0648
22 files changed
+1389
-7
No files matched your search
@@ -25,6 +25,7 @@ WIDGETS_ALLOWING_CONFIG: frozenset[str] = frozenset({
|
||||
"trend_kcal_weight",
|
||||
"nutrition_detail_charts",
|
||||
"recovery_charts_panel",
|
||||
"report_export",
|
||||
})
|
||||
|
||||
_QUICK_CAPTURE_KEYS: frozenset[str] = frozenset({
|
||||
@@ -201,6 +202,8 @@ def validate_widget_entry_config(widget_id: str, raw: Any) -> dict[str, Any]:
|
||||
return _validate_recovery_history_viz_config({})
|
||||
if widget_id == "history_overview_viz":
|
||||
return _validate_history_overview_viz_config({})
|
||||
if widget_id == "report_export":
|
||||
return _validate_report_export_config({})
|
||||
return {}
|
||||
|
||||
if widget_id == "body_overview":
|
||||
@@ -227,6 +230,8 @@ def validate_widget_entry_config(widget_id: str, raw: Any) -> dict[str, Any]:
|
||||
return _validate_chart_days_only(raw, label="nutrition_detail_charts")
|
||||
if widget_id == "recovery_charts_panel":
|
||||
return _validate_chart_days_only(raw, label="recovery_charts_panel")
|
||||
if widget_id == "report_export":
|
||||
return _validate_report_export_config(raw)
|
||||
|
||||
raise ValueError(f"Widget {widget_id}: keine Konfiguration unterstützt")
|
||||
|
||||
@@ -530,3 +535,43 @@ def _validate_chart_days_only(raw: dict[str, Any], *, label: str) -> dict[str, A
|
||||
return {"chart_days": v}
|
||||
|
||||
|
||||
def _validate_report_export_config(raw: dict[str, Any]) -> dict[str, Any]:
|
||||
label = "report_export"
|
||||
allowed = frozenset({"document_title", "subtitle", "capture_scale"})
|
||||
unknown = set(raw) - allowed
|
||||
if unknown:
|
||||
raise ValueError(f"{label}: unbekannte config-Felder: {sorted(unknown)}")
|
||||
out: dict[str, Any] = {"capture_scale": 2}
|
||||
if "document_title" in raw:
|
||||
t = raw["document_title"]
|
||||
if t is not None and not isinstance(t, str):
|
||||
raise ValueError(f"{label}: document_title muss Text sein")
|
||||
s = (t or "").strip()
|
||||
if len(s) > 120:
|
||||
raise ValueError(f"{label}: document_title max. 120 Zeichen")
|
||||
if s:
|
||||
out["document_title"] = s
|
||||
if "subtitle" in raw:
|
||||
t = raw["subtitle"]
|
||||
if t is not None and not isinstance(t, str):
|
||||
raise ValueError(f"{label}: subtitle muss Text sein")
|
||||
s = (t or "").strip()
|
||||
if len(s) > 240:
|
||||
raise ValueError(f"{label}: subtitle max. 240 Zeichen")
|
||||
if s:
|
||||
out["subtitle"] = s
|
||||
if "capture_scale" in raw:
|
||||
v = raw["capture_scale"]
|
||||
if isinstance(v, bool) or isinstance(v, float):
|
||||
if isinstance(v, float) and math.isfinite(v) and abs(v - round(v)) < 1e-9:
|
||||
v = int(round(v))
|
||||
else:
|
||||
raise ValueError(f"{label}: capture_scale muss ganze Zahl 1–3 sein")
|
||||
if not isinstance(v, int):
|
||||
raise ValueError(f"{label}: capture_scale muss ganze Zahl 1–3 sein")
|
||||
if v < 1 or v > 3:
|
||||
raise ValueError(f"{label}: capture_scale muss zwischen 1 und 3 liegen")
|
||||
out["capture_scale"] = v
|
||||
return out
|
||||
|
||||
|
||||
@@ -35,6 +35,7 @@ from routers import workflows # Phase 2 Workflow Engine - Execution
|
||||
from routers import reference_values # Persönliche Referenzwerte (Profil)
|
||||
from routers import admin_reference_value_types # Admin: Referenzwert-Typen
|
||||
from routers import app_dashboard # Geschützter App-Bereich: Dashboard-Layout + Widget-Katalog
|
||||
from routers import reports # Strukturierter PDF-Bericht (Profil v1)
|
||||
from routers import csv_import, admin_csv_templates # Issue #21 Universal CSV Parser
|
||||
from routers import admin_training_parameters, admin_activity_attribute_profiles # EAV session metrics
|
||||
|
||||
@@ -127,6 +128,7 @@ app.include_router(workflows.router) # /api/workflows/* (Phase 2 Exec
|
||||
app.include_router(reference_values.router) # /api/reference-value-types, /api/profile-reference-values
|
||||
app.include_router(admin_reference_value_types.router) # /api/admin/reference-value-types
|
||||
app.include_router(app_dashboard.router) # /api/app/dashboard-layout
|
||||
app.include_router(reports.router) # /api/reports/* (Berichtsprofil + PDF)
|
||||
app.include_router(csv_import.router) # /api/csv/* (Issue #21)
|
||||
app.include_router(admin_csv_templates.router) # /api/admin/csv-templates/* (Issue #21)
|
||||
app.include_router(admin_training_parameters.router) # /api/admin/training-parameters
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
-- Migration 060: Strukturierter Bericht (Profil JSON pro Nutzerprofil, unabhängig vom Dashboard-Layout)
|
||||
|
||||
CREATE TABLE IF NOT EXISTS report_profiles (
|
||||
profile_id UUID PRIMARY KEY REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
payload JSONB NOT NULL DEFAULT '{}'::jsonb,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_report_profiles_updated ON report_profiles(updated_at);
|
||||
|
||||
COMMENT ON TABLE report_profiles IS 'Konfigurierbarer PDF-Bericht v1 (Blöcke: section, chart, ai_insight); Rendering serverseitig aus Datenlayer';
|
||||
@@ -0,0 +1,139 @@
|
||||
"""
|
||||
Chart-Daten für Berichts-PDF: dieselbe Logik wie /api/charts/* (Data Layer), ohne HTTP.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, Callable
|
||||
|
||||
from data_layer.activity_metrics import (
|
||||
build_training_type_distribution_chart_payload,
|
||||
build_training_volume_chart_payload,
|
||||
)
|
||||
from data_layer.body_metrics import get_weight_trend_data
|
||||
from data_layer.nutrition_chart_payloads import build_energy_balance_chart_payload
|
||||
from data_layer.nutrition_metrics import get_nutrition_average_data
|
||||
from data_layer.utils import serialize_dates
|
||||
|
||||
|
||||
def _weight_trend_payload(profile_id: str, days: int) -> dict[str, Any]:
|
||||
d = min(max(days, 7), 365)
|
||||
trend_data = get_weight_trend_data(profile_id, d)
|
||||
if trend_data["confidence"] == "insufficient":
|
||||
return {
|
||||
"chart_type": "line",
|
||||
"data": {"labels": [], "datasets": []},
|
||||
"metadata": {
|
||||
"confidence": "insufficient",
|
||||
"data_points": 0,
|
||||
"message": "Nicht genug Daten für Trend-Analyse",
|
||||
},
|
||||
}
|
||||
series = trend_data.get("series") or []
|
||||
labels = [
|
||||
pt["date"].isoformat() if hasattr(pt["date"], "isoformat") else str(pt["date"]) for pt in series
|
||||
]
|
||||
values = [pt["weight"] for pt in series]
|
||||
return {
|
||||
"chart_type": "line",
|
||||
"data": {
|
||||
"labels": labels,
|
||||
"datasets": [
|
||||
{
|
||||
"label": "Gewicht",
|
||||
"data": values,
|
||||
"borderColor": "#1D9E75",
|
||||
"backgroundColor": "rgba(29, 158, 117, 0.1)",
|
||||
"borderWidth": 2,
|
||||
"tension": 0.4,
|
||||
"fill": True,
|
||||
"pointRadius": 2,
|
||||
}
|
||||
],
|
||||
},
|
||||
"metadata": serialize_dates(
|
||||
{
|
||||
"confidence": trend_data["confidence"],
|
||||
"data_points": trend_data["data_points"],
|
||||
"first_value": trend_data["first_value"],
|
||||
"last_value": trend_data["last_value"],
|
||||
"delta": trend_data["delta"],
|
||||
"direction": trend_data["direction"],
|
||||
}
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def _macro_distribution_payload(profile_id: str, days: int) -> dict[str, Any]:
|
||||
d = min(max(days, 7), 90)
|
||||
macro_data = get_nutrition_average_data(profile_id, d)
|
||||
if macro_data["confidence"] == "insufficient":
|
||||
return {
|
||||
"chart_type": "pie",
|
||||
"data": {"labels": [], "datasets": []},
|
||||
"metadata": {"confidence": "insufficient", "message": "Keine Ernährungsdaten vorhanden"},
|
||||
}
|
||||
protein_kcal = macro_data["protein_avg"] * 4
|
||||
carbs_kcal = macro_data["carbs_avg"] * 4
|
||||
fat_kcal = macro_data["fat_avg"] * 9
|
||||
total_kcal = protein_kcal + carbs_kcal + fat_kcal
|
||||
if total_kcal == 0:
|
||||
return {
|
||||
"chart_type": "pie",
|
||||
"data": {"labels": [], "datasets": []},
|
||||
"metadata": {"confidence": "insufficient", "message": "Keine Makronährstoff-Daten"},
|
||||
}
|
||||
protein_pct = protein_kcal / total_kcal * 100
|
||||
carbs_pct = carbs_kcal / total_kcal * 100
|
||||
fat_pct = fat_kcal / total_kcal * 100
|
||||
return {
|
||||
"chart_type": "pie",
|
||||
"data": {
|
||||
"labels": ["Protein", "Kohlenhydrate", "Fett"],
|
||||
"datasets": [
|
||||
{
|
||||
"data": [round(protein_pct, 1), round(carbs_pct, 1), round(fat_pct, 1)],
|
||||
"backgroundColor": ["#1D9E75", "#F59E0B", "#EF4444"],
|
||||
"borderWidth": 2,
|
||||
"borderColor": "#fff",
|
||||
}
|
||||
],
|
||||
},
|
||||
"metadata": {"confidence": macro_data.get("confidence", "high")},
|
||||
}
|
||||
|
||||
|
||||
def _training_volume_payload(profile_id: str, window_days: int) -> dict[str, Any]:
|
||||
w = max(4, min(52, window_days // 7))
|
||||
return build_training_volume_chart_payload(profile_id, w)
|
||||
|
||||
|
||||
_CHART_FETCHERS: dict[str, Callable[[str, int], dict[str, Any]]] = {
|
||||
"weight_trend": _weight_trend_payload,
|
||||
"energy_balance": lambda pid, d: build_energy_balance_chart_payload(pid, min(max(d, 7), 90)),
|
||||
"macro_distribution": _macro_distribution_payload,
|
||||
"training_volume": _training_volume_payload,
|
||||
"training_type_distribution": lambda pid, d: build_training_type_distribution_chart_payload(
|
||||
pid, min(max(d, 7), 90)
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def fetch_chart_payload(chart_id: str, profile_id: str, window_days: int) -> dict[str, Any]:
|
||||
fn = _CHART_FETCHERS.get(chart_id)
|
||||
if not fn:
|
||||
raise ValueError(f"Unbekanntes chart_id: {chart_id}")
|
||||
return fn(profile_id, window_days)
|
||||
|
||||
|
||||
CHART_CATALOG_FOR_API: list[dict[str, Any]] = [
|
||||
{"id": "weight_trend", "title": "Gewichtstrend", "default_window_days": 90, "window_max": 365},
|
||||
{"id": "energy_balance", "title": "Energiebilanz", "default_window_days": 28, "window_max": 90},
|
||||
{"id": "macro_distribution", "title": "Makroverteilung (Ø)", "default_window_days": 28, "window_max": 90},
|
||||
{"id": "training_volume", "title": "Trainingsvolumen (Wochen)", "default_window_days": 84, "window_max": 365},
|
||||
{
|
||||
"id": "training_type_distribution",
|
||||
"title": "Trainingsart-Verteilung",
|
||||
"default_window_days": 28,
|
||||
"window_max": 90,
|
||||
},
|
||||
]
|
||||
@@ -0,0 +1,212 @@
|
||||
"""
|
||||
PDF-Bericht aus ReportProfilePayload: ReportLab für Text/Layout, Matplotlib für Chart.js-ähnliche Payloads.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import io
|
||||
import logging
|
||||
from typing import Any
|
||||
from xml.sax.saxutils import escape
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt
|
||||
from reportlab.lib.pagesizes import A4
|
||||
from reportlab.lib.styles import getSampleStyleSheet
|
||||
from reportlab.lib.units import mm
|
||||
from reportlab.platypus import Image as RLImage
|
||||
from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer
|
||||
|
||||
from db import get_cursor, get_db
|
||||
from report_chart_fetch import fetch_chart_payload
|
||||
from report_profile_schema import (
|
||||
AiInsightBlock,
|
||||
ChartBlock,
|
||||
ReportProfilePayload,
|
||||
SectionBlock,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
_CONTENT_TRUNCATE = 12000
|
||||
|
||||
|
||||
def _color_to_rgb(hex_or_rgba: str) -> tuple[float, float, float]:
|
||||
s = (hex_or_rgba or "#333333").strip()
|
||||
if s.startswith("#") and len(s) >= 7:
|
||||
try:
|
||||
r = int(s[1:3], 16) / 255.0
|
||||
g = int(s[3:5], 16) / 255.0
|
||||
b = int(s[5:7], 16) / 255.0
|
||||
return (r, g, b)
|
||||
except ValueError:
|
||||
pass
|
||||
return (0.12, 0.62, 0.46)
|
||||
|
||||
|
||||
def chart_payload_to_png(payload: dict[str, Any], fig_width_in: float = 6.2, fig_height_in: float = 3.4) -> bytes:
|
||||
"""Erzeugt PNG aus Chart.js-kompatiblem Payload (line, bar, pie)."""
|
||||
chart_type = payload.get("chart_type") or "line"
|
||||
data = payload.get("data") or {}
|
||||
labels = data.get("labels") or []
|
||||
datasets = data.get("datasets") or []
|
||||
|
||||
fig, ax = plt.subplots(figsize=(fig_width_in, fig_height_in), dpi=120)
|
||||
ax.set_facecolor("#fafaf9")
|
||||
fig.patch.set_facecolor("#ffffff")
|
||||
|
||||
if chart_type == "pie" and datasets:
|
||||
ds0 = datasets[0]
|
||||
values = ds0.get("data") or []
|
||||
colors = ds0.get("backgroundColor") or ["#1D9E75", "#378ADD", "#D85A30"]
|
||||
if labels and values and len(labels) == len(values):
|
||||
ax.pie(values, labels=labels, autopct="%1.0f%%", colors=colors[: len(values)], startangle=90)
|
||||
ax.axis("equal")
|
||||
else:
|
||||
ax.text(0.5, 0.5, "Keine Daten", ha="center", va="center", transform=ax.transAxes)
|
||||
|
||||
elif chart_type in ("line", "bar", "scatter") and datasets:
|
||||
x = range(len(labels)) if labels else []
|
||||
for i, ds in enumerate(datasets):
|
||||
y = ds.get("data") or []
|
||||
if not y:
|
||||
continue
|
||||
lab = ds.get("label") or f"Serie {i + 1}"
|
||||
col = _color_to_rgb(str(ds.get("borderColor") or ds.get("backgroundColor") or "#1D9E75"))
|
||||
if chart_type == "bar":
|
||||
yv = y[: len(labels)] if labels else y
|
||||
bg = ds.get("backgroundColor")
|
||||
if isinstance(bg, list):
|
||||
cols = [_color_to_rgb(str(c)) for c in bg[: len(yv)]]
|
||||
else:
|
||||
cols = [_color_to_rgb(str(bg or "#1D9E75"))] * len(yv)
|
||||
ax.bar(list(range(len(yv))), yv, label=lab, color=cols[: len(yv)], alpha=0.88)
|
||||
else:
|
||||
ax.plot(
|
||||
list(x)[: len(y)],
|
||||
y,
|
||||
label=lab,
|
||||
color=col,
|
||||
linewidth=1.6,
|
||||
marker="o",
|
||||
markersize=2,
|
||||
)
|
||||
if labels and chart_type != "bar":
|
||||
step = max(1, len(labels) // 8)
|
||||
ax.set_xticks(list(x)[::step])
|
||||
ax.set_xticklabels([labels[j] for j in range(0, len(labels), step)], rotation=25, fontsize=7)
|
||||
elif labels and chart_type == "bar":
|
||||
ax.set_xticks(list(x))
|
||||
ax.set_xticklabels(labels, rotation=30, fontsize=7)
|
||||
ax.legend(loc="upper right", fontsize=7)
|
||||
ax.grid(True, alpha=0.25)
|
||||
ax.set_xmargin(0.02)
|
||||
|
||||
else:
|
||||
ax.text(0.5, 0.5, "Diagrammtyp nicht unterstützt oder leer", ha="center", va="center", transform=ax.transAxes)
|
||||
|
||||
fig.tight_layout()
|
||||
buf = io.BytesIO()
|
||||
fig.savefig(buf, format="png", bbox_inches="tight", facecolor=fig.get_facecolor())
|
||||
plt.close(fig)
|
||||
buf.seek(0)
|
||||
return buf.read()
|
||||
|
||||
|
||||
def _insight_text(profile_id: str, insight_id: str | None) -> tuple[str, str]:
|
||||
"""Returns (heading, body_text)."""
|
||||
if not insight_id:
|
||||
return (
|
||||
"KI-Auswertung",
|
||||
"(Noch keine Auswahl — in einer späteren Version kannst du hier eine gespeicherte KI-Analyse "
|
||||
"verknüpfen.)",
|
||||
)
|
||||
try:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT scope, content, created FROM ai_insights WHERE id = %s AND profile_id = %s",
|
||||
(insight_id, profile_id),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
return ("KI-Auswertung", "Eintrag nicht gefunden oder keine Berechtigung.")
|
||||
scope = row.get("scope") or "Analyse"
|
||||
content = row.get("content") or ""
|
||||
if len(content) > _CONTENT_TRUNCATE:
|
||||
content = content[:_CONTENT_TRUNCATE] + "\n\n[… gekürzt …]"
|
||||
created = row.get("created")
|
||||
sub = f"{scope}" + (f" · {created}" if created else "")
|
||||
return (sub, content)
|
||||
except Exception as e:
|
||||
logger.warning("report pdf insight load failed: %s", e)
|
||||
return ("KI-Auswertung", "Fehler beim Laden des Eintrags.")
|
||||
|
||||
|
||||
def build_structured_report_pdf(
|
||||
*,
|
||||
profile_id: str,
|
||||
profile_name: str,
|
||||
payload: ReportProfilePayload,
|
||||
) -> bytes:
|
||||
"""Vollständiges PDF als Bytes (A4)."""
|
||||
buf = io.BytesIO()
|
||||
doc = SimpleDocTemplate(
|
||||
buf,
|
||||
pagesize=A4,
|
||||
leftMargin=14 * mm,
|
||||
rightMargin=14 * mm,
|
||||
topMargin=16 * mm,
|
||||
bottomMargin=16 * mm,
|
||||
)
|
||||
styles = getSampleStyleSheet()
|
||||
story: list[Any] = []
|
||||
|
||||
title = (payload.document_title or "").strip() or f"{profile_name} – Bericht"
|
||||
story.append(Paragraph(escape(title), styles["Title"]))
|
||||
story.append(Spacer(1, 6 * mm))
|
||||
|
||||
for block in payload.blocks:
|
||||
if isinstance(block, SectionBlock):
|
||||
story.append(Spacer(1, 4 * mm))
|
||||
story.append(Paragraph(escape(block.title), styles["Heading2"]))
|
||||
story.append(Spacer(1, 2 * mm))
|
||||
elif isinstance(block, ChartBlock):
|
||||
try:
|
||||
chart = fetch_chart_payload(block.chart_id, profile_id, block.window_days)
|
||||
except Exception as e:
|
||||
logger.warning("chart fetch %s: %s", block.chart_id, e)
|
||||
story.append(Paragraph(f"Diagramm {block.chart_id}: Fehler bei Daten.", styles["Normal"]))
|
||||
continue
|
||||
meta = chart.get("metadata") or {}
|
||||
if meta.get("confidence") == "insufficient":
|
||||
msg = meta.get("message") or "Nicht genug Daten"
|
||||
story.append(Paragraph(f"<i>{block.chart_id}</i>: {msg}", styles["Normal"]))
|
||||
story.append(Spacer(1, 3 * mm))
|
||||
continue
|
||||
try:
|
||||
png = chart_payload_to_png(chart)
|
||||
img_buf = io.BytesIO(png)
|
||||
# Breite ~ volle Textbreite (~180mm auf A4 mit Standardrändern Platypus)
|
||||
iw = 170 * mm
|
||||
ih = 85 * mm
|
||||
story.append(RLImage(img_buf, width=iw, height=ih))
|
||||
except Exception as e:
|
||||
logger.warning("chart render %s: %s", block.chart_id, e)
|
||||
story.append(Paragraph(f"Diagramm {block.chart_id}: Darstellung fehlgeschlagen.", styles["Normal"]))
|
||||
story.append(Spacer(1, 4 * mm))
|
||||
elif isinstance(block, AiInsightBlock):
|
||||
heading, body = _insight_text(profile_id, block.insight_id)
|
||||
if block.title.strip():
|
||||
story.append(Paragraph(escape(block.title), styles["Heading3"]))
|
||||
else:
|
||||
story.append(Paragraph(escape(heading), styles["Heading3"]))
|
||||
for para in body.split("\n\n"):
|
||||
p = (para or "").strip()
|
||||
if p:
|
||||
story.append(Paragraph(escape(p), styles["BodyText"]))
|
||||
story.append(Spacer(1, 4 * mm))
|
||||
|
||||
doc.build(story)
|
||||
return buf.getvalue()
|
||||
@@ -0,0 +1,92 @@
|
||||
"""
|
||||
Konfigurierbarer PDF-Bericht v1: Payload-Schema (unabhängig vom Dashboard-Layout).
|
||||
|
||||
Block-Typen:
|
||||
- section: Überschrift
|
||||
- chart: diagramm via report_chart_fetch (chart_id + window_days)
|
||||
- ai_insight: optional insight_id (UUID), sonst Platzhalter für spätere Auswahl
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Literal, Union
|
||||
|
||||
from pydantic import BaseModel, Field, model_validator
|
||||
|
||||
ALLOWED_CHART_IDS: frozenset[str] = frozenset(
|
||||
{
|
||||
"weight_trend",
|
||||
"energy_balance",
|
||||
"macro_distribution",
|
||||
"training_volume",
|
||||
"training_type_distribution",
|
||||
}
|
||||
)
|
||||
|
||||
_MAX_BLOCKS = 24
|
||||
|
||||
|
||||
class SectionBlock(BaseModel):
|
||||
type: Literal["section"] = "section"
|
||||
title: str = Field(min_length=1, max_length=200)
|
||||
|
||||
|
||||
class ChartBlock(BaseModel):
|
||||
type: Literal["chart"] = "chart"
|
||||
chart_id: str = Field(min_length=1, max_length=64)
|
||||
window_days: int = Field(default=28, ge=7, le=365)
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _chart_known(self) -> ChartBlock:
|
||||
if self.chart_id not in ALLOWED_CHART_IDS:
|
||||
raise ValueError(f"Unbekanntes chart_id: {self.chart_id!r} (erlaubt: {sorted(ALLOWED_CHART_IDS)})")
|
||||
return self
|
||||
|
||||
|
||||
class AiInsightBlock(BaseModel):
|
||||
type: Literal["ai_insight"] = "ai_insight"
|
||||
title: str = Field(default="", max_length=200)
|
||||
insight_id: str | None = Field(default=None, max_length=48)
|
||||
|
||||
|
||||
class ReportProfilePayload(BaseModel):
|
||||
version: Literal[1] = 1
|
||||
document_title: str = Field(default="", max_length=120)
|
||||
blocks: list[Union[SectionBlock, ChartBlock, AiInsightBlock]]
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _blocks_limit(self) -> ReportProfilePayload:
|
||||
if len(self.blocks) > _MAX_BLOCKS:
|
||||
raise ValueError(f"Maximal {_MAX_BLOCKS} Blöcke erlaubt")
|
||||
if not self.blocks:
|
||||
raise ValueError("Mindestens ein Block erforderlich")
|
||||
return self
|
||||
|
||||
def to_stored_dict(self) -> dict:
|
||||
return {
|
||||
"version": self.version,
|
||||
"document_title": self.document_title,
|
||||
"blocks": [b.model_dump(mode="json") for b in self.blocks],
|
||||
}
|
||||
|
||||
|
||||
def default_report_profile_dict() -> dict:
|
||||
"""Standard-Bericht beim ersten Zugriff (ohne DB-Zeile)."""
|
||||
p = ReportProfilePayload(
|
||||
document_title="",
|
||||
blocks=[
|
||||
SectionBlock(title="Körpergewicht"),
|
||||
ChartBlock(chart_id="weight_trend", window_days=90),
|
||||
SectionBlock(title="Energiebilanz"),
|
||||
ChartBlock(chart_id="energy_balance", window_days=28),
|
||||
SectionBlock(title="Trainingsvolumen"),
|
||||
ChartBlock(chart_id="training_volume", window_days=84),
|
||||
],
|
||||
)
|
||||
return p.to_stored_dict()
|
||||
|
||||
|
||||
def parse_report_profile(raw: dict | None) -> ReportProfilePayload:
|
||||
if raw is None or raw == {}:
|
||||
return ReportProfilePayload.model_validate(default_report_profile_dict())
|
||||
return ReportProfilePayload.model_validate(raw)
|
||||
|
||||
@@ -10,3 +10,5 @@ slowapi==0.1.9
|
||||
psycopg2-binary==2.9.9
|
||||
python-dateutil==2.9.0
|
||||
tzdata>=2024.1 # ZoneInfo (Europe/Berlin) auch unter Windows
|
||||
matplotlib==3.8.4
|
||||
reportlab==4.2.0
|
||||
@@ -0,0 +1,156 @@
|
||||
"""
|
||||
Strukturierter PDF-Bericht (Profil v1): GET/PUT Profil, Katalog, PDF-Erzeugung.
|
||||
|
||||
Trennung vom Dashboard-Layout; Daten aus data_layer wie /api/charts.
|
||||
PDF-Zähler: data_export (wie andere Exporte).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from fastapi.responses import Response
|
||||
from psycopg2.extras import Json
|
||||
|
||||
from auth import check_feature_access, increment_feature_usage, require_auth
|
||||
from db import get_cursor, get_db
|
||||
from feature_logger import log_feature_usage
|
||||
from report_chart_fetch import CHART_CATALOG_FOR_API
|
||||
from report_pdf_render import build_structured_report_pdf
|
||||
from report_profile_schema import (
|
||||
ReportProfilePayload,
|
||||
default_report_profile_dict,
|
||||
parse_report_profile,
|
||||
)
|
||||
|
||||
router = APIRouter(prefix="/api/reports", tags=["reports"])
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@router.get("/catalog")
|
||||
def get_reports_catalog(session: dict = Depends(require_auth)):
|
||||
"""Metadaten für UI: verfügbare Diagramme und Blocktypen."""
|
||||
return {
|
||||
"catalog_version": 1,
|
||||
"charts": CHART_CATALOG_FOR_API,
|
||||
"block_types": [
|
||||
{"id": "section", "title": "Überschrift"},
|
||||
{"id": "chart", "title": "Diagramm"},
|
||||
{"id": "ai_insight", "title": "KI-Auswertung"},
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _fetch_payload_row(profile_id: str) -> dict | None:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT payload FROM report_profiles WHERE profile_id = %s", (profile_id,))
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
return None
|
||||
p = row.get("payload")
|
||||
return p if isinstance(p, dict) else None
|
||||
|
||||
|
||||
def _profile_display_name(profile_id: str) -> str:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT name FROM profiles WHERE id = %s", (profile_id,))
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
return "Profil"
|
||||
return (row.get("name") or "Profil").strip() or "Profil"
|
||||
|
||||
|
||||
@router.get("/profile")
|
||||
def get_report_profile(session: dict = Depends(require_auth)):
|
||||
pid = session["profile_id"]
|
||||
raw = _fetch_payload_row(pid)
|
||||
if raw is None:
|
||||
return {"stored": False, "profile": default_report_profile_dict()}
|
||||
try:
|
||||
parse_report_profile(raw)
|
||||
except Exception as e:
|
||||
logger.warning("report profile invalid for %s: %s", pid, e)
|
||||
return {"stored": False, "profile": default_report_profile_dict(), "previous_invalid": True}
|
||||
return {"stored": True, "profile": raw}
|
||||
|
||||
|
||||
@router.put("/profile")
|
||||
def put_report_profile(body: dict, session: dict = Depends(require_auth)):
|
||||
pid = session["profile_id"]
|
||||
try:
|
||||
parsed = ReportProfilePayload.model_validate(body)
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=400, detail=str(e))
|
||||
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO report_profiles (profile_id, payload, updated_at)
|
||||
VALUES (%s, %s, CURRENT_TIMESTAMP)
|
||||
ON CONFLICT (profile_id) DO UPDATE SET
|
||||
payload = EXCLUDED.payload,
|
||||
updated_at = CURRENT_TIMESTAMP
|
||||
""",
|
||||
(pid, Json(parsed.to_stored_dict())),
|
||||
)
|
||||
conn.commit()
|
||||
return {"ok": True, "profile": parsed.to_stored_dict()}
|
||||
|
||||
|
||||
@router.delete("/profile")
|
||||
def delete_report_profile(session: dict = Depends(require_auth)):
|
||||
"""Zurück auf Code-Standard (kein DB-Eintrag)."""
|
||||
pid = session["profile_id"]
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM report_profiles WHERE profile_id = %s", (pid,))
|
||||
conn.commit()
|
||||
return {"ok": True, "profile": default_report_profile_dict()}
|
||||
|
||||
|
||||
@router.post("/generate-pdf")
|
||||
def generate_structured_report_pdf(session: dict = Depends(require_auth)):
|
||||
pid = session["profile_id"]
|
||||
|
||||
access = check_feature_access(pid, "data_export")
|
||||
log_feature_usage(pid, "data_export", access, "report_generate_pdf")
|
||||
if not access["allowed"]:
|
||||
logger.warning(
|
||||
"[FEATURE-LIMIT] report pdf blocked: %s used=%s limit=%s",
|
||||
pid,
|
||||
access.get("used"),
|
||||
access.get("limit"),
|
||||
)
|
||||
raise HTTPException(
|
||||
status_code=403,
|
||||
detail=(
|
||||
"Limit erreicht: Daten-Export nicht möglich "
|
||||
f"({access.get('used')}/{access.get('limit')})."
|
||||
),
|
||||
)
|
||||
|
||||
raw = _fetch_payload_row(pid)
|
||||
try:
|
||||
payload = parse_report_profile(raw)
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=400, detail=f"Berichtsprofil ungültig: {e}")
|
||||
|
||||
name = _profile_display_name(pid)
|
||||
try:
|
||||
pdf_bytes = build_structured_report_pdf(profile_id=pid, profile_name=name, payload=payload)
|
||||
except Exception as e:
|
||||
logger.exception("report pdf build failed")
|
||||
raise HTTPException(status_code=500, detail=f"PDF-Erzeugung fehlgeschlagen: {e}")
|
||||
|
||||
increment_feature_usage(pid, "data_export")
|
||||
safe_name = "".join(c for c in name if c.isalnum() or c in (" ", "-", "_")).strip() or "profil"
|
||||
fn = f"mitai-bericht-{safe_name.replace(' ', '-')}-{datetime.now().strftime('%Y-%m-%d')}.pdf"
|
||||
return Response(
|
||||
content=pdf_bytes,
|
||||
media_type="application/pdf",
|
||||
headers={"Content-Disposition": f'attachment; filename="{fn}"'},
|
||||
)
|
||||
@@ -0,0 +1,31 @@
|
||||
"""Berichtsprofil-Schema: Defaults und Validierung."""
|
||||
|
||||
from report_profile_schema import (
|
||||
ReportProfilePayload,
|
||||
default_report_profile_dict,
|
||||
parse_report_profile,
|
||||
)
|
||||
|
||||
|
||||
def test_default_profile_roundtrip():
|
||||
d = default_report_profile_dict()
|
||||
p = ReportProfilePayload.model_validate(d)
|
||||
assert p.version == 1
|
||||
assert len(p.blocks) >= 3
|
||||
|
||||
|
||||
def test_parse_empty_uses_default():
|
||||
p = parse_report_profile({})
|
||||
assert len(p.blocks) >= 1
|
||||
|
||||
|
||||
def test_chart_block_unknown_id_raises():
|
||||
import pytest
|
||||
|
||||
raw = {
|
||||
"version": 1,
|
||||
"document_title": "",
|
||||
"blocks": [{"type": "chart", "chart_id": "not_a_chart", "window_days": 28}],
|
||||
}
|
||||
with pytest.raises(Exception):
|
||||
ReportProfilePayload.model_validate(raw)
|
||||
@@ -149,6 +149,12 @@ WIDGET_CATALOG: list[WidgetCatalogEntry] = [
|
||||
"description": "Pipeline starten + Gesamt-Insight; Feature ai_pipeline",
|
||||
"requires_feature": "ai_pipeline",
|
||||
},
|
||||
{
|
||||
"id": "report_export",
|
||||
"title": "Übersicht als Bild-PDF",
|
||||
"description": "Raster-PDF der Startübersicht (html2canvas); für strukturierten Datenbericht siehe Einstellungen. Optional document_title, subtitle, capture_scale; data_export",
|
||||
"requires_feature": "data_export",
|
||||
},
|
||||
]
|
||||
|
||||
DEFAULT_LAB_WIDGET_IDS: frozenset[str] = frozenset(
|
||||
|
||||
Reference in new issue
Block a user