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:
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"
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user