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 <noreply@anthropic.com>
This commit is contained in:
adminandClaude Sonnet 5 committed 2026-08-02 09:41:38 +02:00
1 parent 55806bb962
commit 8a578d8aa1
12 files changed
+1762 -81

No files matched your search

@@ -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()
@@ -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_<name>, 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"
+255
View File
@@ -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_<original_typ>", 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
+179 -1
View File
@@ -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)
+270
View File
@@ -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),
)
@@ -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')
@@ -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<Aktion | null>(null);
const [backupModalOffen, setBackupModalOffen] = useState(false);
@@ -41,10 +52,27 @@ export default function AdminPage() {
const [dsgvoPid, setDsgvoPid] = useState<number | null>(null);
const [dsgvoGrund, setDsgvoGrund] = useState("");
const [rechnungFehler, setRechnungFehler] = useState<string | null>(null);
const [kontoSuche, setKontoSuche] = useState("");
const [offeneKonten, setOffeneKonten] = useState<Set<number>>(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<NutzerAdmin>[] = [
{
key: "konto",
label: "Konto",
head: true,
render: (n) => (
<div>
<span className="font-medium text-slate-800">{n.name || n.benutzername}</span>
<span className="ml-2 text-xs text-slate-500">
{n.rolle}
{n.ist_demo && " · demo"}
</span>
</div>
),
},
{ 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) => (
<span>
{n.zugang_aktiv ? "aktiv" : "kein Zugang"}
{n.abo_gekuendigt && <span className="ml-1 text-xs text-amber-600">(gekündigt)</span>}
</span>
),
},
{
key: "registriert",
label: "Registriert",
render: (n) => new Date(n.erstellt_am).toLocaleDateString("de-DE"),
},
{
key: "aktionen",
label: "Aktionen",
render: (n) =>
n.id === eigeneId ? (
<span className="text-xs text-slate-500">eigenes Konto</span>
) : (
<div className="flex flex-wrap gap-2">
{n.aktiv ? (
<button onClick={() => setAktion({ typ: "sperren", nutzer: n })} className={buttonStyles.smallDanger}>
Sperren
</button>
) : (
<button onClick={() => setAktion({ typ: "entsperren", nutzer: n })} className={buttonStyles.smallSuccess}>
Entsperren
</button>
)}
<button onClick={() => setAktion({ typ: "loeschen", nutzer: n })} className={buttonStyles.smallDanger}>
Löschen
</button>
<button
onClick={() => {
setMonate(1);
setAktion({ typ: "abo", nutzer: n });
}}
className={buttonStyles.small}
>
Freischalten
</button>
<button onClick={() => rechnungErstellen(n)} className={buttonStyles.small}>
Rechnung
</button>
</div>
),
},
];
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 (
<div className="mx-auto max-w-5xl p-6">
@@ -213,12 +198,169 @@ export default function AdminPage() {
</section>
<section className="mb-6 rounded-2xl border border-slate-200 bg-white p-5">
<p className="mb-3 text-sm font-semibold text-slate-700">Konten</p>
<div className="mb-3 flex flex-wrap items-center justify-between gap-2">
<p className="text-sm font-semibold text-slate-700">
Konten
{nutzer && (
<span className="ml-2 text-xs font-normal text-slate-500">
({gefilterteNutzer.length} von {nutzer.length})
</span>
)}
</p>
<input
type="search"
name="konto_suche"
autoComplete="off"
placeholder="Suchen nach Name, Benutzername, E-Mail, Rechnungsname…"
value={kontoSuche}
onChange={(e) => setKontoSuche(e.target.value)}
className="w-full rounded-lg border border-slate-300 px-3 py-2 text-sm sm:w-80"
/>
</div>
{rechnungFehler && <p className="mb-2 text-sm text-red-600">{rechnungFehler}</p>}
{isLoading ? (
<p className="text-slate-500">Lädt…</p>
) : (
<ResponsiveTable columns={columns} rows={nutzer ?? []} rowKey={(n) => n.id} />
<ul className="flex flex-col gap-2">
{gefilterteNutzer.map((n) => {
const offen = offeneKonten.has(n.id);
return (
<li key={n.id} className="rounded-xl border border-slate-200 bg-white">
<button
type="button"
onClick={() => toggleKonto(n.id)}
className="flex w-full items-center gap-3 px-4 py-3 text-left"
>
{offen ? (
<IconChevronDown size={16} className="shrink-0 text-slate-400" />
) : (
<IconChevronRight size={16} className="shrink-0 text-slate-400" />
)}
{/* Zeile 1: Konto, Status, E-Mail */}
<div className="flex flex-1 flex-wrap items-center gap-x-4 gap-y-1">
<div className="min-w-[160px]">
<span className="font-medium text-slate-800">{n.name || n.benutzername}</span>
<span className="ml-2 text-xs text-slate-500">
{n.rolle}
{n.ist_demo && " · demo"}
</span>
</div>
<span
className={`rounded-full px-2 py-0.5 text-xs font-medium ${
n.aktiv ? "bg-emerald-100 text-emerald-800" : "bg-red-100 text-red-800"
}`}
>
{n.aktiv ? "aktiv" : "gesperrt"}
</span>
<span className="text-sm text-slate-600">{n.email ?? "–"}</span>
</div>
</button>
{offen && (
<div className="border-t border-slate-100 px-4 py-3 pl-11">
{/* Zeile 2: Rechnungsadresse, Preis, Zugang, Registriert */}
<div className="mb-3 flex flex-wrap gap-x-8 gap-y-2">
<div>
<p className="text-xs text-slate-500">Rechnungsadresse</p>
{n.rg_name ? (
<div className="text-xs leading-tight">
<div>{n.rg_name}</div>
<div className="text-slate-500">
{n.rg_strasse}
{n.rg_strasse && <br />}
{[n.rg_plz, n.rg_ort].filter(Boolean).join(" ")}
</div>
</div>
) : (
<p className="text-sm text-slate-700">–</p>
)}
</div>
<div>
<p className="text-xs text-slate-500">Preis/Monat</p>
<p className="text-sm text-slate-700">{n.abo_preis_aktuell.replace(".", ",")} €</p>
</div>
<div>
<p className="text-xs text-slate-500">Zugang</p>
<p className="text-sm text-slate-700">
{n.zugang_aktiv ? "aktiv" : "kein Zugang"}
{n.abo_gekuendigt && (
<span className="ml-1 text-xs text-amber-600">(gekündigt)</span>
)}
</p>
</div>
<div>
<p className="text-xs text-slate-500">Registriert</p>
<p className="text-sm text-slate-700">
{new Date(n.erstellt_am).toLocaleDateString("de-DE")}
</p>
</div>
</div>
{/* Zeile 3: Patienten, Aktionen */}
<div className="flex flex-wrap items-center justify-between gap-3">
<span className="text-sm text-slate-600">
{n.patienten_anzahl} Patient{n.patienten_anzahl === 1 ? "" : "en"}
</span>
{n.id === eigeneId ? (
<span className="text-xs text-slate-500">eigenes Konto</span>
) : (
<div className="flex flex-wrap gap-2">
{n.aktiv ? (
<button
onClick={() => setAktion({ typ: "sperren", nutzer: n })}
className={buttonStyles.smallDanger}
>
Sperren
</button>
) : (
<button
onClick={() => setAktion({ typ: "entsperren", nutzer: n })}
className={buttonStyles.smallSuccess}
>
Entsperren
</button>
)}
<button
onClick={() => setAktion({ typ: "loeschen", nutzer: n })}
className={buttonStyles.smallDanger}
>
Löschen
</button>
{n.patienten_anzahl === 0 && (
<button
onClick={() => setAktion({ typ: "hart_loeschen", nutzer: n })}
className={buttonStyles.smallDanger}
title="Unwiderruflich - im Gegensatz zu 'Löschen' keine Archivierung"
>
Hart löschen
</button>
)}
<button
onClick={() => {
setMonate(1);
setAktion({ typ: "abo", nutzer: n });
}}
className={buttonStyles.small}
>
Freischalten
</button>
<button onClick={() => rechnungErstellen(n)} className={buttonStyles.small}>
Rechnung
</button>
</div>
)}
</div>
</div>
)}
</li>
);
})}
{gefilterteNutzer.length === 0 && (
<p className="py-2 text-sm text-slate-500">
{kontoSuche ? "Keine Konten gefunden." : "Noch keine Konten vorhanden."}
</p>
)}
</ul>
)}
</section>
@@ -278,6 +420,196 @@ export default function AdminPage() {
</ul>
</Collapsible>
<Collapsible
title="E-Mail-Versand"
count={emailLog?.eintraege.length ?? 0}
cardClassName={emailLogAccent.card}
headingClassName={emailLogAccent.heading}
defaultOpen={false}
>
<p className="mb-3 text-xs text-slate-500">
Letzte {emailLog?.zeitraum_tage ?? 30} Tage – Protokoll jedes E-Mail-Versands (Passwort-Reset,
Erinnerungen, Änderungsbenachrichtigungen).
</p>
<div className="mb-3 flex flex-wrap gap-2">
{Object.entries(emailLog?.nach_status ?? {}).map(([status, anzahl]) => (
<span
key={status}
className={`rounded-full px-3 py-1 text-xs font-medium ${
status === "gesendet"
? "bg-emerald-100 text-emerald-800"
: status === "fehlgeschlagen"
? "bg-red-100 text-red-800"
: "bg-slate-100 text-slate-600"
}`}
>
{status}: {anzahl}
</span>
))}
{(!emailLog || Object.keys(emailLog.nach_status).length === 0) && (
<span className="text-xs text-slate-500">Noch keine E-Mails im gewählten Zeitraum.</span>
)}
</div>
{emailLog && Object.keys(emailLog.nach_typ).length > 0 && (
<div className="mb-3 flex flex-wrap gap-2 text-xs text-slate-500">
{Object.entries(emailLog.nach_typ).map(([typ, anzahl]) => (
<span key={typ} className="rounded-lg border border-slate-200 px-2 py-1">
{typ}: {anzahl}
</span>
))}
</div>
)}
<ul className="divide-y divide-slate-100">
{emailLog?.eintraege.slice(0, 50).map((e) => (
<li key={e.id} className="py-2 text-xs text-slate-600">
<span className="font-medium text-slate-700">{new Date(e.erstellt_am).toLocaleString("de-DE")}</span>
{" · "}
{e.empfaenger} · {e.typ} ·{" "}
<span
className={
e.status === "gesendet"
? "text-emerald-700"
: e.status === "fehlgeschlagen"
? "text-red-700"
: "text-slate-500"
}
>
{e.status}
</span>
{e.fehlermeldung && <span className="text-red-600"> – {e.fehlermeldung}</span>}
</li>
))}
</ul>
</Collapsible>
<Collapsible
title="Test-Mail versenden"
cardClassName={emailTestAccent.card}
headingClassName={emailTestAccent.heading}
defaultOpen={false}
>
<p className="mb-3 text-xs text-slate-500">
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.
</p>
<div className="flex flex-col gap-3 sm:flex-row sm:items-end">
<label className="flex-1 text-sm">
<span className="mb-1 block text-xs font-medium text-slate-600">Mailtyp</span>
<select
value={testMailTypWert}
onChange={(e) => {
setTestMailTyp(e.target.value);
emailTestSenden.reset();
}}
className="w-full rounded-lg border border-slate-300 bg-white px-3 py-2 text-sm"
>
{emailTestTypen?.map((t) => (
<option key={t.typ} value={t.typ}>
{t.label}
</option>
))}
</select>
</label>
<label className="flex-1 text-sm">
<span className="mb-1 block text-xs font-medium text-slate-600">Empfänger</span>
<input
type="email"
name="test-mail-empfaenger"
autoComplete="email"
value={testMailEmpfaengerWert}
onChange={(e) => {
setTestMailEmpfaenger(e.target.value);
emailTestSenden.reset();
}}
placeholder="name@beispiel.de"
className="w-full rounded-lg border border-slate-300 bg-white px-3 py-2 text-sm"
/>
</label>
<button
type="button"
onClick={testMailSenden}
disabled={emailTestSenden.isPending || !testMailEmpfaengerWert || !testMailTypWert}
className={buttonStyles.primary}
>
{emailTestSenden.isPending ? "Wird gesendet…" : "Test-Mail senden"}
</button>
</div>
{emailTestSenden.isSuccess && (
<p className="mt-3 text-sm font-medium text-emerald-700">
Test-Mail wurde an {testMailEmpfaengerWert} verschickt.
</p>
)}
{emailTestSenden.isError && (
<p className="mt-3 text-sm font-medium text-red-700">
{(emailTestSenden.error as Error)?.message || "Versand fehlgeschlagen."}
</p>
)}
</Collapsible>
<Collapsible
title="Systemstatus"
cardClassName={schedulerAccent.card}
headingClassName={schedulerAccent.heading}
defaultOpen={false}
>
<p className="mb-3 text-xs text-slate-500">
Letzter erfolgreicher Durchlauf je Hintergrundprozess.
</p>
<ul className="flex flex-col gap-2">
{schedulerStatus?.map((s) => (
<li key={s.name} className="flex items-center gap-2 text-sm">
<span
className={`inline-block h-2.5 w-2.5 rounded-full ${
s.status === "ok"
? "bg-emerald-500"
: s.status === "verzoegert"
? "bg-amber-500"
: "bg-red-500"
}`}
/>
<span className="font-medium text-slate-700">{s.label}</span>
<span className="text-xs text-slate-500">
{s.letzter_lauf
? `zuletzt gelaufen: ${new Date(s.letzter_lauf).toLocaleString("de-DE")}`
: "noch nie gelaufen"}
{s.einmalig && " (einmalig pro Neustart)"}
</span>
</li>
))}
</ul>
</Collapsible>
<Collapsible
title="Speicherplatz"
cardClassName={speicherAccent.card}
headingClassName={speicherAccent.heading}
defaultOpen={false}
>
{speicherplatz && (
<div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
<div>
<p className="text-xs text-slate-500">Uploads gesamt</p>
<p className="text-lg font-semibold text-slate-800">{formatBytes(speicherplatz.uploads_bytes)}</p>
<p className="text-xs text-slate-500">
{Object.entries(speicherplatz.uploads_nach_typ)
.map(([typ, bytes]) => `${typ}: ${formatBytes(bytes)}`)
.join(" · ")}
</p>
</div>
<div>
<p className="text-xs text-slate-500">Backups ({speicherplatz.backups_anzahl})</p>
<p className="text-lg font-semibold text-slate-800">{formatBytes(speicherplatz.backups_bytes)}</p>
</div>
<div>
<p className="text-xs text-slate-500">Datenbank</p>
<p className="text-lg font-semibold text-slate-800">{formatBytes(speicherplatz.datenbank_bytes)}</p>
</div>
</div>
)}
</Collapsible>
<Collapsible
title="System-Backup"
count={backups?.length ?? 0}
@@ -419,14 +751,28 @@ export default function AdminPage() {
? `${aktion.nutzer.benutzername} entsperren`
: aktion.typ === "loeschen"
? `${aktion.nutzer.benutzername} löschen (Soft-Delete)`
: aktion.typ === "hart_loeschen"
? `${aktion.nutzer.benutzername} unwiderruflich hart löschen`
: `${aktion.nutzer.benutzername}: Abo freischalten`
}
extraFeld={
aktion.typ === "abo" ? { label: "Monate", value: monate, onChange: setMonate } : undefined
}
warnung={
aktion.typ === "hart_loeschen"
? "Löscht das Konto endgültig aus der Datenbank – keine Archivierung, keine Wiederherstellung."
: undefined
}
onConfirm={bestaetigen}
onClose={() => 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)}
/>
)}
</div>
@@ -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<string, string> = {
alterspflege: "Alterspflege",
beduerftige: "Bedürftige",
behinderte: "Behinderte",
};
const ANTRAG_TYP_LABEL: Record<string, string> = {
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<string, string> = {
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 (
<div className={`rounded-2xl border p-5 ${a.card}`}>
<p className="text-xs font-medium text-slate-500">{label}</p>
<p className="mt-1 text-3xl font-semibold text-slate-800">{wert}</p>
{unterzeile && <p className="mt-1 text-xs text-slate-500">{unterzeile}</p>}
</div>
);
}
function Abschnitt({ titel, children }: { titel: string; children: React.ReactNode }) {
return (
<section className="mb-6 rounded-2xl border border-slate-200 bg-white p-5">
<p className="mb-3 text-sm font-semibold text-slate-700">{titel}</p>
{children}
</section>
);
}
export default function StatistikenPage() {
const { data: s, isLoading } = useStatistiken();
if (isLoading || !s) {
return <div className="mx-auto max-w-5xl p-6 text-slate-500">Lädt…</div>;
}
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 (
<div className="mx-auto max-w-5xl p-6">
<h1 className="mb-1 text-2xl font-semibold text-slate-800">Statistiken</h1>
<p className="mb-4 text-sm text-slate-500">
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).
</p>
<Abschnitt titel="Konten-Übersicht">
<div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
<StatKachel label="Konten gesamt" wert={String(s.konten_uebersicht.gesamt)} accent="sky" />
<StatKachel
label="Aktiv / gesperrt"
wert={`${s.konten_uebersicht.aktiv} / ${s.konten_uebersicht.gesperrt}`}
accent="emerald"
/>
<StatKachel
label="Selbst registriert / admin-angelegt"
wert={`${s.konten_uebersicht.selbst_registriert} / ${s.konten_uebersicht.admin_angelegt}`}
accent="violet"
/>
<StatKachel
label="Admin- / Demo-Konten"
wert={`${s.konten_uebersicht.admin} / ${s.konten_uebersicht.demo}`}
accent="amber"
/>
</div>
</Abschnitt>
<Abschnitt titel="Konten-Wachstum (neue Konten pro Monat)">
<BarChart data={kontenProMonat} farbe={SEQUENTIAL_HEX} />
</Abschnitt>
<Abschnitt titel="Patienten-Wachstum (neue Patienten pro Monat)">
<BarChart data={patientenProMonat} farbe={SEQUENTIAL_HEX} />
</Abschnitt>
<div className="mb-6 grid grid-cols-1 gap-4 lg:grid-cols-2">
<Abschnitt titel="Patienten nach Zielgruppe">
<BarChart data={nachZielgruppe} farbe={SEQUENTIAL_HEX} />
</Abschnitt>
<Abschnitt titel="Patienten nach Pflegegrad">
<BarChart data={nachPflegegrad} farbe={(_, i) => ordinalPflegegrad(i)} />
</Abschnitt>
</div>
<Abschnitt titel="Anträge nach Typ">
<BarChart data={nachTyp} farbe={SEQUENTIAL_HEX} />
</Abschnitt>
<Abschnitt titel="Anträge nach Status">
<BarChart data={nachStatus} farbe={(_, i) => statusFarbe(ANTRAG_STATUS_REIHENFOLGE[i])} />
</Abschnitt>
<div className="mb-6 grid grid-cols-1 gap-4 sm:grid-cols-2">
<StatKachel
label="Erfolgsquote (genehmigt vs. abgelehnt)"
wert={prozent(s.erfolgsquote.quote)}
unterzeile={`${s.erfolgsquote.genehmigt} genehmigt, ${s.erfolgsquote.abgelehnt} abgelehnt`}
accent="emerald"
/>
<StatKachel
label="Widerspruch-Rate nach Ablehnung"
wert={prozent(s.widerspruch_rate.quote)}
unterzeile={`${s.widerspruch_rate.davon_mit_widerspruch} von ${s.widerspruch_rate.abgelehnte_antraege} Ablehnungen`}
accent="rose"
/>
</div>
<Abschnitt titel="Umsatz (aktueller Stand)">
<div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
<StatKachel label="MRR" wert={euro(s.umsatz.mrr)} accent="emerald" />
<StatKachel label="Zahlende Konten" wert={String(s.umsatz.zahlende_konten)} accent="sky" />
<StatKachel label="Kostenlos freigeschaltet" wert={String(s.umsatz.kostenlose_konten)} accent="amber" />
<StatKachel label="Ohne aktiven Zugang" wert={String(s.umsatz.ohne_zugang)} accent="red" />
</div>
</Abschnitt>
<div className="mb-6 grid grid-cols-1 gap-4 sm:grid-cols-2">
<StatKachel
label="Aktivierungsquote (mind. 1 Patient)"
wert={prozent(s.aktivierung.quote)}
unterzeile={`${s.aktivierung.mit_patient} von ${s.aktivierung.gesamt} Konten`}
accent="violet"
/>
<StatKachel
label="Time-to-Value (Registrierung → 1. Patient)"
wert={s.time_to_value.median_tage != null ? `${s.time_to_value.median_tage} Tage` : "–"}
unterzeile={
s.time_to_value.anzahl_basis > 0
? `Median über ${s.time_to_value.anzahl_basis} Konten (Ø ${s.time_to_value.durchschnitt_tage} Tage)`
: "Noch keine Basis"
}
accent="teal"
/>
</div>
<Abschnitt titel="Retention-Näherung">
<p className="mb-3 text-xs text-slate-500">
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.
</p>
<BarChart data={retention} farbe={SEQUENTIAL_HEX} formatWert={(n) => `${n}%`} />
</Abschnitt>
</div>
);
}
@@ -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-<title> 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)}
</title>
<path d={topRoundedRectPath(x, y, BAR_DICKE, barHoehe, 4)} fill={farbwert} />
<text x={mitteX} y={Math.max(y - 4, 10)} textAnchor="middle" fontSize={10} fill="#52514e">
{formatWert(d.value)}
</text>
<text
x={mitteX}
y={labelY}
textAnchor={gekippt ? "end" : "middle"}
fontSize={10}
fill="#898781"
transform={gekippt ? `rotate(-${ROTATIONS_WINKEL} ${mitteX} ${labelY})` : undefined}
>
{kuerzeLabel(d.label)}
</text>
</g>
);
})}
</svg>
);
}
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(" ");
}
@@ -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({
<div className="w-full max-w-sm rounded-2xl bg-white p-5 shadow-xl">
<h2 className="mb-3 text-sm font-semibold text-slate-800">{titel}</h2>
{warnung && <p className="mb-3 text-sm font-semibold text-red-700">⚠️ {warnung}</p>}
{extraFeld && (
<div className="mb-3">
<label className="mb-1 block text-xs font-medium text-slate-500">{extraFeld.label}</label>
@@ -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 && <p className="mb-3 text-sm text-red-600">{fehler}</p>}
<div className="flex gap-2">
<button
onClick={onClose}
+167 -1
View File
@@ -45,6 +45,45 @@ export type BackupEintrag = {
erstellt_am: string;
};
export type EmailLogEintrag = {
id: number;
empfaenger: string;
typ: string;
betreff: string;
status: "gesendet" | "fehlgeschlagen" | "uebersprungen";
fehlermeldung: string | null;
erstellt_am: string;
};
export type EmailLog = {
eintraege: EmailLogEintrag[];
nach_typ: Record<string, number>;
nach_status: Record<string, number>;
zeitraum_tage: number;
};
export type EmailTestTyp = {
typ: string;
label: string;
};
export type SchedulerStatusEintrag = {
name: string;
label: string;
letzter_lauf: string | null;
erwartetes_intervall_sekunden: number;
einmalig: boolean;
status: "ok" | "verzoegert" | "nie_gelaufen";
};
export type Speicherplatz = {
uploads_bytes: number;
uploads_nach_typ: Record<string, number>;
backups_bytes: number;
backups_anzahl: number;
datenbank_bytes: number;
};
export function useNutzerListe() {
return useQuery<NutzerAdmin[]>({
queryKey: ["admin", "nutzer"],
@@ -113,6 +152,58 @@ export function useAuditLog() {
});
}
export function useEmailLog(tage = 30) {
return useQuery<EmailLog>({
queryKey: ["admin", "email-log", tage],
queryFn: () => api<EmailLog>(`/api/admin/email-log?tage=${tage}`),
});
}
export function useEmailTestTypen() {
return useQuery<EmailTestTyp[]>({
queryKey: ["admin", "email-test-typen"],
queryFn: () => api<EmailTestTyp[]>("/api/admin/email-test/typen"),
staleTime: Infinity, // feste Registry im Backend, aendert sich nicht zur Laufzeit
});
}
export function useEmailTestSenden() {
return useMutation({
mutationFn: ({ empfaenger, typ }: { empfaenger: string; typ: string }) =>
api<{ ok: boolean }>("/api/admin/email-test", {
method: "POST",
body: JSON.stringify({ empfaenger, typ }),
}),
});
}
export function useSchedulerStatus() {
return useQuery<SchedulerStatusEintrag[]>({
queryKey: ["admin", "scheduler-status"],
queryFn: () => api<SchedulerStatusEintrag[]>("/api/admin/scheduler-status"),
refetchInterval: 60_000,
});
}
export function useSpeicherplatz() {
return useQuery<Speicherplatz>({
queryKey: ["admin", "speicherplatz"],
queryFn: () => api<Speicherplatz>("/api/admin/speicherplatz"),
});
}
export function formatBytes(bytes: number): string {
if (bytes < 1024) return `${bytes} B`;
const einheiten = ["KB", "MB", "GB", "TB"];
let wert = bytes;
let i = -1;
do {
wert /= 1024;
i++;
} while (wert >= 1024 && i < einheiten.length - 1);
return `${wert.toFixed(1)} ${einheiten[i]}`;
}
export function useAdminMutationen() {
const queryClient = useQueryClient();
const invalidate = () => {
@@ -160,6 +251,15 @@ export function useAdminMutationen() {
onSuccess: invalidate,
});
// Unwiderruflicher Hard-Delete - anders als "loeschen" (Soft-Delete,
// archiviert Patienten) verweigert das Backend hier (400), solange das
// Konto noch irgendwelche Patienten besitzt.
const hartLoeschen = useMutation({
mutationFn: ({ uid, begruendung }: { uid: number; begruendung: string }) =>
api(`/api/nutzer/${uid}`, { method: "DELETE", body: JSON.stringify({ begruendung }) }),
onSuccess: invalidate,
});
const aboFreischalten = useMutation({
mutationFn: ({ uid, monate, begruendung }: { uid: number; monate: number; begruendung: string }) =>
api(`/api/admin/nutzer/${uid}/abo-freischalten`, {
@@ -169,7 +269,7 @@ export function useAdminMutationen() {
onSuccess: invalidate,
});
return { anlegen, aktualisieren, sperren, entsperren, loeschen, aboFreischalten };
return { anlegen, aktualisieren, sperren, entsperren, loeschen, hartLoeschen, aboFreischalten };
}
export function useEinstellungen() {
@@ -211,6 +311,72 @@ export async function rechnungHerunterladen(uid: number, betragBrutto: number, l
setTimeout(() => URL.revokeObjectURL(url), 2000);
}
export type MonatsWert = { monat: string; anzahl_neu: number; anzahl_kumuliert: number };
export type KontenUebersicht = {
gesamt: number;
aktiv: number;
gesperrt: number;
admin: number;
demo: number;
selbst_registriert: number;
admin_angelegt: number;
};
export type Erfolgsquote = { genehmigt: number; abgelehnt: number; quote: number | null };
export type WiderspruchRate = {
abgelehnte_antraege: number;
davon_mit_widerspruch: number;
quote: number | null;
};
export type Umsatz = {
mrr: string;
zahlende_konten: number;
kostenlose_konten: number;
ohne_zugang: number;
durchschnitt_pro_zahlendem_konto: string | null;
};
export type Aktivierung = { gesamt: number; mit_patient: number; quote: number | null };
export type TimeToValue = {
median_tage: number | null;
durchschnitt_tage: number | null;
anzahl_basis: number;
};
export type KohortenWert = {
kohorte_monat: string;
anzahl_konten: number;
aktiv_letzte_30_tage: number;
quote: number | null;
};
export type Statistiken = {
konten_uebersicht: KontenUebersicht;
konten_pro_monat: MonatsWert[];
patienten_pro_monat: MonatsWert[];
patienten_nach_zielgruppe: Record<string, number>;
patienten_nach_pflegegrad: Record<string, number>;
antraege_nach_typ: Record<string, number>;
antraege_nach_status: Record<string, number>;
erfolgsquote: Erfolgsquote;
widerspruch_rate: WiderspruchRate;
umsatz: Umsatz;
aktivierung: Aktivierung;
time_to_value: TimeToValue;
retention_naeherung: KohortenWert[];
};
export function useStatistiken() {
return useQuery<Statistiken>({
queryKey: ["admin", "statistiken"],
queryFn: () => api<Statistiken>("/api/admin/statistiken"),
});
}
export async function dsgvoExportHerunterladen(pid: number, begruendung: string) {
const apiUrl = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:8100";
const res = await fetch(`${apiUrl}/api/admin/patienten/${pid}/dsgvo-export`, {
@@ -0,0 +1,49 @@
/**
* Farbzuordnung fuer die Statistik-Seite (admin/statistiken), nach der
* Dataviz-Skill-Methode (Job bestimmt die Farbe: sequenziell/ordinal/Status),
* aber auf Basis der in dieser App bereits etablierten Tailwind-Hex-Werte
* statt eines neuen Farbschemas - admin/page.tsx nutzt bereits emerald=gut,
* red=kritisch, amber=Warnung fuer Status-Badges (Konten-Status, E-Mail-Log,
* Scheduler-Status); dieselbe Konvention wird hier fuer Status-gefaerbte
* Balken (Antraege nach Status) weitergefuehrt.
*/
/** Ein Blauton fuer reine Groessenvergleiche (Wachstum, Zielgruppe,
* Antragstyp, Retention) - alle Balken eines Diagramms tragen dieselbe
* Farbe, da es sich um EIN Merkmal ueber verschiedene Kategorien handelt,
* nicht um mehrere Serien (siehe Dataviz-Skill: "one series -> same slot-1
* hue"). */
export const SEQUENTIAL_HEX = "#0284c7"; // Tailwind sky-600
/** Pflegegrad ist ordinal (0-5 mit inhaerenter Reihenfolge/Schwere) - eine
* einzelne Farbfamilie mit monoton steigender Saettigung macht die
* Reihenfolge visuell erkennbar. */
const PFLEGEGRAD_INDIGO_STUFEN = [
"#c7d2fe", // indigo-200 - Grad 0
"#a5b4fc", // indigo-300 - Grad 1
"#818cf8", // indigo-400 - Grad 2
"#6366f1", // indigo-500 - Grad 3
"#4f46e5", // indigo-600 - Grad 4
"#4338ca", // indigo-700 - Grad 5
];
export function ordinalPflegegrad(grad: number): string {
const index = Math.min(Math.max(Math.round(grad), 0), PFLEGEGRAD_INDIGO_STUFEN.length - 1);
return PFLEGEGRAD_INDIGO_STUFEN[index];
}
/** Antrags-Status ist ein echter Zustand -> Status-Farben statt Kategorial-
* Farben (genehmigt=gut, abgelehnt=kritisch). Die drei "noch in Bearbeitung"-
* Zustaende teilen sich dieselbe Warn-Familie (Amber, in Abstufungen), damit
* sie als zusammengehoerig erkennbar, aber unterscheidbar bleiben. */
const STATUS_HEX: Record<string, string> = {
genehmigt: "#059669", // emerald-600 - gut
abgelehnt: "#dc2626", // red-600 - kritisch
offen: "#fde68a", // amber-200
eingereicht: "#fcd34d", // amber-300
in_pruefung: "#f59e0b", // amber-500
};
export function statusFarbe(status: string): string {
return STATUS_HEX[status] ?? "#94a3b8"; // slate-400 Fallback fuer unbekannte Status
}