From 8a578d8aa1ba11da64c529d72dbee1d4f0827e41 Mon Sep 17 00:00:00 2001 From: neodk2004 Date: Sun, 2 Aug 2026 09:41:38 +0200 Subject: [PATCH] pflegepilot_v3: Admin-Dashboard - E-Mail-Log, Scheduler-Status, Speicherplatz, Statistik-Seite, Test-Mail, Konto-Hartloeschen E-Mail-Versand-Protokoll (email_log) mit Erfolgs-/Fehlerquote, Systemstatus der 4 Hintergrund-Scheduler, Speicherplatz-Uebersicht, eine neue Statistik-Seite (Konten-Wachstum, Pflegegrad-Verteilung, Antrags- Erfolgsquote, Umsatz, Aktivierung, Time-to-Value, Retention) mit abhaengigkeitsfreien Inline-SVG-Balkendiagrammen, eine Test-Mail-Funktion zum Pruefen aller proaktiven Mailtypen, sowie Hard-Delete fuer Nutzerkonten inkl. Begruendungspflicht/Audit-Log. Co-Authored-By: Claude Sonnet 5 --- .../backend/app/backup_scheduler.py | 2 + pflegepilot_v3/backend/app/einstellungen.py | 17 + pflegepilot_v3/backend/app/email_test.py | 255 +++++++++ pflegepilot_v3/backend/app/routers/admin.py | 180 ++++++- pflegepilot_v3/backend/app/statistiken.py | 270 ++++++++++ .../versions/b2d5e8f0c3a7_email_log.py | 41 ++ .../frontend/src/app/(app)/admin/page.tsx | 504 +++++++++++++++--- .../src/app/(app)/admin/statistiken/page.tsx | 222 ++++++++ .../frontend/src/components/BarChart.tsx | 127 +++++ .../src/components/BegruendungModal.tsx | 8 + pflegepilot_v3/frontend/src/lib/admin.ts | 168 +++++- .../frontend/src/lib/chartColors.ts | 49 ++ 12 files changed, 1762 insertions(+), 81 deletions(-) create mode 100644 pflegepilot_v3/backend/app/email_test.py create mode 100644 pflegepilot_v3/backend/app/statistiken.py create mode 100644 pflegepilot_v3/backend/migrations/versions/b2d5e8f0c3a7_email_log.py create mode 100644 pflegepilot_v3/frontend/src/app/(app)/admin/statistiken/page.tsx create mode 100644 pflegepilot_v3/frontend/src/components/BarChart.tsx create mode 100644 pflegepilot_v3/frontend/src/lib/chartColors.ts diff --git a/pflegepilot_v3/backend/app/backup_scheduler.py b/pflegepilot_v3/backend/app/backup_scheduler.py index b74f1ab..a89dccf 100644 --- a/pflegepilot_v3/backend/app/backup_scheduler.py +++ b/pflegepilot_v3/backend/app/backup_scheduler.py @@ -21,6 +21,7 @@ from sqlalchemy import text from app.backup import BackupFehler, alte_backups_aufraeumen, erstelle_backup, liste_backups from app.db import engine +from app.einstellungen import stempel_scheduler_lauf logger = logging.getLogger(__name__) @@ -50,6 +51,7 @@ def _scheduler_thread() -> None: _taegliches_backup_falls_faellig() except Exception: logger.exception("Fehler im Backup-Scheduler-Durchlauf") + stempel_scheduler_lauf("backup") time.sleep(_PRUEF_INTERVALL_SEKUNDEN) finally: lock_connection.close() diff --git a/pflegepilot_v3/backend/app/einstellungen.py b/pflegepilot_v3/backend/app/einstellungen.py index b079f8d..69ad6d1 100644 --- a/pflegepilot_v3/backend/app/einstellungen.py +++ b/pflegepilot_v3/backend/app/einstellungen.py @@ -8,6 +8,7 @@ import decimal from sqlalchemy.orm import Session +from app.db import SessionLocal from app.models import Einstellung, Nutzer # Gestaffeltes Preismodell (Kundenfeedback 2026-07-24): Basispreis deckt den @@ -32,6 +33,22 @@ def set_setting(db: Session, key: str, value: str) -> None: db.add(Einstellung(schluessel=key, wert=value)) +def stempel_scheduler_lauf(name: str) -> None: + """Persistiert den Zeitstempel des letzten (erfolgreich durchlaufenen) + Scheduler-Durchgangs fuer den Admin-Dashboard-Systemstatus - eigene + kurzlebige Session, damit Hintergrund-Threads (reminder_scheduler.py, + backup_scheduler.py, umkreis_favoriten_watch.py, katalog_watch.py) dafuer + keine eigene Session offenhalten muessen. Key-Schema: + scheduler_letzter_lauf_, ausgewertet von + GET /api/admin/scheduler-status (routers/admin.py).""" + db = SessionLocal() + try: + set_setting(db, f"scheduler_letzter_lauf_{name}", datetime.datetime.now(datetime.timezone.utc).isoformat()) + db.commit() + finally: + db.close() + + def abo_pflicht_aktiv(db: Session) -> bool: return get_setting(db, "abo_pflicht", "0") == "1" diff --git a/pflegepilot_v3/backend/app/email_test.py b/pflegepilot_v3/backend/app/email_test.py new file mode 100644 index 0000000..5cf2748 --- /dev/null +++ b/pflegepilot_v3/backend/app/email_test.py @@ -0,0 +1,255 @@ +"""Test-Mail-Funktion fuers Admin-Dashboard: verschickt zu jedem der 7 +proaktiven Mailtypen eine Beispiel-Mail mit realistischen Platzhalterdaten an +eine frei waehlbare Adresse - damit sich Design/Anrede/Ton pruefen laesst, +ohne echte Scheduler-Bedingungen (faellige Aufgabe, geaenderter Katalog- +Eintrag, abgelaufene Widerspruchsfrist, ...) im System nachstellen zu +muessen (Betreiber-Feedback 2026-08-01: "gib mir eine mail-test funktion im +admin bereich um test mails zu versenden"). + +Baut bewusst mit denselben email_templates-Bausteinen und derselben +Text-/HTML-Formulierung wie die echten Versandstellen (reminder_scheduler.py, +katalog_watch.py, umkreis_favoriten_watch.py, routers/auth.py) fuer +visuelle Deckungsgleichheit - nur die Eingabedaten sind fest hinterlegte +Platzhalter statt echter DB-Objekte, da fuer eine Testmail keine reale +Aufgabe/kein realer Antrag/Favorit existieren muss. Wird die Formulierung an +einer echten Versandstelle geaendert, sollte der jeweilige Baustein hier +zeitnah nachgezogen werden, sonst laeuft die Testmail-Vorschau der echten +Mail inhaltlich davon. + +Betreff bekommt ein "[Testmail]"-Praefix, damit im Posteingang sofort klar +ist, dass es kein echter Versand war. Der Router protokolliert den Versand +im email_log mit typ="test_", damit Testversendungen die +echten Volumen-Statistiken (E-Mail-Log-Karte im Admin-Dashboard) nicht +verfaelschen.""" + +import datetime +from typing import Callable + +from app import email_templates +from app.config import settings + +_VORNAME = "Max" +_PATIENT = "Grete Musterfrau" + +BaueFunktion = Callable[[], tuple[str, str, str]] + + +def _tagebuch_reminder() -> tuple[str, str, str]: + html = email_templates.render_email( + titel="Wie war der Tag?", + inhalt_html=( + email_templates.gruss(_VORNAME) + + email_templates.absatz( + "Kurzer Check-in für heute: Wie war der Tag mit Ihrem Angehörigen? Schlaf, " + "Stimmung, besondere Vorfälle oder Medikamente – ein kurzer Eintrag im " + "Pflegetagebuch reicht schon, das dauert nur eine halbe Minute." + ) + + email_templates.absatz( + "Diese Erinnerung lässt sich jederzeit in Ihren Kontoeinstellungen abschalten." + ) + ), + cta_label="Zum Pflegetagebuch", + cta_url=f"{settings.web_origins[0]}/dashboard", + ) + text = ( + f"Hallo {_VORNAME},\n\n" + "kurzer Check-in für heute: Wie war der Tag mit Ihrem Angehörigen?\n" + "Schlaf, Stimmung, besondere Vorfälle oder Medikamente – ein kurzer Eintrag im " + "Pflegetagebuch reicht schon, das dauert nur eine halbe Minute.\n\n" + "Diese Erinnerung lässt sich jederzeit in Ihren Kontoeinstellungen abschalten.\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + return "MeinPflegeFuchs – Wie war der Tag?", text, html + + +def _aufgabe_faellig() -> tuple[str, str, str]: + frist_text = "in 7 Tagen" + faellig_am = datetime.date.today() + datetime.timedelta(days=7) + titel = "Pflegehilfsmittel-Antrag nachreichen" + html = email_templates.render_email( + titel=f"Aufgabe fällig {frist_text}", + inhalt_html=email_templates.gruss(_VORNAME) + + email_templates.absatz( + f"Nicht vergessen: die Aufgabe „{titel}“ ist {frist_text} fällig. " + f"Fällig am {faellig_am.strftime('%d.%m.%Y')}." + ), + cta_label="Zu den Aufgaben", + cta_url=f"{settings.web_origins[0]}/aufgaben", + ) + text = ( + f"Hallo {_VORNAME},\n\n" + f"nicht vergessen: die Aufgabe „{titel}“ ist {frist_text} fällig.\n" + f"Fällig am: {faellig_am.strftime('%d.%m.%Y')}\n\n" + "Direkt in MeinPflegeFuchs unter Aufgaben einsehen und ggf. als erledigt markieren.\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + return f"MeinPflegeFuchs – Aufgabe fällig {frist_text}", text, html + + +def _antragsstatus_erinnerung() -> tuple[str, str, str]: + typ_label = "Ersteinstufung Pflegegrad" + basis = datetime.date.today() - datetime.timedelta(days=21) + basis_link = f"{settings.web_origins[0]}/antrag-status?token=testvorschau&ergebnis=" + html = email_templates.render_email( + titel="Antwort zu Ihrem Antrag schon da?", + inhalt_html=( + email_templates.gruss(_VORNAME) + + email_templates.absatz( + f"Am {basis.strftime('%d.%m.%Y')} haben Sie für {_PATIENT} einen Antrag " + f"({typ_label}) gestellt – ist inzwischen eine Antwort eingetroffen? Ein Klick " + "reicht:" + ) + + email_templates.magic_link_reihe( + [ + ("Ja, bewilligt", basis_link + "bewilligt"), + ("Ja, abgelehnt", basis_link + "abgelehnt"), + ("Noch keine Antwort", basis_link + "offen"), + ] + ) + + email_templates.absatz( + "Sie können den Status jederzeit auch direkt in MeinPflegeFuchs eintragen." + ) + ), + ) + text = ( + f"Hallo {_VORNAME},\n\n" + f"am {basis.strftime('%d.%m.%Y')} haben Sie für {_PATIENT} einen Antrag " + f"({typ_label}) gestellt. Ist inzwischen eine Antwort eingetroffen?\n\n" + f"Ja, bewilligt: {basis_link}bewilligt\n" + f"Ja, abgelehnt: {basis_link}abgelehnt\n" + f"Noch keine Antwort: {basis_link}offen\n\n" + "Sie können den Status jederzeit auch direkt in MeinPflegeFuchs eintragen.\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + return "MeinPflegeFuchs – Antwort zu Ihrem Antrag schon da?", text, html + + +def _widerspruch_eskalation() -> tuple[str, str, str]: + typ_label = "Ersteinstufung Pflegegrad" + frist = datetime.date.today() + datetime.timedelta(days=7) + tage_rest = 7 + link = f"{settings.web_origins[0]}/antrag-status?token=testvorschau&ergebnis=abgelehnt" + html = email_templates.render_email( + titel="Widerspruchsfrist läuft bald ab", + inhalt_html=email_templates.gruss(_VORNAME) + + email_templates.absatz( + f"Für den abgelehnten Antrag ({typ_label}) von {_PATIENT} läuft die " + f"Widerspruchsfrist am {frist.strftime('%d.%m.%Y')} ab (noch " + f"{tage_rest} Tage, § 84 SGG). Wir wollten Sie rechtzeitig daran erinnern." + ), + cta_label="Jetzt Widerspruch vorbereiten", + cta_url=link, + ) + text = ( + f"Hallo {_VORNAME},\n\n" + f"für den abgelehnten Antrag ({typ_label}) von {_PATIENT} läuft die " + f"Widerspruchsfrist am {frist.strftime('%d.%m.%Y')} ab (noch {tage_rest} Tage, § 84 SGG). " + "Wir wollten Sie rechtzeitig daran erinnern.\n\n" + f"Jetzt Widerspruch vorbereiten: {link}\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + return "MeinPflegeFuchs – Widerspruchsfrist läuft bald ab", text, html + + +def _katalog_aenderung() -> tuple[str, str, str]: + leistung_name = "Verhinderungspflege" + alt_betrag, neu_betrag = "1.612 € / Jahr", "1.685 € / Jahr" + text = ( + f"Hallo {_VORNAME},\n\n" + "im Leistungskatalog haben sich folgende, bei Ihnen hinterlegte Leistungen geändert:\n\n" + f"„{leistung_name}“ (für {_PATIENT}):\n" + f" Bisheriger Richtwert: {alt_betrag}\n" + f" Neuer Richtwert: {neu_betrag}\n\n" + "Bitte prüfen Sie im Leistungskatalog in MeinPflegeFuchs, ob sich dadurch etwas für Sie ändert.\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + box = email_templates.aenderungs_box( + f"{leistung_name} – für {_PATIENT}", [("Betrag", alt_betrag, neu_betrag)] + ) + html = email_templates.render_email( + titel=f"Änderung bei „{leistung_name}“", + inhalt_html=( + email_templates.gruss(_VORNAME) + + email_templates.absatz( + "Im Leistungskatalog haben sich folgende, bei Ihnen hinterlegte Leistungen geändert:" + ) + + box + ), + cta_label="Zum Leistungskatalog", + cta_url=f"{settings.web_origins[0]}/katalog", + ) + return f"MeinPflegeFuchs – Änderung bei „{leistung_name}“", text, html + + +def _umkreis_favorit_aenderung() -> tuple[str, str, str]: + favorit_name = "Pflegedienst Sonnenschein" + alt_tel, neu_tel = "030 1234567", "030 7654321" + text = ( + f"Hallo {_VORNAME},\n\n" + "bei folgenden von Ihnen gemerkten Einrichtungen aus der Umkreissuche haben sich die " + "Kontaktdaten geändert:\n\n" + f"„{favorit_name}“:\n" + f" Telefon: {alt_tel} → {neu_tel}\n\n" + "Bitte prüfen Sie die Angaben in Ihren Umkreissuche-Favoriten in MeinPflegeFuchs.\n\n" + "Erstellt mit MeinPflegeFuchs." + ) + box = email_templates.aenderungs_box(favorit_name, [("Telefon", alt_tel, neu_tel)]) + html = email_templates.render_email( + titel="Änderung bei gemerkten Einrichtungen", + inhalt_html=( + email_templates.gruss(_VORNAME) + + email_templates.absatz( + "Bei folgenden von Ihnen gemerkten Einrichtungen aus der Umkreissuche haben sich die " + "Kontaktdaten geändert:" + ) + + box + ), + cta_label="Zu den Favoriten", + cta_url=f"{settings.web_origins[0]}/umkreissuche", + ) + return "MeinPflegeFuchs – Änderung bei gemerkten Einrichtungen", text, html + + +def _passwort_reset() -> tuple[str, str, str]: + link = f"{settings.web_origins[0]}/passwort-zuruecksetzen?token=testvorschau" + html = email_templates.render_email( + titel="Passwort zurücksetzen", + inhalt_html=email_templates.gruss(_VORNAME) + + email_templates.absatz( + "Sie möchten Ihr Passwort zurücksetzen? Klicken Sie einfach auf den Button unten " + "(der Link ist eine Stunde gültig). Falls Sie diese Anfrage nicht gestellt haben, " + "ignorieren Sie diese E-Mail einfach – es ändert sich nichts an Ihrem Konto." + ), + cta_label="Passwort zurücksetzen", + cta_url=link, + ) + text = ( + f"Hallo {_VORNAME},\n\n" + "Sie möchten Ihr Passwort zurücksetzen? Klicken Sie einfach auf folgenden Link " + f"(eine Stunde gültig):\n\n{link}\n\n" + "Falls Sie diese Anfrage nicht gestellt haben, ignorieren Sie diese E-Mail einfach " + "– es ändert sich nichts an Ihrem Konto." + ) + return "MeinPflegeFuchs – Passwort zurücksetzen", text, html + + +# Registry fuers Admin-Dashboard: typ -> (Label, Builder). dict-Reihenfolge +# bestimmt die Anzeigereihenfolge im Frontend-Dropdown. +TEST_MAIL_TYPEN: dict[str, tuple[str, BaueFunktion]] = { + "tagebuch_reminder": ("Tagebuch-Erinnerung", _tagebuch_reminder), + "aufgabe_faellig": ("Aufgabe fällig", _aufgabe_faellig), + "antragsstatus_erinnerung": ("Antragsstatus-Erinnerung", _antragsstatus_erinnerung), + "widerspruch_eskalation": ("Widerspruchsfrist-Eskalation", _widerspruch_eskalation), + "katalog_aenderung": ("Katalog-Änderung", _katalog_aenderung), + "umkreis_favorit_aenderung": ("Umkreis-Favoriten-Änderung", _umkreis_favorit_aenderung), + "passwort_reset": ("Passwort-Reset", _passwort_reset), +} + + +def baue_test_mail(typ: str) -> tuple[str, str, str]: + """Liefert (betreff, text, html) fuer den gegebenen Typ, Betreff mit + "[Testmail]"-Praefix. Wirft KeyError fuer einen unbekannten Typ - vom + Aufrufer (Router) in einen 400 zu uebersetzen.""" + _, builder = TEST_MAIL_TYPEN[typ] + betreff, text_body, html_body = builder() + return f"[Testmail] {betreff}", text_body, html_body diff --git a/pflegepilot_v3/backend/app/routers/admin.py b/pflegepilot_v3/backend/app/routers/admin.py index 05fa8cb..15cb2c9 100644 --- a/pflegepilot_v3/backend/app/routers/admin.py +++ b/pflegepilot_v3/backend/app/routers/admin.py @@ -9,22 +9,26 @@ import zipfile from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, UploadFile from fastapi.responses import FileResponse, Response +from sqlalchemy import func, text from sqlalchemy.orm import Session from app import backup as backup_modul from app import changelog as changelog_logik +from app import email_test as email_test_modul from app.archivierung import add_monate, archiviere_patient from app.audit import log_admin_aktion from app.config import settings from app.db import SessionLocal, get_db from app.deps import require_admin from app.einstellungen import abo_preise, berechne_abo_preis, get_setting, set_setting +from app.email_util import send_email from app.models import ( Antrag, AdminAuditLog, Aufgabe, Dokument, Einstellung, + EmailLogEintrag, Leistung, NotizVerlauf, Nutzer, @@ -38,12 +42,18 @@ from app.schemas import ( AuditLogOut, BackupEintragOut, BegruendungRequest, + EmailLogOut, + EmailTestRequest, NutzerCreate, NutzerOut, NutzerUpdate, RechnungRequest, + SchedulerStatusEintragOut, + SpeicherplatzOut, + StatistikenOut, ) from app.security import hash_password +from app.statistiken import berechne_statistiken router = APIRouter(dependencies=[Depends(require_admin)], tags=["admin"]) @@ -144,9 +154,22 @@ def nutzer_aktualisieren(uid: int, payload: NutzerUpdate, db: Session = Depends( @router.delete("/api/nutzer/{uid}") -def nutzer_hard_delete(uid: int, request: Request, db: Session = Depends(get_db)): +def nutzer_hard_delete( + uid: int, payload: BegruendungRequest, request: Request, db: Session = Depends(get_db) +): + """Unwiderruflicher Hard-Delete - anders als der Soft-Delete-Pfad + (POST .../loeschen, archiviert Patienten statt sie zu loeschen, siehe + unten) gibt es hier keine Aufbewahrung. Deshalb strenger als der Soft- + Delete: verweigert (400), solange das Konto noch irgendwelche Patienten + besitzt (auch archivierte - erst per Admin-Datenexport/DSGVO-Export + sichern, dann die Patienten selbst loeschen, dann erst das Konto), + verlangt wie jede andere destruktive Admin-Aktion eine Begruendung und + wird im Audit-Log protokolliert (Name/Begruendung werden VOR dem Loeschen + erfasst, der Log-Eintrag selbst hat bewusst keinen FK auf nutzer.id und + ueberlebt die Loeschung, siehe log_admin_aktion()).""" if uid == request.session.get("nutzer_id"): raise HTTPException(status_code=400, detail="Eigenen Account nicht löschbar") + grund = _require_begruendung(payload) anzahl = db.query(Patient).filter(Patient.nutzer_id == uid).count() if anzahl > 0: raise HTTPException( @@ -156,7 +179,11 @@ def nutzer_hard_delete(uid: int, request: Request, db: Session = Depends(get_db) nutzer = db.get(Nutzer, uid) if nutzer is None: raise HTTPException(status_code=404, detail="Nicht gefunden") + + benutzername = nutzer.benutzername + admin = db.get(Nutzer, request.session["nutzer_id"]) db.delete(nutzer) + log_admin_aktion(db, admin, "konto_hart_geloescht", "nutzer", uid, benutzername, grund) db.commit() return {"ok": True} @@ -271,6 +298,157 @@ def audit_log(db: Session = Depends(get_db)): ) +# ─── E-Mail-Versand-Uebersicht (Betreiber-Feedback: keine Sicht auf Volumen/ +# Erfolgsquote, relevant fuer Skalierungsentscheidungen) ───────────────────── + +@router.get("/api/admin/email-log", response_model=EmailLogOut) +def email_log(tage: int = 30, db: Session = Depends(get_db)): + seit = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=tage) + eintraege = ( + db.query(EmailLogEintrag) + .filter(EmailLogEintrag.erstellt_am >= seit) + .order_by(EmailLogEintrag.erstellt_am.desc()) + .limit(200) + .all() + ) + nach_typ = dict( + db.query(EmailLogEintrag.typ, func.count()) + .filter(EmailLogEintrag.erstellt_am >= seit) + .group_by(EmailLogEintrag.typ) + .all() + ) + nach_status = dict( + db.query(EmailLogEintrag.status, func.count()) + .filter(EmailLogEintrag.erstellt_am >= seit) + .group_by(EmailLogEintrag.status) + .all() + ) + return EmailLogOut(eintraege=eintraege, nach_typ=nach_typ, nach_status=nach_status, zeitraum_tage=tage) + + +# ─── Test-Mail-Funktion (Betreiber-Feedback 2026-08-01: Design/Anrede/Ton +# der 7 proaktiven Mailtypen pruefen koennen, ohne die jeweilige echte +# Versandbedingung im System nachstellen zu muessen) ──────────────────────── + +_EMAIL_REGEX = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$") + + +@router.get("/api/admin/email-test/typen") +def email_test_typen(): + return [{"typ": typ, "label": label} for typ, (label, _) in email_test_modul.TEST_MAIL_TYPEN.items()] + + +@router.post("/api/admin/email-test") +def email_test_senden(payload: EmailTestRequest, db: Session = Depends(get_db)): + empfaenger = payload.empfaenger.strip().lower() + if not _EMAIL_REGEX.match(empfaenger): + raise HTTPException(status_code=400, detail="Bitte eine gültige E-Mail-Adresse angeben") + try: + betreff, text_body, html_body = email_test_modul.baue_test_mail(payload.typ) + except KeyError: + raise HTTPException(status_code=400, detail="Unbekannter Mailtyp") + send_email(db, empfaenger, betreff, text_body, typ=f"test_{payload.typ}", html=html_body) + db.commit() + return {"ok": True} + + +# ─── Scheduler-Status (Betreiber-Feedback: sichtbar machen, ob die 4 +# Hintergrund-Threads noch aktiv sind) ─────────────────────────────────────── + +_SCHEDULER_META = { + "reminder": { + "label": "Tagebuch-/Aufgaben-/Antragsstatus-Erinnerungen", + "intervall_sekunden": 300, + "einmalig": False, + }, + "backup": {"label": "Automatisches Backup", "intervall_sekunden": 3600, "einmalig": False}, + "umkreis_favoriten": { + "label": "Umkreissuche-Favoriten-Änderungserkennung", + "intervall_sekunden": 86400, + "einmalig": False, + }, + "katalog": { + "label": "Leistungskatalog-Änderungserkennung", + "intervall_sekunden": 0, + "einmalig": True, + }, +} + + +@router.get("/api/admin/scheduler-status", response_model=list[SchedulerStatusEintragOut]) +def scheduler_status(db: Session = Depends(get_db)): + jetzt = datetime.datetime.now(datetime.timezone.utc) + ergebnis = [] + for name, meta in _SCHEDULER_META.items(): + wert = get_setting(db, f"scheduler_letzter_lauf_{name}") + letzter_lauf = datetime.datetime.fromisoformat(wert) if wert else None + if letzter_lauf is None: + status = "nie_gelaufen" + elif meta["einmalig"]: + # Laeuft nur einmal pro App-Start, kein Wiederholungsintervall zu + # pruefen - jeder vorhandene Zeitstempel bedeutet "erfolgreich + # beim letzten Start gelaufen". + status = "ok" + elif (jetzt - letzter_lauf).total_seconds() <= meta["intervall_sekunden"] * 2: + status = "ok" + else: + status = "verzoegert" + ergebnis.append( + SchedulerStatusEintragOut( + name=name, + label=meta["label"], + letzter_lauf=letzter_lauf, + erwartetes_intervall_sekunden=meta["intervall_sekunden"], + einmalig=meta["einmalig"], + status=status, + ) + ) + return ergebnis + + +# ─── Speicherplatz-Uebersicht (Betreiber-Feedback: relevant fuer dieselbe +# "wie skaliere ich"-Fragestellung wie der E-Mail-Log) ─────────────────────── + +@router.get("/api/admin/speicherplatz", response_model=SpeicherplatzOut) +def speicherplatz(db: Session = Depends(get_db)): + uploads_nach_typ: dict[str, int] = {} + uploads_gesamt = 0 + if os.path.isdir(settings.uploads_dir): + for eintrag in os.listdir(settings.uploads_dir): + teil_pfad = os.path.join(settings.uploads_dir, eintrag) + if not os.path.isdir(teil_pfad): + continue + groesse = sum( + os.path.getsize(os.path.join(dirpath, dateiname)) + for dirpath, _, dateinamen in os.walk(teil_pfad) + for dateiname in dateinamen + ) + uploads_nach_typ[eintrag] = groesse + uploads_gesamt += groesse + + backups = backup_modul.liste_backups() + backups_bytes = sum(b["groesse_bytes"] for b in backups) + + datenbank_bytes = db.execute(text("SELECT pg_database_size(current_database())")).scalar() or 0 + + return SpeicherplatzOut( + uploads_bytes=uploads_gesamt, + uploads_nach_typ=uploads_nach_typ, + backups_bytes=backups_bytes, + backups_anzahl=len(backups), + datenbank_bytes=datenbank_bytes, + ) + + +# ─── Statistik-Seite (Betreiber-Feedback: Konten-/Patienten-Wachstum, +# Anträge & Erfolgsquote, Umsatz, Aktivierung, Time-to-Value, Retention- +# Näherung) — reine Aggregation, siehe app/statistiken.py ───────────────────── + +@router.get("/api/admin/statistiken", response_model=StatistikenOut) +def statistiken(db: Session = Depends(get_db)): + return berechne_statistiken(db) + + @router.post("/api/admin/patienten/{pid}/dsgvo-export") def dsgvo_export( pid: int, payload: BegruendungRequest, request: Request, db: Session = Depends(get_db) diff --git a/pflegepilot_v3/backend/app/statistiken.py b/pflegepilot_v3/backend/app/statistiken.py new file mode 100644 index 0000000..6b2049c --- /dev/null +++ b/pflegepilot_v3/backend/app/statistiken.py @@ -0,0 +1,270 @@ +"""Aggregationen fuer die Admin-Statistik-Seite (Betreiber-Feedback: eigene +Statistik-Seite im Admin-Bereich). Rein lesend gegen bereits vorhandene +Tabellen - keine neue Persistenz, keine Migration. + +Konsistente Filterregel fuer alle wachstums-/geschaeftsbezogenen Kennzahlen: +nur "echte Kunden" (rolle='nutzer', ist_demo=False) - Admin-Testkonten und +das feste Demo-Konto wuerden sonst jede dieser Zahlen verzerren. Nur die +Konten-Uebersicht zeigt zusaetzlich Admin-/Demo-Konten als eigene Segmente, +da sie dort als reine Bestandsaufnahme sinnvoll sind.""" + +import datetime +import decimal +import statistics + +from sqlalchemy import func +from sqlalchemy.orm import Session + +from app.einstellungen import berechne_abo_preis +from app.models import Antrag, Nutzer, Patient +from app.schemas import ( + AktivierungOut, + ErfolgsquoteOut, + KohortenWertOut, + KontenUebersichtOut, + MonatsWertOut, + StatistikenOut, + TimeToValueOut, + UmsatzOut, + WiderspruchRateOut, +) +from app.static_data.antrag_fristen import ANTRAG_ERINNERUNGS_TAGE + +_TRACKBARE_TYPEN = list(ANTRAG_ERINNERUNGS_TAGE.keys()) + + +def _kunden_filter(query, modell=Nutzer): + return query.filter(modell.rolle == "nutzer", modell.ist_demo.is_(False)) + + +def _konten_uebersicht(db: Session) -> KontenUebersichtOut: + alle = db.query(Nutzer).all() + return KontenUebersichtOut( + gesamt=len(alle), + aktiv=sum(1 for n in alle if n.aktiv), + gesperrt=sum(1 for n in alle if not n.aktiv), + admin=sum(1 for n in alle if n.rolle == "admin"), + demo=sum(1 for n in alle if n.ist_demo), + selbst_registriert=sum(1 for n in alle if n.selbst_registriert), + admin_angelegt=sum(1 for n in alle if n.rolle == "nutzer" and not n.ist_demo and not n.selbst_registriert), + ) + + +def _konten_pro_monat(db: Session) -> list[MonatsWertOut]: + query = _kunden_filter(db.query(Nutzer.erstellt_am)) + return _monatswerte_aus_query(query) + + +def _monatswerte_aus_query(query) -> list[MonatsWertOut]: + zeitstempel = [row[0] for row in query.all()] + monate: dict[str, int] = {} + for ts in zeitstempel: + key = ts.strftime("%Y-%m") + monate[key] = monate.get(key, 0) + 1 + ergebnis = [] + kumuliert = 0 + for monat in sorted(monate.keys()): + kumuliert += monate[monat] + ergebnis.append(MonatsWertOut(monat=monat, anzahl_neu=monate[monat], anzahl_kumuliert=kumuliert)) + return ergebnis + + +def _kunden_patienten_query(db: Session): + return db.query(Patient).join(Nutzer, Patient.nutzer_id == Nutzer.id).filter( + Nutzer.rolle == "nutzer", Nutzer.ist_demo.is_(False) + ) + + +def _patienten_pro_monat(db: Session) -> list[MonatsWertOut]: + query = _kunden_patienten_query(db).with_entities(Patient.erstellt_am) + return _monatswerte_aus_query(query) + + +def _patienten_nach_zielgruppe(db: Session) -> dict[str, int]: + rows = ( + _kunden_patienten_query(db) + .with_entities(Patient.zielgruppe, func.count()) + .group_by(Patient.zielgruppe) + .all() + ) + return dict(rows) + + +def _patienten_nach_pflegegrad(db: Session) -> dict[str, int]: + rows = ( + _kunden_patienten_query(db) + .with_entities(Patient.pflegegrad, func.count()) + .group_by(Patient.pflegegrad) + .all() + ) + return {str(grad): anzahl for grad, anzahl in rows} + + +def _antraege_nach_typ(db: Session) -> dict[str, int]: + rows = db.query(Antrag.typ, func.count()).group_by(Antrag.typ).all() + return dict(rows) + + +def _antraege_nach_status(db: Session) -> dict[str, int]: + rows = db.query(Antrag.status, func.count()).group_by(Antrag.status).all() + return dict(rows) + + +def _erfolgsquote(db: Session) -> ErfolgsquoteOut: + rows = ( + db.query(Antrag.status, func.count()) + .filter(Antrag.typ.in_(_TRACKBARE_TYPEN), Antrag.status.in_(["genehmigt", "abgelehnt"])) + .group_by(Antrag.status) + .all() + ) + werte = dict(rows) + genehmigt = werte.get("genehmigt", 0) + abgelehnt = werte.get("abgelehnt", 0) + gesamt = genehmigt + abgelehnt + quote = genehmigt / gesamt if gesamt else None + return ErfolgsquoteOut(genehmigt=genehmigt, abgelehnt=abgelehnt, quote=quote) + + +def _widerspruch_rate(db: Session) -> WiderspruchRateOut: + """Gleiche Korrelations-Heuristik wie reminder_scheduler.py: + _sende_widerspruch_eskalation() - ein abgelehnter Antrag gilt als "mit + Widerspruch", wenn fuer denselben Patienten spaeter ein Antrag vom Typ + 'widerspruch' angelegt wurde.""" + abgelehnte = ( + db.query(Antrag) + .filter(Antrag.typ.in_(_TRACKBARE_TYPEN), Antrag.status == "abgelehnt") + .all() + ) + if not abgelehnte: + return WiderspruchRateOut(abgelehnte_antraege=0, davon_mit_widerspruch=0, quote=None) + + mit_widerspruch = 0 + for antrag in abgelehnte: + gefunden = ( + db.query(Antrag) + .filter( + Antrag.patient_id == antrag.patient_id, + Antrag.typ == "widerspruch", + Antrag.erstellt_am > antrag.erstellt_am, + ) + .first() + ) + if gefunden is not None: + mit_widerspruch += 1 + + return WiderspruchRateOut( + abgelehnte_antraege=len(abgelehnte), + davon_mit_widerspruch=mit_widerspruch, + quote=mit_widerspruch / len(abgelehnte), + ) + + +def _umsatz(db: Session) -> UmsatzOut: + heute = datetime.date.today() + kunden = _kunden_filter(db.query(Nutzer)).filter(Nutzer.abo_bis.isnot(None), Nutzer.abo_bis >= heute).all() + ohne_zugang = _kunden_filter(db.query(func.count(Nutzer.id))).filter( + (Nutzer.abo_bis.is_(None)) | (Nutzer.abo_bis < heute) + ).scalar() or 0 + + mrr = decimal.Decimal("0") + zahlende_betraege: list[decimal.Decimal] = [] + kostenlose_konten = 0 + for nutzer in kunden: + patienten_anzahl = db.query(func.count(Patient.id)).filter(Patient.nutzer_id == nutzer.id).scalar() or 0 + preis = berechne_abo_preis(db, patienten_anzahl) + if nutzer.abo_typ == "kostenlos_admin": + kostenlose_konten += 1 + else: + zahlende_betraege.append(preis) + mrr += preis + + durchschnitt = ( + sum(zahlende_betraege) / len(zahlende_betraege) if zahlende_betraege else None + ) + return UmsatzOut( + mrr=mrr, + zahlende_konten=len(zahlende_betraege), + kostenlose_konten=kostenlose_konten, + ohne_zugang=int(ohne_zugang), + durchschnitt_pro_zahlendem_konto=durchschnitt, + ) + + +def _aktivierung(db: Session) -> AktivierungOut: + kunden = _kunden_filter(db.query(Nutzer.id)).all() + gesamt = len(kunden) + if gesamt == 0: + return AktivierungOut(gesamt=0, mit_patient=0, quote=None) + kunden_ids = [row[0] for row in kunden] + mit_patient = ( + db.query(func.count(func.distinct(Patient.nutzer_id))) + .filter(Patient.nutzer_id.in_(kunden_ids)) + .scalar() + or 0 + ) + return AktivierungOut(gesamt=gesamt, mit_patient=mit_patient, quote=mit_patient / gesamt) + + +def _time_to_value(db: Session) -> TimeToValueOut: + nutzer_erste_patienten = ( + db.query(Nutzer.erstellt_am, func.min(Patient.erstellt_am)) + .join(Patient, Patient.nutzer_id == Nutzer.id) + .filter(Nutzer.rolle == "nutzer", Nutzer.ist_demo.is_(False)) + .group_by(Nutzer.id, Nutzer.erstellt_am) + .all() + ) + deltas_tage = [ + (erster_patient - nutzer_erstellt).total_seconds() / 86400 + for nutzer_erstellt, erster_patient in nutzer_erste_patienten + ] + if not deltas_tage: + return TimeToValueOut(median_tage=None, durchschnitt_tage=None, anzahl_basis=0) + return TimeToValueOut( + median_tage=round(statistics.median(deltas_tage), 1), + durchschnitt_tage=round(statistics.mean(deltas_tage), 1), + anzahl_basis=len(deltas_tage), + ) + + +def _retention_naeherung(db: Session) -> list[KohortenWertOut]: + grenze = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=30) + kunden = _kunden_filter(db.query(Nutzer.erstellt_am, Nutzer.letzter_login)).all() + kohorten: dict[str, dict[str, int]] = {} + for erstellt_am, letzter_login in kunden: + key = erstellt_am.strftime("%Y-%m") + eintrag = kohorten.setdefault(key, {"gesamt": 0, "aktiv": 0}) + eintrag["gesamt"] += 1 + if letzter_login is not None and letzter_login >= grenze: + eintrag["aktiv"] += 1 + + ergebnis = [] + for monat in sorted(kohorten.keys()): + gesamt = kohorten[monat]["gesamt"] + aktiv = kohorten[monat]["aktiv"] + ergebnis.append( + KohortenWertOut( + kohorte_monat=monat, + anzahl_konten=gesamt, + aktiv_letzte_30_tage=aktiv, + quote=aktiv / gesamt if gesamt else None, + ) + ) + return ergebnis + + +def berechne_statistiken(db: Session) -> StatistikenOut: + return StatistikenOut( + konten_uebersicht=_konten_uebersicht(db), + konten_pro_monat=_konten_pro_monat(db), + patienten_pro_monat=_patienten_pro_monat(db), + patienten_nach_zielgruppe=_patienten_nach_zielgruppe(db), + patienten_nach_pflegegrad=_patienten_nach_pflegegrad(db), + antraege_nach_typ=_antraege_nach_typ(db), + antraege_nach_status=_antraege_nach_status(db), + erfolgsquote=_erfolgsquote(db), + widerspruch_rate=_widerspruch_rate(db), + umsatz=_umsatz(db), + aktivierung=_aktivierung(db), + time_to_value=_time_to_value(db), + retention_naeherung=_retention_naeherung(db), + ) diff --git a/pflegepilot_v3/backend/migrations/versions/b2d5e8f0c3a7_email_log.py b/pflegepilot_v3/backend/migrations/versions/b2d5e8f0c3a7_email_log.py new file mode 100644 index 0000000..b121c83 --- /dev/null +++ b/pflegepilot_v3/backend/migrations/versions/b2d5e8f0c3a7_email_log.py @@ -0,0 +1,41 @@ +"""email_log-Tabelle: Uebersicht ueber E-Mail-Versand im Admin-Dashboard + +Revision ID: b2d5e8f0c3a7 +Revises: a1c4e7f9b3d6 +Create Date: 2026-07-31 00:00:00.000000 + +Betreiber-Feedback: keine Uebersicht, wie viele E-Mails verschickt werden +(relevant fuer Skalierungsentscheidungen) - send_email() (app/email_util.py) +war bislang die einzige Stelle mit SMTP-Zugriff, aber ohne jede Persistenz. +""" +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision = 'b2d5e8f0c3a7' +down_revision = 'a1c4e7f9b3d6' +branch_labels = None +depends_on = None + + +def upgrade() -> None: + op.create_table( + 'email_log', + sa.Column('id', sa.Integer(), primary_key=True), + sa.Column('empfaenger', sa.String(255), nullable=False), + sa.Column('typ', sa.String(50), nullable=False), + sa.Column('betreff', sa.String(300), nullable=False), + sa.Column('status', sa.String(20), nullable=False), + sa.Column('fehlermeldung', sa.Text(), nullable=True), + sa.Column('erstellt_am', sa.DateTime(timezone=True), server_default=sa.func.now()), + ) + op.create_check_constraint( + 'ck_email_log_status', + 'email_log', + "status IN ('gesendet','fehlgeschlagen','uebersprungen')", + ) + + +def downgrade() -> None: + op.drop_table('email_log') diff --git a/pflegepilot_v3/frontend/src/app/(app)/admin/page.tsx b/pflegepilot_v3/frontend/src/app/(app)/admin/page.tsx index ed6b54a..f7878c5 100644 --- a/pflegepilot_v3/frontend/src/app/(app)/admin/page.tsx +++ b/pflegepilot_v3/frontend/src/app/(app)/admin/page.tsx @@ -1,6 +1,7 @@ "use client"; import { useState } from "react"; +import { IconChevronDown, IconChevronRight } from "@tabler/icons-react"; import { useAuth } from "@/lib/auth"; import { useNutzerListe, @@ -8,25 +9,35 @@ import { useAdminMutationen, useBackups, useBackupMutationen, + useEmailLog, + useEmailTestTypen, + useEmailTestSenden, + useSchedulerStatus, + useSpeicherplatz, backupUrl, dsgvoExportHerunterladen, rechnungHerunterladen, + formatBytes, type NutzerAdmin, } from "@/lib/admin"; -import { ResponsiveTable, type Column } from "@/components/ResponsiveTable"; import { BegruendungModal } from "@/components/BegruendungModal"; import { Collapsible } from "@/components/Collapsible"; import { getAccent, buttonStyles } from "@/lib/theme"; -type Aktion = { typ: "sperren" | "entsperren" | "loeschen" | "abo"; nutzer: NutzerAdmin }; +type Aktion = { typ: "sperren" | "entsperren" | "loeschen" | "hart_loeschen" | "abo"; nutzer: NutzerAdmin }; export default function AdminPage() { const { meQuery } = useAuth(); const { data: nutzer, isLoading } = useNutzerListe(); const { data: auditLog } = useAuditLog(); - const { sperren, entsperren, loeschen, aboFreischalten, anlegen } = useAdminMutationen(); + const { sperren, entsperren, loeschen, hartLoeschen, aboFreischalten, anlegen } = useAdminMutationen(); const { data: backups } = useBackups(); const { erstellen: backupErstellen, loeschen: backupLoeschen, wiederherstellen } = useBackupMutationen(); + const { data: emailLog } = useEmailLog(); + const { data: emailTestTypen } = useEmailTestTypen(); + const emailTestSenden = useEmailTestSenden(); + const { data: schedulerStatus } = useSchedulerStatus(); + const { data: speicherplatz } = useSpeicherplatz(); const [aktion, setAktion] = useState(null); const [backupModalOffen, setBackupModalOffen] = useState(false); @@ -41,10 +52,27 @@ export default function AdminPage() { const [dsgvoPid, setDsgvoPid] = useState(null); const [dsgvoGrund, setDsgvoGrund] = useState(""); const [rechnungFehler, setRechnungFehler] = useState(null); + const [kontoSuche, setKontoSuche] = useState(""); + const [offeneKonten, setOffeneKonten] = useState>(new Set()); + + const [testMailEmpfaenger, setTestMailEmpfaenger] = useState(""); + const [testMailTyp, setTestMailTyp] = useState(""); const eigeneId = meQuery.data?.id; const auditAccent = getAccent("indigo"); const backupAccent = getAccent("teal"); + const emailLogAccent = getAccent("sky"); + const emailTestAccent = getAccent("cyan"); + const schedulerAccent = getAccent("violet"); + const speicherAccent = getAccent("amber"); + + const testMailEmpfaengerWert = testMailEmpfaenger || meQuery.data?.email || ""; + const testMailTypWert = testMailTyp || emailTestTypen?.[0]?.typ || ""; + + const testMailSenden = () => { + if (!testMailEmpfaengerWert || !testMailTypWert) return; + emailTestSenden.mutate({ empfaenger: testMailEmpfaengerWert, typ: testMailTypWert }); + }; const rechnungErstellen = async (n: NutzerAdmin) => { setRechnungFehler(null); @@ -67,82 +95,39 @@ export default function AdminPage() { if (typ === "sperren") sperren.mutate({ uid: n.id, begruendung }, { onSuccess: onDone }); if (typ === "entsperren") entsperren.mutate({ uid: n.id, begruendung }, { onSuccess: onDone }); if (typ === "loeschen") loeschen.mutate({ uid: n.id, begruendung }, { onSuccess: onDone }); + if (typ === "hart_loeschen") hartLoeschen.mutate({ uid: n.id, begruendung }, { onSuccess: onDone }); if (typ === "abo") aboFreischalten.mutate({ uid: n.id, monate, begruendung }, { onSuccess: onDone }); }; - const columns: Column[] = [ - { - key: "konto", - label: "Konto", - head: true, - render: (n) => ( -
- {n.name || n.benutzername} - - {n.rolle} - {n.ist_demo && " · demo"} - -
- ), - }, - { key: "aktiv", label: "Status", render: (n) => (n.aktiv ? "aktiv" : "gesperrt") }, - { key: "patienten", label: "Patienten", render: (n) => n.patienten_anzahl }, - { - key: "preis", - label: "Preis/Monat", - render: (n) => `${n.abo_preis_aktuell.replace(".", ",")} €`, - }, - { - key: "zugang", - label: "Zugang", - render: (n) => ( - - {n.zugang_aktiv ? "aktiv" : "kein Zugang"} - {n.abo_gekuendigt && (gekündigt)} - - ), - }, - { - key: "registriert", - label: "Registriert", - render: (n) => new Date(n.erstellt_am).toLocaleDateString("de-DE"), - }, - { - key: "aktionen", - label: "Aktionen", - render: (n) => - n.id === eigeneId ? ( - eigenes Konto - ) : ( -
- {n.aktiv ? ( - - ) : ( - - )} - - - -
- ), - }, - ]; + const aktionFehler = (t: Aktion["typ"] | undefined) => { + const mutation = + t === "sperren" ? sperren + : t === "entsperren" ? entsperren + : t === "loeschen" ? loeschen + : t === "hart_loeschen" ? hartLoeschen + : t === "abo" ? aboFreischalten + : undefined; + return mutation?.isError ? (mutation.error as Error).message : null; + }; + + const toggleKonto = (id: number) => { + setOffeneKonten((prev) => { + const next = new Set(prev); + next.has(id) ? next.delete(id) : next.add(id); + return next; + }); + }; + + const gefilterteNutzer = (nutzer ?? []).filter((n) => { + const q = kontoSuche.trim().toLowerCase(); + if (!q) return true; + return ( + n.benutzername.toLowerCase().includes(q) || + (n.name ?? "").toLowerCase().includes(q) || + (n.email ?? "").toLowerCase().includes(q) || + (n.rg_name ?? "").toLowerCase().includes(q) + ); + }); return (
@@ -213,12 +198,169 @@ export default function AdminPage() {
-

Konten

+
+

+ Konten + {nutzer && ( + + ({gefilterteNutzer.length} von {nutzer.length}) + + )} +

+ setKontoSuche(e.target.value)} + className="w-full rounded-lg border border-slate-300 px-3 py-2 text-sm sm:w-80" + /> +
{rechnungFehler &&

{rechnungFehler}

} {isLoading ? (

Lädt…

) : ( - n.id} /> +
    + {gefilterteNutzer.map((n) => { + const offen = offeneKonten.has(n.id); + return ( +
  • + + + {offen && ( +
    + {/* Zeile 2: Rechnungsadresse, Preis, Zugang, Registriert */} +
    +
    +

    Rechnungsadresse

    + {n.rg_name ? ( +
    +
    {n.rg_name}
    +
    + {n.rg_strasse} + {n.rg_strasse &&
    } + {[n.rg_plz, n.rg_ort].filter(Boolean).join(" ")} +
    +
    + ) : ( +

    –

    + )} +
    +
    +

    Preis/Monat

    +

    {n.abo_preis_aktuell.replace(".", ",")} €

    +
    +
    +

    Zugang

    +

    + {n.zugang_aktiv ? "aktiv" : "kein Zugang"} + {n.abo_gekuendigt && ( + (gekündigt) + )} +

    +
    +
    +

    Registriert

    +

    + {new Date(n.erstellt_am).toLocaleDateString("de-DE")} +

    +
    +
    + + {/* Zeile 3: Patienten, Aktionen */} +
    + + {n.patienten_anzahl} Patient{n.patienten_anzahl === 1 ? "" : "en"} + + {n.id === eigeneId ? ( + eigenes Konto + ) : ( +
    + {n.aktiv ? ( + + ) : ( + + )} + + {n.patienten_anzahl === 0 && ( + + )} + + +
    + )} +
    +
    + )} +
  • + ); + })} + {gefilterteNutzer.length === 0 && ( +

    + {kontoSuche ? "Keine Konten gefunden." : "Noch keine Konten vorhanden."} +

    + )} +
)}
@@ -278,6 +420,196 @@ export default function AdminPage() { + +

+ Letzte {emailLog?.zeitraum_tage ?? 30} Tage – Protokoll jedes E-Mail-Versands (Passwort-Reset, + Erinnerungen, Änderungsbenachrichtigungen). +

+
+ {Object.entries(emailLog?.nach_status ?? {}).map(([status, anzahl]) => ( + + {status}: {anzahl} + + ))} + {(!emailLog || Object.keys(emailLog.nach_status).length === 0) && ( + Noch keine E-Mails im gewählten Zeitraum. + )} +
+ {emailLog && Object.keys(emailLog.nach_typ).length > 0 && ( +
+ {Object.entries(emailLog.nach_typ).map(([typ, anzahl]) => ( + + {typ}: {anzahl} + + ))} +
+ )} +
    + {emailLog?.eintraege.slice(0, 50).map((e) => ( +
  • + {new Date(e.erstellt_am).toLocaleString("de-DE")} + {" · "} + {e.empfaenger} · {e.typ} ·{" "} + + {e.status} + + {e.fehlermeldung && – {e.fehlermeldung}} +
  • + ))} +
+
+ + +

+ Verschickt eine Beispiel-Mail eines der proaktiven Mailtypen mit Platzhalterdaten an eine frei + wählbare Adresse – zum Prüfen von Design/Anrede/Ton, ohne die echte Versandbedingung (fällige + Aufgabe, geänderter Katalog-Eintrag, …) im System nachstellen zu müssen. Der Betreff bekommt ein + „[Testmail]“-Präfix. +

+
+ + + +
+ {emailTestSenden.isSuccess && ( +

+ Test-Mail wurde an {testMailEmpfaengerWert} verschickt. +

+ )} + {emailTestSenden.isError && ( +

+ {(emailTestSenden.error as Error)?.message || "Versand fehlgeschlagen."} +

+ )} +
+ + +

+ Letzter erfolgreicher Durchlauf je Hintergrundprozess. +

+
    + {schedulerStatus?.map((s) => ( +
  • + + {s.label} + + {s.letzter_lauf + ? `zuletzt gelaufen: ${new Date(s.letzter_lauf).toLocaleString("de-DE")}` + : "noch nie gelaufen"} + {s.einmalig && " (einmalig pro Neustart)"} + +
  • + ))} +
+
+ + + {speicherplatz && ( +
+
+

Uploads gesamt

+

{formatBytes(speicherplatz.uploads_bytes)}

+

+ {Object.entries(speicherplatz.uploads_nach_typ) + .map(([typ, bytes]) => `${typ}: ${formatBytes(bytes)}`) + .join(" · ")} +

+
+
+

Backups ({speicherplatz.backups_anzahl})

+

{formatBytes(speicherplatz.backups_bytes)}

+
+
+

Datenbank

+

{formatBytes(speicherplatz.datenbank_bytes)}

+
+
+ )} +
+ setAktion(null)} - pending={sperren.isPending || entsperren.isPending || loeschen.isPending || aboFreischalten.isPending} + pending={ + sperren.isPending || + entsperren.isPending || + loeschen.isPending || + hartLoeschen.isPending || + aboFreischalten.isPending + } + fehler={aktionFehler(aktion.typ)} /> )}
diff --git a/pflegepilot_v3/frontend/src/app/(app)/admin/statistiken/page.tsx b/pflegepilot_v3/frontend/src/app/(app)/admin/statistiken/page.tsx new file mode 100644 index 0000000..6159d90 --- /dev/null +++ b/pflegepilot_v3/frontend/src/app/(app)/admin/statistiken/page.tsx @@ -0,0 +1,222 @@ +"use client"; + +import { useStatistiken } from "@/lib/admin"; +import { BarChart } from "@/components/BarChart"; +import { SEQUENTIAL_HEX, ordinalPflegegrad, statusFarbe } from "@/lib/chartColors"; +import { getAccent, type AccentName } from "@/lib/theme"; + +const ZIELGRUPPE_LABEL: Record = { + alterspflege: "Alterspflege", + beduerftige: "Bedürftige", + behinderte: "Behinderte", +}; + +const ANTRAG_TYP_LABEL: Record = { + erstantrag: "Erstantrag", + widerspruch: "Widerspruch", + hoeherst: "Höherstufung", + adressaenderung: "Adressänderung", + vollmacht: "Vollmacht", + patientenverfuegung: "Patientenverfügung", + eingliederung: "Eingliederungshilfe", + grundsicherung: "Grundsicherung", + blindenhilfe: "Blindenhilfe", +}; + +const ANTRAG_STATUS_REIHENFOLGE = ["offen", "eingereicht", "in_pruefung", "genehmigt", "abgelehnt"]; +const ANTRAG_STATUS_LABEL: Record = { + offen: "Offen", + eingereicht: "Eingereicht", + in_pruefung: "In Prüfung", + genehmigt: "Genehmigt", + abgelehnt: "Abgelehnt", +}; + +const MONATE_KURZ = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"]; + +function monatLabel(monat: string): string { + const [jahr, monatNr] = monat.split("-"); + const index = Number(monatNr) - 1; + return `${MONATE_KURZ[index] ?? monatNr} ${jahr.slice(2)}`; +} + +function prozent(quote: number | null): string { + return quote == null ? "–" : `${Math.round(quote * 100)}%`; +} + +function euro(betrag: string | number | null): string { + if (betrag == null) return "–"; + return `${Number(betrag).toFixed(2).replace(".", ",")} €`; +} + +function StatKachel({ + label, + wert, + unterzeile, + accent, +}: { + label: string; + wert: string; + unterzeile?: string; + accent: AccentName; +}) { + const a = getAccent(accent); + return ( +
+

{label}

+

{wert}

+ {unterzeile &&

{unterzeile}

} +
+ ); +} + +function Abschnitt({ titel, children }: { titel: string; children: React.ReactNode }) { + return ( +
+

{titel}

+ {children} +
+ ); +} + +export default function StatistikenPage() { + const { data: s, isLoading } = useStatistiken(); + + if (isLoading || !s) { + return
Lädt…
; + } + + const kontenProMonat = s.konten_pro_monat.map((m) => ({ label: monatLabel(m.monat), value: m.anzahl_neu })); + const patientenProMonat = s.patienten_pro_monat.map((m) => ({ + label: monatLabel(m.monat), + value: m.anzahl_neu, + })); + const nachZielgruppe = Object.entries(s.patienten_nach_zielgruppe).map(([key, value]) => ({ + label: ZIELGRUPPE_LABEL[key] ?? key, + value, + })); + const nachPflegegrad = ["0", "1", "2", "3", "4", "5"].map((grad) => ({ + label: `Grad ${grad}`, + value: s.patienten_nach_pflegegrad[grad] ?? 0, + })); + const nachTyp = Object.entries(s.antraege_nach_typ) + .map(([typ, value]) => ({ label: ANTRAG_TYP_LABEL[typ] ?? typ, value })) + .sort((a, b) => b.value - a.value); + const nachStatus = ANTRAG_STATUS_REIHENFOLGE.map((status) => ({ + label: ANTRAG_STATUS_LABEL[status], + value: s.antraege_nach_status[status] ?? 0, + })); + const retention = s.retention_naeherung.map((k) => ({ + label: monatLabel(k.kohorte_monat), + value: k.quote != null ? Math.round(k.quote * 100) : 0, + })); + + return ( +
+

Statistiken

+

+ Konten-Wachstum, Patienten, Anträge und Umsatz auf einen Blick. Alle wachstums-/ + geschäftsbezogenen Zahlen beziehen sich nur auf echte Kundenkonten (ohne Admin- und + Demo-Konto). +

+ + +
+ + + + +
+
+ + + + + + + + + +
+ + + + + ordinalPflegegrad(i)} /> + +
+ + + + + + + statusFarbe(ANTRAG_STATUS_REIHENFOLGE[i])} /> + + +
+ + +
+ + +
+ + + + +
+
+ +
+ + 0 + ? `Median über ${s.time_to_value.anzahl_basis} Konten (Ø ${s.time_to_value.durchschnitt_tage} Tage)` + : "Noch keine Basis" + } + accent="teal" + /> +
+ + +

+ Anteil je Registrierungs-Monat, dessen letzter Login nicht länger als 30 Tage zurückliegt. + Keine echte Kohorten-Historie — die App speichert nur den letzten Login, keine vollständige + Login-Historie. +

+ `${n}%`} /> +
+
+ ); +} diff --git a/pflegepilot_v3/frontend/src/components/BarChart.tsx b/pflegepilot_v3/frontend/src/components/BarChart.tsx new file mode 100644 index 0000000..8f2f71f --- /dev/null +++ b/pflegepilot_v3/frontend/src/components/BarChart.tsx @@ -0,0 +1,127 @@ +"use client"; + +/** + * Abhängigkeitsfreies Inline-SVG-Balkendiagramm (kein Chart-Package im + * Frontend vorhanden, siehe admin/statistiken). Mark-Specs nach der + * Dataviz-Skill-Methode: Balken ≤24px dick, 4px abgerundete Kappe/quadratische + * Grundlinie, Werte direkt an der Balkenspitze beschriftet (bei den hier + * vorkommenden ≤12 Balken pro Diagramm sanktioniert die Skill-Referenz das + * explizit, macht eine Hover-Tooltip-Statemachine überflüssig) - zusätzlich + * ein natives SVG- je Balken als Hover-Bonus. + * + * Wichtig: ein SVG-Wurzelelement clippt nicht automatisch am viewBox-Rand + * (overflow:visible ist der Default) - ein zu knapp bemessenes Platzband für + * gekippten Text malt einfach über den eigenen Rahmen hinaus und kollidiert + * mit Nachbarelementen. Deshalb wird das Platzband hier tatsächlich aus der + * Rotationsgeometrie berechnet (nicht geschätzt), plus Labels werden auf eine + * feste Länge gekürzt (voller Text bleibt im <title> erhalten). + */ + +export type BarChartDatum = { label: string; value: number }; + +type Props = { + data: BarChartDatum[]; + farbe: string | ((datum: BarChartDatum, index: number) => string); + formatWert?: (n: number) => string; + hoehe?: number; +}; + +const BAR_DICKE = 20; // <=24px laut Mark-Spec +const LUECKE = 20; +const WERT_LABEL_BAND = 18; +const ROTATIONS_WINKEL = 50; // Grad - steiler als die uebliche 45°-Konvention, reduziert die horizontale Ausdehnung des gekippten Labels und damit die Kollisionsgefahr mit dem Nachbarbalken +const MAX_LABEL_ZEICHEN = 7; +// Bewusst grosszuegig geschaetzt (echte Zeichenbreiten variieren, Grossbuchstaben +// und "…" sind breiter als der Durchschnitt) - lieber etwas mehr Abstand +// reservieren als eine Kollision riskieren. +const ZEICHEN_BREITE_SCHAETZUNG = 6.2; + +function kuerzeLabel(label: string): string { + return label.length > MAX_LABEL_ZEICHEN ? `${label.slice(0, MAX_LABEL_ZEICHEN - 1)}…` : label; +} + +export function BarChart({ data, farbe, formatWert = (n) => String(n), hoehe = 120 }: Props) { + if (data.length === 0) { + return <p className="text-sm text-slate-500">Keine Daten.</p>; + } + + const maxWert = Math.max(...data.map((d) => d.value), 1); + const slotBreite = BAR_DICKE + LUECKE; + + // Gekippt wird nur, wenn ein horizontales Label tatsaechlich nicht in + // seinen eigenen Slot passen wuerde - kurze Labels ("Grad 3") bleiben + // horizontal und zentriert. + const maxLabelLaenge = Math.max(...data.map((d) => d.label.length)); + const gekippt = maxLabelLaenge * ZEICHEN_BREITE_SCHAETZUNG > slotBreite; + + // Reale Ausdehnung des (gekuerzten) Labels nach der Rotation berechnen, + // statt sie zu schaetzen - textAnchor="end" laesst den Text vom Ankerpunkt + // aus nach links-unten wachsen (siehe Modul-Kommentar). + const gekuerzteLabelLaenge = Math.min(maxLabelLaenge, MAX_LABEL_ZEICHEN); + const labelBreitePx = gekuerzteLabelLaenge * ZEICHEN_BREITE_SCHAETZUNG; + const winkelRad = (ROTATIONS_WINKEL * Math.PI) / 180; + const horizontalAusdehnung = gekippt ? labelBreitePx * Math.cos(winkelRad) : labelBreitePx / 2; + const vertikalAusdehnung = gekippt ? labelBreitePx * Math.sin(winkelRad) : 0; + + const seitenPuffer = Math.ceil(horizontalAusdehnung) + 8; + const achsenLabelBand = Math.ceil(vertikalAusdehnung) + (gekippt ? 16 : 20); + + const breite = data.length * slotBreite + seitenPuffer * 2; + const gesamtHoehe = WERT_LABEL_BAND + hoehe + achsenLabelBand; + const grundlinieY = WERT_LABEL_BAND + hoehe; + + return ( + <svg + viewBox={`0 0 ${breite} ${gesamtHoehe}`} + width="100%" + style={{ maxWidth: breite, height: "auto" }} + role="img" + aria-label="Balkendiagramm" + > + <line x1={0} y1={grundlinieY} x2={breite} y2={grundlinieY} stroke="#c3c2b7" strokeWidth={1} /> + {data.map((d, i) => { + const x = seitenPuffer + i * slotBreite; + const barHoehe = maxWert > 0 ? (d.value / maxWert) * hoehe : 0; + const y = grundlinieY - barHoehe; + const farbwert = typeof farbe === "function" ? farbe(d, i) : farbe; + const mitteX = x + BAR_DICKE / 2; + const labelY = grundlinieY + 12; + return ( + <g key={d.label + i}> + <title> + {d.label}: {formatWert(d.value)} + + + + {formatWert(d.value)} + + + {kuerzeLabel(d.label)} + + + ); + })} + + ); +} + +function topRoundedRectPath(x: number, y: number, breite: number, hoehe: number, radius: number): string { + const r = Math.max(0, Math.min(radius, breite / 2, hoehe)); + if (hoehe <= 0) return `M${x},${y} L${x + breite},${y}`; + return [ + `M${x},${y + hoehe}`, + `L${x},${y + r}`, + `Q${x},${y} ${x + r},${y}`, + `L${x + breite - r},${y}`, + `Q${x + breite},${y} ${x + breite},${y + r}`, + `L${x + breite},${y + hoehe}`, + "Z", + ].join(" "); +} diff --git a/pflegepilot_v3/frontend/src/components/BegruendungModal.tsx b/pflegepilot_v3/frontend/src/components/BegruendungModal.tsx index bb01185..285dd43 100644 --- a/pflegepilot_v3/frontend/src/components/BegruendungModal.tsx +++ b/pflegepilot_v3/frontend/src/components/BegruendungModal.tsx @@ -8,12 +8,16 @@ export function BegruendungModal({ onConfirm, onClose, pending, + fehler, + warnung, }: { titel: string; extraFeld?: { label: string; value: number; onChange: (v: number) => void }; onConfirm: (begruendung: string) => void; onClose: () => void; pending?: boolean; + fehler?: string | null; + warnung?: string; }) { const [begruendung, setBegruendung] = useState(""); @@ -22,6 +26,8 @@ export function BegruendungModal({

{titel}

+ {warnung &&

⚠️ {warnung}

} + {extraFeld && (
@@ -47,6 +53,8 @@ export function BegruendungModal({ className="mb-3 w-full rounded-lg border border-slate-300 px-3 py-2 text-sm" /> + {fehler &&

{fehler}

} +