27 Commits 6427d252ea ... 82839ae76b

Auteur SHA1 Message Date
  gc-server3 82839ae76b Projekt an die Reisacher-Datenbank angepasst il y a 1 semaine
  gc-server3 39f9011c2a Logging il y a 2 semaines
  gc-server3 0158a876f8 Füge Dashboard-Funktionalität hinzu und entferne veraltete SQL-Abfragen il y a 2 semaines
  gc-server3 86989f858c Füge Verursacher- und Wiedervorlage-Buttons hinzu il y a 2 semaines
  gc-server3 f3f72e73a7 Header-Stil mit Drop-Shadow angepasst il y a 2 semaines
  gc-server3 949e2d27e9 Füge Unterstützung für die Einreichung von Kommentaren mit Dateianhängen hinzu il y a 2 semaines
  gc-server3 1a67095ee1 Füge Blocktitel für die Seiten hinzu il y a 2 semaines
  gc-server3 996210f053 Implementierung von Rückkehr-URLs und Fokusverwaltung für Detailansichten il y a 2 semaines
  gc-server3 6135485984 Implementierung einer neuen Forderungsliste mit verbessertem Layout und interaktiven Filtern il y a 2 semaines
  gc-server3 d905fcf9f4 Verbessere Schriftgrößen und Abstände in den Detailansichten für bessere Lesbarkeit il y a 2 semaines
  gc-server3 e0eed56703 Verbessere das Styling und die Struktur der Detailansichten il y a 2 semaines
  gc-server3 000c36f4e2 Verbesserungen an den Detailansichten für Forderungen il y a 2 semaines
  gc-server3 41b6bb7dfb Implementierung von Kommentar- und Buchungsbeleg-Tab-Filterung mit dynamischen Inhalten il y a 2 semaines
  gc-server3 6b89ba4325 Aktualisiere SQL-Abfrage zur Verwendung von Rolle_ID und Rolle_Name für bessere Datenklarheit il y a 2 semaines
  gc-server3 82191be5c0 Verbessere CSRF-Token-Verwaltung und teste, dass Anmeldeformulare bei mehreren Tabs gültig bleiben il y a 2 semaines
  gc-server3 92f0a8a6ce Aktualisiere Chat-Nachrichten-Stile und -Klassennamen für bessere Benutzererkennung il y a 2 semaines
  gc-server3 bb487e98b6 Verbessere Kommentarverarbeitung und passe Zeitformat an; aktiviere automatisches Neuladen des Servers il y a 2 semaines
  gc-server3 1ad0ad9bdc Füge Unterstützung für Forderungsdetails hinzu und verbessere Berechtigungsprüfung il y a 1 mois
  gc-server3 e46d02a259 Anmeldung ohne LDAP im Debug-Modus il y a 1 mois
  gc-server3 0579a3d06b Port auf 8094 geändert il y a 1 mois
  gc-server3 4f366c126a Entferne nicht mehr benötigte Dateien und bereinige den Code il y a 1 mois
  gc-server3 6cf42fec89 Füge Authentifizierungs- und Berechtigungsmanagement hinzu il y a 1 mois
  gc-server3 444a303300 Kleine Anpassungen il y a 2 mois
  gc-server3 1a61216d6f Anpassungen uvicorn il y a 2 mois
  gc-server3 a666295e47 Anpassungen Docuware il y a 3 mois
  gc-server3 8be9b39d56 Datenbankfelder der Hauptabfrage angepasst il y a 3 mois
  gc-server3 e6f3e42413 Webservice mit Logs il y a 3 mois
100 fichiers modifiés avec 7368 ajouts et 3484 suppressions
  1. 30 0
      .env.example
  2. 2 0
      .gitignore
  3. 1 0
      .vscode/settings.json
  4. 305 4
      README.md
  5. 156 0
      app/auth.py
  6. 0 17
      app/auth2.py
  7. 57 53
      app/cleanup_comments.py
  8. 97 0
      app/comment_submission.py
  9. 88 13
      app/config.py
  10. 144 0
      app/dashboard_segment.py
  11. 70 8
      app/db.py
  12. 12 12
      app/docuware_search.py
  13. 220 14
      app/file_storage.py
  14. 196 0
      app/forderung_dashboard.py
  15. 19 0
      app/forderung_data.py
  16. 39 0
      app/forderung_history.py
  17. 27 0
      app/forderung_summary.py
  18. 70 0
      app/http_logging.py
  19. 15 14
      app/imap.py
  20. 4 1
      app/jinja_templates.py
  21. 106 19
      app/ldap.py
  22. 321 0
      app/logging_setup.py
  23. 14 12
      app/main.py
  24. 0 50
      app/main2.py
  25. 0 94
      app/main3.py
  26. 0 62
      app/models.py
  27. 132 0
      app/navigation.py
  28. 89 19
      app/oauth_token.py
  29. 92 0
      app/permissions.py
  30. 388 232
      app/routes.py
  31. 0 47
      app/schemas.py
  32. 0 35
      app/users.py
  33. 128 0
      app/verursacher.py
  34. 123 0
      app/wiedervorlage.py
  35. BIN
      dev.db
  36. 9 8
      filter_export.py
  37. 60 0
      migrations/001_authentication.sql
  38. 2 0
      pyproject.toml
  39. 24 0
      server.py
  40. 99 0
      static/assets/css/app.css
  41. 54 0
      static/assets/css/dashboard.css
  42. 168 0
      static/assets/css/details.css
  43. 93 0
      static/assets/css/list.css
  44. 285 121
      static/assets/css/main.css
  45. 0 1183
      static/assets/css/redesign.css
  46. BIN
      static/assets/images/SuK.png
  47. 86 0
      static/assets/js/attachments.js
  48. 164 0
      static/assets/js/dashboard.js
  49. 29 0
      static/assets/js/layout.js
  50. 101 0
      static/assets/js/list.js
  51. 79 0
      static/assets/js/navigation.js
  52. 84 0
      static/assets/js/verursacher.js
  53. 61 0
      static/assets/js/wiedervorlage.js
  54. 49 137
      templates/base/base.html
  55. 24 460
      templates/base/chat_container.html
  56. 26 61
      templates/base/liste.html
  57. 41 33
      templates/base/liste_filter.html
  58. 13 7
      templates/base/liste_tabelle.html
  59. 11 4
      templates/base/login.html
  60. 19 0
      templates/base/logout.html
  61. 65 121
      templates/forderungen/dashboard/dashboard.html
  62. 0 21
      templates/forderungen/dashboard/queries/dashboard_betriebe.sql
  63. 0 21
      templates/forderungen/dashboard/queries/dashboard_staffel.sql
  64. 0 18
      templates/forderungen/dashboard/queries/dashboard_verursacher.sql
  65. 3 0
      templates/forderungen/details/comment_submission.html
  66. 39 51
      templates/forderungen/details/details.html
  67. 17 10
      templates/forderungen/details/details_buchungen.html
  68. 6 4
      templates/forderungen/details/details_dateien.html
  69. 32 33
      templates/forderungen/details/details_formular.html
  70. 24 27
      templates/forderungen/details/details_kommentare.html
  71. 117 312
      templates/forderungen/details/details_uebersicht.html
  72. 7 0
      templates/forderungen/details/files_panel.html
  73. 15 0
      templates/forderungen/details/history_tabs.html
  74. 22 0
      templates/forderungen/details/notice.html
  75. 3 3
      templates/forderungen/details/queries/auftraege_positionen.sql
  76. 18 25
      templates/forderungen/details/queries/forderungen_buchungen.sql
  77. 16 10
      templates/forderungen/details/queries/forderungen_details.sql
  78. 13 9
      templates/forderungen/details/queries/forderungen_kommentare.sql
  79. 3 3
      templates/forderungen/details/queries/forderungen_mahnungen.sql
  80. 31 0
      templates/forderungen/details/queries/history_scope.sql
  81. 1 1
      templates/forderungen/details/queries/post/post_comments.sql
  82. 21 21
      templates/forderungen/details/queries/post/post_details.sql
  83. 0 2
      templates/forderungen/liste/config/liste_filter.csv
  84. 13 14
      templates/forderungen/liste/liste_kopfzeile.html
  85. 64 30
      templates/forderungen/liste/liste_zeile.html
  86. 31 28
      templates/forderungen/liste/queries/forderungen_liste.sql
  87. 29 0
      templates/forderungen/liste/summary.html
  88. 8 0
      templates/forderungen/verursacher/button.html
  89. 8 0
      templates/forderungen/verursacher/detail_field.html
  90. 34 0
      templates/forderungen/verursacher/modal.html
  91. 24 0
      templates/forderungen/wiedervorlage/modal.html
  92. 24 0
      tests/__init__.py
  93. 193 0
      tests/test_auth.py
  94. 366 0
      tests/test_dashboard.py
  95. 158 0
      tests/test_debug_auth.py
  96. 346 0
      tests/test_forderung_history.py
  97. 217 0
      tests/test_forderung_list.py
  98. 129 0
      tests/test_forderung_notice.py
  99. 482 0
      tests/test_logging.py
  100. 263 0
      tests/test_navigation.py

+ 30 - 0
.env.example

@@ -0,0 +1,30 @@
+ENVIRONMENT=production
+# Development only: ENVIRONMENT=development and DEBUG_AUTH=true enable username=password login.
+DEBUG_AUTH=false
+DATABASE_URL=mssql+pyodbc://server/database?driver=ODBC+Driver+18+for+SQL+Server&trusted_connection=yes&TrustServerCertificate=no
+
+AUTH_PROXY_HEADER=X-Remote-User
+TRUSTED_PROXY_IPS=127.0.0.1,::1
+JWT_SECRET=replace-with-at-least-32-random-bytes
+JWT_ISSUER=gcepic
+JWT_AUDIENCE=gcepic-web
+JWT_IDLE_MINUTES=30
+JWT_ABSOLUTE_HOURS=8
+COOKIE_SECURE=true
+
+LDAP_URL=ldaps://domain-controller.example.local:636
+LDAP_BASE_DN=DC=example,DC=local
+LDAP_BIND_DN=CN=gcepic-service,OU=Service Accounts,DC=example,DC=local
+LDAP_BIND_PASSWORD=replace-me
+LDAP_UPN_SUFFIX=example.local
+LDAP_START_TLS=false
+
+LOCAL_STORAGE=C:\\Data\\GCEPIC
+UPLOAD_MAX_FILE_SIZE_MB=50
+
+LOG_LEVEL=INFO
+LOG_DIR=logs
+LOG_TO_FILE=true
+LOG_TO_CONSOLE=true
+LOG_RETENTION_DAYS=30
+LOG_SQL_STATEMENT=true

+ 2 - 0
.gitignore

@@ -8,4 +8,6 @@ wheels/
 
 # Virtual environments
 .venv
+.uv-cache/
 .env
+logs/

+ 1 - 0
.vscode/settings.json

@@ -8,6 +8,7 @@
     },
     "isort.args":["--profile", "black"],
     "black-formatter.args": ["--line-length", "120"],
+    "python.useEnvironmentsExtension": true,
     "python.testing.pytestEnabled": false,
     "python.testing.unittestEnabled": true,
     "files.associations": {

+ 305 - 4
README.md

@@ -31,10 +31,10 @@ Das übernimmt `uv`
 ```cmd
 cd C:\Projekte\Reisacher-Forderung
 uv sync
-echo DATABASE_URL=mssql+pyodbc://user:pass@server:port/database?driver=SQL+Server+Native+Client+11.0 > .env
+copy .env.example .env
 ```
 
-Dann muss noch die Datenbankanbindung definiert werden. Dazu muss die Datei `.env` bearbeitet werden und die Platzhalter mit der tatsächlichen Datenbank-Anmeldung eingetragen werden.
+Danach müssen in `.env` die Datenbank-, LDAP-, Proxy- und JWT-Platzhalter ersetzt werden.
 
 Danach kann der Webserver gestartet werden:
 
@@ -61,6 +61,307 @@ Das Repository ist nun bereit für die Nutzung.
 
 Öffne <http://127.0.0.1:8000> im Browser.
 
-## Deployment
+## Authentifizierung und Deployment
 
-TODO
+Die Anwendung läuft im Produktivbetrieb ausschließlich hinter dem IIS-Reverse-Proxy auf
+`127.0.0.1:8094`. IIS entfernt einen eventuell vom Client gelieferten Header
+`X-Remote-User` und setzt ihn nur für erfolgreich per Windows Authentication bestätigte
+Benutzer neu. Fehlt der Header, bietet die Anwendung die Anmeldung gegen Active Directory
+über LDAPS an.
+
+1. `migrations/001_authentication.sql` auf der Anwendungsdatenbank ausführen.
+2. `.env.example` nach `.env` kopieren und alle Platzhalter ersetzen.
+3. Ein eigenes zufälliges `JWT_SECRET` mit mindestens 32 Byte konfigurieren.
+4. Das LDAPS-Zertifikat des Domain Controllers auf dem Server als vertrauenswürdig installieren.
+5. Die IIS-Proxyadresse in `TRUSTED_PROXY_IPS` eintragen und den FastAPI-Port nicht extern freigeben.
+6. Den Windows-Dienst mit `webservice/install_service.bat` installieren.
+
+Die Rollenprioritäten sind: Buchhaltung (400), Standortleitung (300),
+Abteilungsleitung (200) und Mitarbeiter (100). Berechtigungen werden bei jedem Request
+aus `dbo.Benutzer_Rechte` gelesen; leere Benutzerkennungen erteilen keine Rechte.
+
+Tests werden ohne zusätzliche Testabhängigkeiten ausgeführt:
+
+```cmd
+.venv\Scripts\python.exe -m unittest discover -v
+```
+
+## Filter auf der Forderungsdetailseite
+
+Kommentare und Buchungsbelege starten jeweils mit „Diese Rechnung“ und lassen sich
+unabhängig auf offene Rechnungen, das Fahrzeug oder die gesamte Debitorhistorie erweitern.
+Die Auswahl gilt für die geöffnete Seite und wird beim Neuladen zurückgesetzt.
+Die Fahrzeugansicht bleibt auf denselben Debitor begrenzt und ist ohne Fahrzeugnummer deaktiviert.
+Offen bedeutet `Beleg_Offen <> 0`; Zahlungen werden über `Bezug_Beleg_Nr` zugeordnet.
+
+Alle Filter bleiben im Mandanten der Ausgangsrechnung. Nach erfolgreicher Rechteprüfung
+dieser Rechnung umfasst die erweiterte Ansicht ausdrücklich auch andere Standorte und
+Abteilungen des Debitors. Der direkte Zugriff auf andere Rechnungen wird separat geprüft.
+Neue Kommentare gehören immer zur geöffneten Rechnung, auch in erweiterten Ansichten.
+Filterwechsel erhalten ungespeicherte Eingaben. Buchungsbelege sind auf 1.000 Zeilen begrenzt;
+bei Erreichen dieses Limits erscheint ein Hinweis.
+
+Die lesenden Endpunkte `/app/forderungen/details/{primary_key}/kommentare` und
+`/app/forderungen/details/{primary_key}/buchungen` liefern HTML-Fragmente für HTMX.
+`scope` akzeptiert `invoice` (Standard), `open`, `vehicle` und `debtor`; andere Werte
+werden mit HTTP 422 abgelehnt. Kommentar-POSTs übergeben die aktuelle Auswahl als
+`comment_scope`. Datenbankschemaänderungen sind nicht erforderlich.
+
+## Debug-Anmeldung ohne LDAP
+
+Für Entwicklung und manuelle Tests diese Werte in `.env` setzen und die Anwendung neu starten:
+
+```dotenv
+ENVIRONMENT=development
+DEBUG_AUTH=true
+COOKIE_SECURE=false
+```
+
+Unter `/login` dieselbe Benutzerkennung in beide Felder eingeben, z. B.
+Benutzername `winter` und Passwort `winter`. Beide Eingaben müssen exakt übereinstimmen.
+Die Kennung wird anschließend wie beim AD-Login normalisiert. Eine gültige Zuordnung in
+`dbo.Benutzer_Rechte` zu einer aktiven Rolle in `dbo.Rollen` ist weiterhin erforderlich;
+mehrere Berechtigungszeilen werden wie bisher vereinigt. Ein LDAP-Server ist dafür nicht nötig,
+die konfigurierte SQL-Datenbank und die Authentifizierungsmigration hingegen schon.
+
+Im Debugmodus werden IIS-Identitätsheader ignoriert, damit verschiedene Benutzer über
+das Formular getestet werden können. JWT, CSRF, Logout und die Rechteprüfung pro Request
+bleiben aktiv; der Token enthält `auth_source=debug`. Benutzername wird als Anzeigename
+verwendet, E-Mail bleibt leer. Nach dem Deaktivieren von `DEBUG_AUTH` werden diese Tokens
+nicht mehr akzeptiert. Standardmäßig ist `DEBUG_AUTH=false`; außerhalb der Umgebungen
+`development`, `debug` und `test` verweigert die Anwendung den Start mit aktivem Debug-Login.
+`COOKIE_SECURE=false` ist nur für lokale HTTP-Tests gedacht; bei HTTPS auf `true` setzen.
+
+## Forderungsdashboard
+
+Das Dashboard verwendet dieselbe berechtigte Belegabfrage wie die Liste. Anzahl und
+`Beleg_Offen` enthalten auch Gutschriften, negative Beträge und Nullbeträge; jeder Beleg
+wird anhand von Mandant und Belegnummer einmal gezählt. Die Berechtigungsprüfung erfolgt
+vor der Aggregation über Benutzer, Hauptbetrieb, Standort und Abteilung. Beträge werden
+mit Dezimalarithmetik summiert. An den Browser gehen nur berechtigte Aggregate.
+
+Die Rubriken Altersstaffel, Standort und Verursacher zeigen horizontale Balken mit
+Umschalter zwischen Betrag und Anzahl. Die Stapelung lässt sich zwischen Abteilung und
+Wiedervorlage wählen (`stack=abteilung|wiedervorlage`). Negative Beträge liegen links der
+Null. Verursacherüberschreibungen und die effektive Wiedervorlage werden wie in der Liste
+berücksichtigt. Für die Staffelung gilt zuerst `Forderungen_Details.Wiedervorlage`,
+ersatzweise `Beleg_Faellig_Datum`. Maßgeblich ist der Berliner Kalendertag:
+„Überfällig“ liegt vor heute, „In 3 Tagen fällig“ umfasst heute bis heute + 3 Tage,
+„Noch nicht fällig“ heute + 4 bis einschließlich heute + 14 Tage und „zurückgestellt“
+alles danach. Fehlen beide Datumsfelder, bleibt der Beleg separat als „Ohne Datum“ sichtbar.
+Die verwendeten Datumsgrenzen stehen konkret im Listenlink und wandern nicht nachträglich.
+Alte Dashboardadressen mit `page=Wiedervorlage` wechseln zum Standort mit
+Wiedervorlagestapelung; bestehende Listenlinks bleiben gültig.
+
+Mouseover zeigt beide Kennzahlen für Segment und Gruppe; Antippen fixiert die Anzeige,
+Escape schließt sie. „Liste öffnen“ startet einen neuen Tab. Die aufklappbare Datentabelle
+bietet dieselben Werte und Links per Tastatur, auch für Beträge von null Euro.
+Suche und Diagrammseiten mit jeweils 20 Gruppen ändern nicht die Gesamtkennzahlen.
+`page=Altersstaffel|Standort|Verursacher`, `metric=betrag|anzahl` und `stack` bestimmen
+die initiale Ansicht; Standard ist „Nach Standort“. Chart.js 4.6.1 wird erst beim Dashboardaufruf geladen; bei einem
+Ladefehler bleibt die Datentabelle verfügbar. Es gibt keine neuen Schreibaktionen.
+
+Die standardmäßig ausgeschaltete Checkbox „Nur Rechnungen“ (`only_invoices=true`) begrenzt
+Kennzahlen, Diagramme und Datentabelle exakt auf `Rechnung_Gutschrift = 'Rechnung'`.
+Rechnungen mit negativem oder null offenem Betrag bleiben enthalten. Die Auswahl bleibt
+bei Rubrik- und Kennzahlwechseln sowie beim Neuladen erhalten und gilt auch für sämtliche
+verlinkten Listen; deren Dashboardfilter trägt dafür das boolesche Feld `only_invoices`.
+
+Der zusätzliche Listenparameter `dashboard_segment` enthält eine URL-kodierte JSON-Auswahl
+mit `view`, `key` und optional `department` beziehungsweise `follow_up` mit konkreten
+Datumsgrenzen. Gruppen werden exakt mit gebundenen Parametern
+gefiltert; fehlende Werte stehen ausdrücklich als `null`. Ungültige Auswahlen werden mit
+HTTP 400 abgelehnt. Normale Listenfilter wirken zusätzlich und behalten ihre bisherige
+Teiltextsuche. Der Dashboardfilter zählt als ein aktiver Filter, ist separat entfernbar
+und bleibt bei Nachladen, Detailnavigation, Rückkehr, Bearbeitungsmodals und Login erhalten.
+
+## Darstellung der Forderungsliste
+
+Die Filter bleiben vollständig sichtbar und sind in Organisation, Kunde und Beleg sowie
+Bearbeitung und Wiedervorlage gegliedert. Beim Scrollen der Seite dockt der Tabellenkopf
+unter der Navigation an; bei schmalen Fenstern lässt sich die Tabelle seitlich verschieben.
+Kommentare und Antragsinformationen werden je Beleg über „Anzeigen“ eingeblendet.
+
+Die Fußleiste zeigt Anzahl und offenen Gesamtbetrag aller gefilterten Treffer, unabhängig
+von den bereits nachgeladenen Zeilen. Aktive Filter lassen sich dort aufklappen.
+Auch ohne Treffer bleiben die Filter bedienbar. Die gemeinsamen Gestaltungsregeln liegen
+in `app.css`, die Ansichten ergänzen `list.css` beziehungsweise `details.css`.
+
+## Rückkehr aus der Detailseite und erneute Anmeldung
+
+„Zurück“, „Speichern & Zurück“ und Browser-Zurück laden die Liste frisch, behalten die
+Filter und führen zur zuvor geöffneten Rechnung. Dazu wird auf der Detailseite eine
+validierte Listenadresse in `return_to` und auf der Liste die Belegkennung in `focus`
+mitgeführt. Liegt der Beleg hinter dem ersten Nachladeblock, liefert der erste Aufruf
+die Zeilen bis einschließlich seines Blocks; danach läuft das Nachladen normal weiter.
+Ist der Beleg nicht mehr enthalten, bleiben die Filter bestehen und ein Hinweis erscheint.
+Der Browser hält Rückkehrkontexte getrennt je Tab und Benutzer; es werden keine
+Kommentare oder Formulareingaben im Browserspeicher abgelegt.
+
+Bei abgelaufener Anmeldung führen HTMX-Anfragen nach dem Login auf die vollständige
+gefilterte Liste beziehungsweise Detailseite. Kommentar- und Buchungsfragmente sowie
+technische Nachladeseiten sind keine Login-Rücksprungziele. Unterbrochene Schreibaktionen
+werden nicht automatisch wiederholt; ungespeicherte Eingaben werden nicht gesichert.
+
+
+## Verursacher ändern
+
+Der Stift neben dem Verursacher öffnet in Liste und Detailseite dasselbe Auswahlmodal.
+Die Benutzer stammen aus `dbo.Benutzer_Rolle` (`Benutzer_ID`, `Name`, `Rolle_Name`)
+und lassen sich nach Rolle filtern. Mehrere Rollen erzeugen keine doppelten Benutzer
+oder Rechnungszeilen. Jeder Benutzer mit Belegzugriff darf die Zuordnung ändern.
+
+Gespeichert wird ausschließlich `dbo.Forderungen_Details.Verursacher_Benutzer_ID`.
+„Auf ursprünglichen Verursacher zurücksetzen“ entfernt diese Überschreibung.
+Auf der Detailseite steht die aktuelle Zuordnung im Bereich „Bearbeitung“ oberhalb
+der Wiedervorlage; in den Grunddaten bleibt der ursprüngliche Verursacher sichtbar.
+Das Modal speichert unabhängig vom übrigen Formular und erhält dessen ungespeicherte
+Eingaben sowie Kommentarentwürfe. Die normalen Speicherbuttons ändern diese Zuordnung
+nicht. In der Liste führt das Speichern zu einem frischen Aufruf mit denselben Filtern
+und Fokus auf die Rechnung; entfällt sie durch die Filter, erscheint ein Hinweis.
+
+Bei abgelaufener Anmeldung wird nach dem Login die vollständige Liste beziehungsweise
+Detailseite geöffnet. Eine unterbrochene Zuordnungsänderung wird nicht automatisch
+wiederholt. Es sind keine neuen Datenbanktabellen oder Migrationen erforderlich.
+
+## Wiedervorlage in der Liste ändern
+
+Das Wiedervorlagedatum ist ein Button mit einem Datumsmodal. „Heute“ und „Heute + 7 Tage“
+setzen das Eingabefeld anhand des aktuellen Datums in Europe/Berlin; erst „Speichern“
+übernimmt die Änderung. Ein fehlendes Datum lässt sich über „Festlegen“ ergänzen.
+Die Änderung schreibt ausschließlich `Forderungen_Details.Wiedervorlage` und den Kommentar
+`WV auf dd.mm.yyyy angepasst` mit dem angemeldeten Benutzer und Berliner Zeitstempel.
+Datum und Kommentar werden gemeinsam in einer Transaktion gespeichert. Ein unverändertes
+Datum erzeugt keinen weiteren Kommentar. Danach wird die Liste mit den bestehenden Filtern
+frisch geladen und die Rechnung fokussiert; passt sie nicht mehr zum Filter, erscheint
+der entsprechende Hinweis. Nach einem Login wird ein unterbrochener Speichervorgang nicht
+automatisch wiederholt.
+
+## Dokumente im Kommentarbereich
+
+Über die Büroklammer oder durch Ablegen auf dem Kommentarfeld können mehrere Dateien
+beliebigen Typs ausgewählt werden. Die Auswahl mit Name, Größe und Entfernen-Schaltfläche
+bleibt bis „Abschicken“ ausschließlich im Browser. Kommentartext ist optional; reine
+Datei-Uploads erzeugen keinen Chat-Eintrag. Beim Verlassen oder Neuladen geht eine noch
+nicht abgeschickte Auswahl verloren.
+
+```dotenv
+LOCAL_STORAGE="C:\\Projekte\\Reisacher-Fileserver"
+UPLOAD_MAX_FILE_SIZE_MB=50
+```
+
+Die Größenbegrenzung gilt je Datei, einschließlich leerer Dateien: 50 MB entsprechen
+50 × 1024² = 52.428.800 Bytes. Auswahl und Server prüfen die Grenze. Neue Dateien liegen
+unter `LOCAL_STORAGE/{Client_DB}_{Beleg_Nr}/{Originalname}`. Altdateien unter
+`LOCAL_STORAGE/{Client_DB}/{Beleg_Nr}` bleiben sichtbar und herunterladbar; es gibt keine
+Migration. Unicode-Namen bleiben erhalten. Unter Windows unzulässige Dateinamen werden
+mit einer Fehlermeldung abgelehnt.
+
+Bei Namenskonflikten in beiden Belegordnern wird die ältere Datei in ihrem jeweiligen
+Ordner als `Name_YYYYMMDD_HHMMSS_ffffff.ext` archiviert (Europe/Berlin, bei Bedarf mit
+Zähler). Eine prozessübergreifende Belegsperre unter `.upload-locks` schützt die Ablage
+auch bei mehreren Workern. Dateien werden zuerst unter `.upload-staging` vollständig
+geschrieben und geprüft; danach erfolgt die Übernahme mit Rücknahme der Archivierung,
+wenn diese Datei nicht abgelegt werden kann. Diese internen Ordner sind über die
+Downloadroute nicht erreichbar. Der Ablagepfad darf nicht als öffentliches IIS-Verzeichnis
+oder als statischer Webpfad freigegeben werden.
+
+Das Anwendungskonto benötigt Lesen, Auflisten, Anlegen, Schreiben, Umbenennen und Löschen
+im Ablagestamm, beiden Belegstrukturen sowie den internen Arbeitsordnern. Für diese Ordner
+nur den erforderlichen Betriebskonten Zugriff geben. Alle Worker müssen denselben Stamm
+mit funktionierenden Dateisperren verwenden. Downloads prüfen weiterhin die Belegrechte.
+
+Erfolgreiche Dateien bleiben bei Teilerfolgen oder fehlgeschlagener Kommentarspeicherung
+bestehen. Nur fehlgeschlagene Dateien und nicht gespeicherter Text bleiben zur erneuten
+Übermittlung in der Auswahl. Nach einer erneuten Anmeldung werden Uploads nicht automatisch
+wiederholt. Kommentarhistorie und Dateiliste aktualisieren sich ohne Seitenneuladen.
+
+Bei IIS `system.webServer/security/requestFiltering/requestLimits/maxAllowedContentLength`
+(in Bytes) sowie gegebenenfalls vorgeschaltete Proxy- und Hosting-Limits auf die **gesamte**
+Multipart-Anfrage abstimmen: Anzahl gleichzeitig versandter Dateien × Dateilimit plus
+Kommentar und Multipart-Overhead. Das Dateilimit ist kein Gesamtlimit. Beispielsweise
+brauchen vier Dateien à 50 MB mehr als 209.715.200 Bytes; 220.200.960 Bytes (210 MiB)
+lassen hierfür zusätzlichen Overhead zu. Das übliche IIS-Standardlimit von 30.000.000 Bytes
+reicht bereits für eine 50-MB-Datei nicht aus. Eine serverseitig mit 413 abgewiesene Anfrage
+bleibt in der Auswahl; dann weniger Dateien gleichzeitig senden oder das Betriebslimit
+anpassen. Genügend temporären Speicher auch für den Multipart-Parser des Servers einplanen.
+
+Uploadtests verwenden ausschließlich temporäre Verzeichnisse:
+`python -m unittest discover -s tests -q`.
+
+## Zentrales Logging
+
+Webanwendung und Hilfsprogramme verwenden dieselbe idempotente Logging-Konfiguration.
+Entwicklung: `python server.py`; Dienstbetrieb: `python server.py --no-reload`.
+`webservice/webservice.bat` verwendet diesen Einstieg ohne zusätzliche Dateiumleitung.
+Nach Änderungen an Konfiguration oder Dienstskript den Dienst neu starten.
+
+```dotenv
+LOG_LEVEL=INFO
+LOG_DIR=logs
+LOG_TO_FILE=true
+LOG_TO_CONSOLE=true
+LOG_RETENTION_DAYS=30
+LOG_SQL_STATEMENT=true
+```
+
+Relative Logverzeichnisse beziehen sich auf den Projektstamm. `application.log` enthält
+je Ereignis eine JSON-Zeile; die Konsole zeigt dieselben Ereignisse lesbar an. `LOG_LEVEL`
+akzeptiert DEBUG, INFO, WARNING, ERROR und CRITICAL. Beide Ausgaben lassen sich unabhängig
+abschalten. Die Zeitstempel enthalten Millisekunden und den Europe/Berlin-Offset.
+Die tägliche Rotation erfolgt dagegen um Mitternacht UTC. Eigene Archive heißen
+`application.log.YYYY-MM-DD`; Archive älter als die konfigurierte Aufbewahrungsdauer
+werden beim Start und bei Rotation entfernt. Frühere Dienstlogs bleiben erhalten.
+
+Alle Prozesse müssen dasselbe Verzeichnis und dieselben Rotationseinstellungen verwenden.
+`concurrent-log-handler` koordiniert Schreiben und Rotation über Dateisperren, auch unter
+Windows. Das Dienstkonto benötigt Auflisten, Anlegen, Lesen, Schreiben, Umbenennen und
+Löschen für Logdateien, Archive und Sperrdateien im Logverzeichnis. Fehlende Schreibrechte,
+Rotations- oder Schreibfehler erzeugen eine datenarme Konsolenmeldung; bei Dateiausfall
+bleibt die Konsole als Fallback verfügbar. Deshalb auch die Dienstkonsole erfassbar halten.
+Logs nur den erforderlichen Betriebskonten zugänglich machen.
+
+HTTP-Abschlüsse enthalten `event=http_completed`, eine eigene `event_id`, `request_id`,
+Benutzerkennung (soweit angemeldet), Methode, Pfad, Status und Laufzeit in Millisekunden.
+Die Antwort liefert dieselbe Request-ID als `X-Request-ID`. Zur Fehlersuche beispielsweise:
+
+```powershell
+Select-String -LiteralPath .\logs\application.log -Pattern 'REQUEST-ID-AUS-DER-ANTWORT'
+```
+
+4xx werden als WARNING, 5xx als ERROR und andere Anfragen als INFO erfasst. Erfolgreiche
+Abrufe unter `/static/` und `/health` erscheinen nur mit DEBUG. Loginanforderungen haben
+zusätzlich `event=auth_login_required`, auch bei HTMX-Antworten mit HTTP 200. Uvicorns
+separates Zugriffslog ist abgeschaltet. Unerwartete Exceptions werden einmal technisch
+erfasst; der HTTP-Abschluss bleibt ein eigenes, über die Request-ID zugeordnetes Ereignis.
+Fehler nach Beginn einer Streamingantwort behalten den tatsächlich gesendeten Status.
+Fehler, die IIS oder ein vorgeschalteter Proxy vor Python erzeugt, stehen weiterhin in
+den jeweiligen Serverlogs.
+
+Datenbankfehler haben `event=database_error` mit Operation, Abfrageherkunft,
+`query_fingerprint`, Exceptiontyp, verfügbaren technischen Fehlercodes und Stackframes
+(Dateiname, Funktion, Zeile). Templateabfragen tragen ihren SQL-Dateinamen als Herkunft.
+Für SQL Server werden zusätzlich `db_code` (nativer Fehlercode, etwa 207), `sqlstate`
+und `db_message` (bereinigte Serverbeschreibung) ausgegeben. `db_diagnostics` enthält
+auch weitere ODBC-Meldungen desselben Fehlers mit jeweils Code, SQLSTATE und Beschreibung.
+Diese Angaben bleiben bei `LOG_SQL_STATEMENT=false` verfügbar. Zitierte Inhalte,
+zurückgemeldete Parameterwerte und Wertetupel werden in den Beschreibungen maskiert;
+es wird nicht die um SQL und Parameter ergänzte SQLAlchemy-Exception ausgegeben.
+Ausnahme: Bei SQL-Server-Fehler 207 („Ungültiger Spaltenname“ / „Invalid column name“)
+bleibt der Spaltenname in der Standardmeldung sichtbar, auch bei abgeschaltetem SQL-Text.
+SQL-Parameter, lokale Variablen und ungeprüfte Exceptiontexte werden nicht ausgegeben.
+SQL-Kommentare werden entfernt und Zeichenketten- sowie Zahlenliterale maskiert; der
+SQL-Text wird auf 8192 Zeichen begrenzt. Mit `LOG_SQL_STATEMENT=false` entfällt auch diese
+bereinigte Anweisung; Fingerabdruck und Herkunft bleiben erhalten. Abgefangene
+Datenbankfehler werden ebenfalls erfasst, weitere Logger erzeugen für dieselbe Exception
+keinen zweiten technischen Datensatz. Ein zusätzlicher Rollbackfehler bleibt sichtbar.
+Neue Logaufrufe dürfen keine Passwörter, Tokens, Header, Queryparameter, Formularinhalte,
+Mailbetreffzeilen oder Datei-/PDF-Inhalte enthalten. Binärdaten nur über ihre Größe erfassen.
+
+Hilfsskripte mit Paketimporten starten: `python -m app.imap`,
+`python -m app.cleanup_comments`, `python -m app.docuware_search` beziehungsweise
+`python filter_export.py`. Diese Programme behalten ihre fachlichen Aktionen bei;
+ein Import allein führt sie nicht aus. Nicht zu Logging-Testzwecken produktiv starten.
+Loggingtests nutzen ausschließlich temporäre Verzeichnisse und isolierte SQLite-Engines:
+`python -m unittest tests.test_logging -q`. Die vollständige Prüfung erfolgt mit
+`python -m unittest discover -s tests -q`.

+ 156 - 0
app/auth.py

@@ -0,0 +1,156 @@
+import logging
+import secrets
+from urllib.parse import parse_qs, quote
+
+from fastapi import HTTPException, Request, status
+from fastapi.responses import JSONResponse, RedirectResponse, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from .config import settings
+from .db import SessionLocal
+from .ldap import DirectoryUnavailable, lookup_directory_user
+from .oauth_token import (
+    InvalidSessionToken,
+    create_access_token,
+    decode_access_token,
+    renew_access_token,
+    token_needs_renewal,
+)
+from .navigation import normalize_page_url
+from .permissions import Principal, highest_role, load_entitlements
+
+logger = logging.getLogger(__name__)
+
+PUBLIC_PREFIXES = ("/static/",)
+PUBLIC_PATHS = {"/login", "/health"}
+UNSAFE_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+
+
+def set_session_cookie(response, token: str) -> None:
+    response.set_cookie(
+        settings.SESSION_COOKIE_NAME,
+        token,
+        secure=settings.COOKIE_SECURE,
+        httponly=True,
+        samesite="lax",
+        path="/",
+    )
+
+
+def clear_session_cookie(response) -> None:
+    response.delete_cookie(
+        settings.SESSION_COOKIE_NAME,
+        secure=settings.COOKIE_SECURE,
+        httponly=True,
+        samesite="lax",
+        path="/",
+    )
+
+
+def safe_next_url(value: str | None, default: str = "/select") -> str:
+    return normalize_page_url(value, default)
+
+
+def _principal(payload: dict, entitlements) -> Principal:
+    return Principal(
+        username=payload["sub"],
+        name=payload["name"],
+        email=payload["email"],
+        role=highest_role(entitlements),
+        auth_source=payload["auth_source"],
+        csrf=payload["csrf"],
+        entitlements=entitlements,
+    )
+
+
+async def _submitted_csrf(request: Request) -> str:
+    header = request.headers.get("X-CSRF-Token", "")
+    if header:
+        return header
+    content_type = request.headers.get("content-type", "")
+    if content_type.startswith("application/x-www-form-urlencoded"):
+        body = await request.body()
+        return parse_qs(body.decode("utf-8", errors="replace")).get("_csrf", [""])[0]
+    return ""
+
+
+class AuthenticationMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        is_public = request.url.path in PUBLIC_PATHS or request.url.path.startswith(PUBLIC_PREFIXES)
+        token = request.cookies.get(settings.SESSION_COOKIE_NAME)
+        payload = None
+        new_token = None
+
+        if token:
+            try:
+                payload = decode_access_token(token)
+            except InvalidSessionToken:
+                payload = None
+
+        proxy_user = request.headers.get(settings.AUTH_PROXY_HEADER)
+        proxy_host = request.client.host if request.client else None
+        trusted_proxy_identity = (
+            proxy_user if not settings.debug_auth_enabled and settings.is_trusted_proxy(proxy_host) else None
+        )
+        if proxy_user and not trusted_proxy_identity and not settings.debug_auth_enabled:
+            logger.warning("Nicht vertrauenswürdiger Proxy-Identitätsheader von %s ignoriert", proxy_host)
+
+        try:
+            with SessionLocal() as db:
+                if payload:
+                    entitlements = load_entitlements(db, payload["sub"])
+                    principal = _principal(payload, entitlements)
+                    request.state.principal = principal
+                    if token_needs_renewal(payload, principal.role):
+                        new_token = renew_access_token(payload, principal.role)
+                elif trusted_proxy_identity:
+                    directory_user = lookup_directory_user(trusted_proxy_identity)
+                    if not directory_user or directory_user.disabled:
+                        return JSONResponse({"detail": "Windows-Benutzer ist nicht gültig"}, status_code=401)
+                    entitlements = load_entitlements(db, directory_user.username)
+                    role = highest_role(entitlements)
+                    new_token = create_access_token(
+                        username=directory_user.username,
+                        name=directory_user.name,
+                        email=directory_user.email,
+                        role=role,
+                        auth_source="iis",
+                    )
+                    payload = decode_access_token(new_token)
+                    request.state.principal = _principal(payload, entitlements)
+        except HTTPException as exc:
+            return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)
+        except ValueError:
+            return JSONResponse({"detail": "Windows-Benutzer ist nicht gültig"}, status_code=401)
+        except DirectoryUnavailable:
+            logger.exception("IIS-Benutzer konnte nicht im AD aufgelöst werden")
+            return JSONResponse({"detail": "Anmeldedienst ist derzeit nicht verfügbar"}, status_code=503)
+        except Exception:
+            logger.exception("Berechtigungen konnten nicht geladen werden")
+            return JSONResponse({"detail": "Berechtigungssystem ist derzeit nicht verfügbar"}, status_code=503)
+
+        principal = getattr(request.state, "principal", None)
+        if not principal and not is_public:
+            logger.info('Anmeldung erforderlich', extra={'event': 'auth_login_required', 'reason': 'invalid_or_expired_session' if token else 'missing_session'})
+            next_url = request.url.path
+            if request.url.query:
+                next_url += "?" + request.url.query
+            next_url = normalize_page_url(next_url, current_url=request.headers.get("HX-Current-URL"))
+            login_url = f"/login?next={quote(next_url, safe='')}"
+            if request.headers.get("HX-Request", "").lower() == "true":
+                response = Response(status_code=200, headers={"HX-Redirect": login_url})
+            else:
+                response = RedirectResponse(login_url, status_code=303)
+            if token:
+                clear_session_cookie(response)
+            return response
+
+        if principal and request.method in UNSAFE_METHODS and request.url.path != "/login":
+            submitted = await _submitted_csrf(request)
+            if not submitted or not secrets.compare_digest(submitted, principal.csrf):
+                return JSONResponse({"detail": "Ungültiger CSRF-Token"}, status_code=status.HTTP_403_FORBIDDEN)
+
+        response = await call_next(request)
+        if new_token and not getattr(request.state, "suppress_session_refresh", False):
+            set_session_cookie(response, new_token)
+        return response

+ 0 - 17
app/auth2.py

@@ -1,17 +0,0 @@
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
-from .oauth_token import verify_token
-from .schemas import TokenData
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-
-def get_current_user(token: str = Depends(oauth2_scheme)):
-    payload = verify_token(token)
-    username: str = payload.get("sub")
-    if username is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid authentication credentials",
-        )
-    return TokenData(username=username)

+ 57 - 53
app/cleanup_comments.py

@@ -1,68 +1,71 @@
 import re
+import logging
 from datetime import date, timedelta
 
-from db import get_session
+from .db import SessionLocal
+from .logging_setup import run_cli
 from sqlalchemy import text
 
+logger = logging.getLogger(__name__)
+
 
 def main():
-    db = next(get_session())
-    q = db.execute(text("SELECT * FROM dbo.Forderungen_Kommentar_Rohdaten"))
-
-    for row in q.fetchall():
-        for i, r in enumerate(row.Kommentar.split("\n"), 1):
-            comment_date = row.Timestamp + timedelta(minutes=i)
-            comment_user = row.Benutzer_ID
-            r = r.replace("'", "")
-            d, u = get_date_and_user_from_comment(r)
-            db.execute(
-                text(
-                    "INSERT INTO dbo.Forderungen_Kommentar "
-                    f"VALUES ('{row.Client_DB}', '{row.Beleg_Nr}', '{comment_date}', '{comment_user}', '{r}')"
+    with SessionLocal() as db:
+        q = db.execute(text("SELECT * FROM dbo.Forderungen_Kommentar_Rohdaten"))
+
+        for row in q.fetchall():
+            for i, r in enumerate(row.Kommentar.split("\n"), 1):
+                comment_date = (row.Timestamp + timedelta(minutes=i)).strftime("%Y-%m-%dT%H:%M:%S")
+                comment_user = row.Benutzer_ID
+                r = r.replace("'", "").replace("?", "").replace(" :", "").replace("  ", " ").strip()
+                # d, u = get_date_and_user_from_comment(r)
+                db.execute(
+                    text("INSERT INTO dbo.Forderungen_Kommentar (Client_DB, Beleg_Nr, [Timestamp], Benutzer_ID, Kommentar) "
+                         "VALUES (:Client_DB, :Beleg_Nr, :Timestamp, :Benutzer_ID, :Kommentar)")
+                    .execution_options(query_name='cleanup_comments.import_comments'),
+                    dict(Client_DB=row.Client_DB, Beleg_Nr=row.Beleg_Nr, Timestamp=comment_date, Benutzer_ID=comment_user, Kommentar=r),
                 )
-            )
 
-    db.commit()
+        db.commit()
 
 
 def get_details_from_comments():
-    db = next(get_session())
-    q = db.execute(text("SELECT * FROM dbo.Forderungen_Kommentar_Rohdaten"))
-
-    for row in q.fetchall():
-        data = {}
-
-        az = re.search(r"^AZ\:?\s(\d+\/\d+)", row.Kommentar)
-        if az:
-            data["Rechtsanwalt_Aktenzeichen"] = az[1]
-
-        if "HP Schaden" in row.Kommentar:
-            data["Versicherung_Typ"] = "Haftpflicht"
-        if "Haftpflicht" in row.Kommentar:
-            data["Versicherung_Typ"] = "Haftpflicht"
-        if "VK Schaden" in row.Kommentar:
-            data["Versicherung_Typ"] = "Vollkasko"
-        if "VK-Schaden" in row.Kommentar:
-            data["Versicherung_Typ"] = "Vollkasko"
-        if "TK Schaden" in row.Kommentar:
-            data["Versicherung_Typ"] = "Teilkasko"
-        if "TK-Schaden" in row.Kommentar:
-            data["Versicherung_Typ"] = "Teilkasko"
-
-        s = re.search(r"Schaden (.*) bei (.*) eingereicht", row.Kommentar)
-        if s:
-            data["Schadennummer"] = s[1]
-            data["Vers_Adresse_ID"] = s[2].replace("'", "").lower()[:25]
-
-        if data:
-            db.execute(
-                text(
-                    "UPDATE dbo.Forderungen_Details SET "
-                    + ", ".join([f"{k} = '{v}'" for k, v in data.items()])
-                    + f" WHERE Client_DB = '{row.Client_DB}' AND Beleg_Nr = '{row.Beleg_Nr}'"
+    with SessionLocal() as db:
+        q = db.execute(text("SELECT * FROM dbo.Forderungen_Kommentar_Rohdaten"))
+
+        for row in q.fetchall():
+            data = {}
+
+            az = re.search(r"^AZ\:?\s(\d+\/\d+)", row.Kommentar)
+            if az:
+                data["Rechtsanwalt_Aktenzeichen"] = az[1]
+
+            if "HP Schaden" in row.Kommentar:
+                data["Versicherung_Typ"] = "Haftpflicht"
+            if "Haftpflicht" in row.Kommentar:
+                data["Versicherung_Typ"] = "Haftpflicht"
+            if "VK Schaden" in row.Kommentar:
+                data["Versicherung_Typ"] = "Vollkasko"
+            if "VK-Schaden" in row.Kommentar:
+                data["Versicherung_Typ"] = "Vollkasko"
+            if "TK Schaden" in row.Kommentar:
+                data["Versicherung_Typ"] = "Teilkasko"
+            if "TK-Schaden" in row.Kommentar:
+                data["Versicherung_Typ"] = "Teilkasko"
+
+            s = re.search(r"Schaden (.*) bei (.*) eingereicht", row.Kommentar)
+            if s:
+                data["Schadennummer"] = s[1][:25]
+                data["Vers_Adresse_ID"] = s[2].replace("'", "").lower()[:25]
+
+            if data:
+                db.execute(
+                    text("UPDATE dbo.Forderungen_Details SET " + ", ".join(f"{key} = :{key}" for key in data)
+                         + " WHERE Client_DB = :Client_DB AND Beleg_Nr = :Beleg_Nr")
+                    .execution_options(query_name='cleanup_comments.parse_details'),
+                    dict(data, Client_DB=row.Client_DB, Beleg_Nr=row.Beleg_Nr),
                 )
-            )
-    db.commit()
+        db.commit()
 
 
 def get_date_and_user_from_comment(r: str) -> tuple[date, str]:
@@ -81,4 +84,5 @@ def get_date_and_user_from_comment(r: str) -> tuple[date, str]:
 
 
 if __name__ == "__main__":
-    get_details_from_comments()
+    # main()
+    run_cli(get_details_from_comments)

+ 97 - 0
app/comment_submission.py

@@ -0,0 +1,97 @@
+"""Independent file and comment results for the existing comment POST."""
+from datetime import datetime
+import json
+import logging
+import re
+
+from fastapi import HTTPException
+from sqlalchemy import text
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import UploadFile
+
+from .config import settings
+from .file_storage import UploadError, get_files, save_upload
+from .forderung_history import history_context
+from .jinja_templates import templates
+from .permissions import current_principal
+
+logger = logging.getLogger(__name__)
+
+
+def _rollback(db):
+    try:
+        db.rollback()
+    except Exception:
+        logger.exception('Rollback nach fehlgeschlagenem Kommentar nicht möglich')
+
+
+async def submit_comment(request, pkey, db, scope):
+    results, messages = [], []
+    comment_saved = False
+    async with request.form() as form:
+        uploads = form.getlist('attachments')
+        comment = form.get('Kommentar', '')
+        try:
+            ids = json.loads(form.get('attachment_ids', '[]'))
+        except (ValueError, TypeError):
+            raise HTTPException(400, 'Die Dateiauswahl ist ungültig.')
+        if (not isinstance(comment, str) or not isinstance(ids, list) or len(ids) != len(uploads)
+                or any(not isinstance(item, UploadFile) for item in uploads)
+                or any(not isinstance(item, str) or not re.fullmatch(r'[A-Za-z0-9_-]{1,80}', item) for item in ids)
+                or len(set(ids)) != len(ids)):
+            raise HTTPException(400, 'Die Dateiauswahl ist ungültig.')
+
+        for identity, upload in zip(ids, uploads):
+            result = {'id': identity, 'name': upload.filename or '', 'success': False}
+            try:
+                await run_in_threadpool(save_upload, pkey, upload.filename or '', upload.file,
+                                        settings.UPLOAD_MAX_FILE_SIZE_MB * 1024 * 1024)
+                result['success'] = True
+            except UploadError as error:
+                result['error'] = str(error)
+            except OSError:
+                logger.exception('Datei konnte für %s nicht gespeichert werden', pkey)
+                result['error'] = 'Speichern fehlgeschlagen. Bitte Speicherplatz, Dateisperren und Zugriffsrechte prüfen.'
+            results.append(result)
+
+        if comment.strip():
+            data = dict(pkey, Benutzer_ID=current_principal(request).username,
+                        Timestamp=datetime.now().strftime('%Y-%m-%dT%H:%M:%S'), Kommentar=comment)
+            try:
+                query = templates.env.get_template('forderungen/details/queries/post/post_comments.sql').render(data=data)
+                for statement in query.split(';'):
+                    if statement.strip():
+                        db.execute(text(statement).execution_options(query_name='forderungen/details/queries/post/post_comments.sql'), data)
+                db.commit()
+                comment_saved = True
+            except Exception:
+                _rollback(db)
+                logger.exception('Kommentar konnte für %s nicht gespeichert werden', pkey)
+                messages.append('Der Kommentar konnte nicht gespeichert werden. Der Text bleibt im Eingabefeld.')
+        elif not uploads:
+            messages.append('Bitte einen Kommentar oder Dateien hinzufügen.')
+
+    context = {}
+    history_available = True
+    try:
+        context.update(history_context(db, pkey, 'kommentare', scope))
+    except Exception:
+        history_available = False
+        _rollback(db)
+        logger.exception('Kommentarhistorie konnte nicht aktualisiert werden')
+        messages.append('Die Kommentare konnten nicht aktualisiert werden. Bereits gespeicherte Ergebnisse bleiben erhalten.')
+    files_available = True
+    try:
+        context['files'] = get_files(pkey)
+    except OSError:
+        files_available = False
+        logger.exception('Dateiliste konnte nicht aktualisiert werden')
+        messages.append('Die Dateiliste konnte nicht aktualisiert werden. Bereits gespeicherte Dateien bleiben erhalten.')
+    context.update(
+        history_available=history_available, files_available=files_available, files_oob=True,
+        send_result={'files': results, 'comment_saved': comment_saved, 'messages': messages},
+    )
+    return templates.TemplateResponse(
+        request, 'forderungen/details/comment_submission.html', context,
+        headers={} if history_available else {'HX-Reswap': 'none'},
+    )

+ 88 - 13
app/config.py

@@ -1,20 +1,95 @@
-from pydantic_settings import BaseSettings
+from functools import lru_cache
+from ipaddress import ip_address, ip_network
+from typing import Annotated, Literal
+
+from pydantic import AliasChoices, BeforeValidator, Field, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+DEVELOPMENT_JWT_SECRET = "development-only-change-me-32-bytes"
+
+def _split_csv(value: object) -> list[str]:
+    if isinstance(value, str):
+        return [item.strip() for item in value.split(",") if item.strip()]
+    return list(value or [])
+
+
+CsvList = Annotated[list[str], BeforeValidator(_split_csv)]
 
 
 class Settings(BaseSettings):
-    # auth
-    SECRET_KEY: str = "my_secret_key"
-    ALGORITHM: str = "HS256"
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
-    # ldap
-    LDAP_URL: str
-    LDAP_USER_DN: str
-    LDAP_BASE_DN: str
-    # database
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore", case_sensitive=False)
+
+    ENVIRONMENT: str = "development"
+    DEBUG_AUTH: bool = False
     DATABASE_URL: str = "sqlite:///./dev.db"
 
-    class Config:
-        env_file = ".env"
+    AUTH_PROXY_HEADER: str = "X-Remote-User"
+    TRUSTED_PROXY_IPS: CsvList = Field(default_factory=lambda: ["127.0.0.1", "::1"])
+
+    JWT_SECRET: str = DEVELOPMENT_JWT_SECRET
+    JWT_ISSUER: str = "gcepic"
+    JWT_AUDIENCE: str = "gcepic-web"
+    JWT_IDLE_MINUTES: int = 30
+    JWT_ABSOLUTE_HOURS: int = 8
+    JWT_RENEW_BEFORE_MINUTES: int = 5
+    COOKIE_SECURE: bool = False
+    SESSION_COOKIE_NAME: str = "gcepic_session"
+    LOGIN_CSRF_COOKIE_NAME: str = "gcepic_login_csrf"
+
+    LDAP_URL: str | None = None
+    LDAP_BASE_DN: str | None = None
+    LDAP_BIND_DN: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("LDAP_BIND_DN", "LDAP_USER_DN"),
+    )
+    LDAP_BIND_PASSWORD: str | None = None
+    LDAP_UPN_SUFFIX: str | None = None
+    LDAP_START_TLS: bool = False
+    LOCAL_STORAGE: str | None = None
+    UPLOAD_MAX_FILE_SIZE_MB: int = Field(default=50, gt=0)
+    LOG_LEVEL: Annotated[Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], BeforeValidator(lambda value: str(value).upper())] = 'INFO'
+    LOG_DIR: str = 'logs'
+    LOG_TO_FILE: bool = True
+    LOG_TO_CONSOLE: bool = True
+    LOG_RETENTION_DAYS: int = Field(default=30, ge=1)
+    LOG_SQL_STATEMENT: bool = True
+
+    @model_validator(mode="after")
+    def validate_security_settings(self) -> "Settings":
+        if self.DEBUG_AUTH and self.ENVIRONMENT.lower() not in {"development", "debug", "test"}:
+            raise ValueError("DEBUG_AUTH is only allowed in development, debug or test")
+        if self.ENVIRONMENT.lower() == "production":
+            if len(self.JWT_SECRET.encode("utf-8")) < 32 or self.JWT_SECRET == DEVELOPMENT_JWT_SECRET:
+                raise ValueError("A unique JWT_SECRET with at least 32 bytes is required in production")
+            if not self.COOKIE_SECURE:
+                raise ValueError("COOKIE_SECURE must be enabled in production")
+        if self.JWT_IDLE_MINUTES <= 0 or self.JWT_ABSOLUTE_HOURS <= 0:
+            raise ValueError("JWT session lifetimes must be positive")
+        return self
+
+    @property
+    def debug_auth_enabled(self) -> bool:
+        return self.DEBUG_AUTH and self.ENVIRONMENT.lower() in {"development", "debug", "test"}
+
+    def is_trusted_proxy(self, host: str | None) -> bool:
+        if not host:
+            return False
+        try:
+            address = ip_address(host)
+        except ValueError:
+            return host in self.TRUSTED_PROXY_IPS and self.ENVIRONMENT.lower() != "production"
+        for entry in self.TRUSTED_PROXY_IPS:
+            try:
+                if address in ip_network(entry, strict=False):
+                    return True
+            except ValueError:
+                continue
+        return False
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
 
 
-settings = Settings()
+settings = get_settings()

+ 144 - 0
app/dashboard_segment.py

@@ -0,0 +1,144 @@
+"""Validated exact dashboard selections; independent of navigation and authentication."""
+from datetime import date, timedelta
+import json
+
+VIEWS = ('Altersstaffel', 'Standort', 'Verursacher', 'Wiedervorlage')
+DASHBOARD_VIEWS = VIEWS[:-1]  # Old Wiedervorlage list selections remain valid.
+
+
+def _date_key(key):
+    if key is None:
+        return
+    if not isinstance(key, dict) or set(key) != {'from', 'to'} or not any(key.values()):
+        raise ValueError('Ungültiger Datumsfilter')
+    for value in key.values():
+        if value is not None and (not isinstance(value, str) or date.fromisoformat(value).isoformat() != value):
+            raise ValueError('Ungültiges Datum')
+    if key['from'] and key['to'] and key['from'] > key['to']:
+        raise ValueError('Ungültiger Zeitraum')
+    if key['to'] == '9999-12-31':
+        raise ValueError('Zeitraum außerhalb des unterstützten Bereichs')
+
+
+def _value(value):
+    if value is not None and (not isinstance(value, str) or len(value) > 500
+                              or any(ord(char) < 32 or ord(char) == 127 or 0xd800 <= ord(char) <= 0xdfff for char in value)):
+        raise ValueError('Ungültiger Gruppenschlüssel')
+
+
+def parse_segment(raw):
+    if not raw:
+        return None
+    if not isinstance(raw, str) or len(raw) > 4096:
+        raise ValueError('Ungültiger Dashboardfilter')
+    try:
+        segment = json.loads(raw)
+    except (ValueError, TypeError, RecursionError) as error:
+        raise ValueError('Ungültiger Dashboardfilter') from error
+    if (not isinstance(segment, dict) or set(segment) - {'view', 'key', 'department', 'only_invoices', 'follow_up'}
+            or not {'view', 'key'} <= set(segment) or segment['view'] not in VIEWS):
+        raise ValueError('Ungültiger Dashboardfilter')
+    key, view = segment['key'], segment['view']
+    if 'only_invoices' in segment and type(segment['only_invoices']) is not bool:
+        raise ValueError('Ungültiger Rechnungsfilter')
+    if 'department' in segment:
+        _value(segment['department'])
+    if 'follow_up' in segment:
+        _date_key(segment['follow_up'])
+    if view == 'Altersstaffel':
+        _value(key)
+    elif view == 'Standort':
+        if not isinstance(key, dict) or set(key) != {'client', 'site'} or not key['client']:
+            raise ValueError('Ungültiger Standortfilter')
+        _value(key['client']); _value(key['site'])
+    elif view == 'Verursacher':
+        if not isinstance(key, dict) or set(key) not in ({'id'}, {'text'}):
+            raise ValueError('Ungültiger Verursacherfilter')
+        _value(next(iter(key.values())))
+        if 'id' in key and not key['id']:
+            raise ValueError('Benutzer-ID fehlt')
+    else:
+        _date_key(key)
+    return segment
+
+
+def pack_segment(segment):
+    return json.dumps(segment, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
+
+
+def segment_sql(segment):
+    clauses, values = [], {}
+    def dates(key, prefix):
+        if key is None:
+            clauses.append('F.[Wiedervorlage] IS NULL')
+            return
+        if key['from']:
+            clauses.append(f'F.[Wiedervorlage] >= :{prefix}_from')
+            values[prefix + '_from'] = key['from']
+        if key['to']:
+            clauses.append(f'F.[Wiedervorlage] < :{prefix}_until')
+            values[prefix + '_until'] = (date.fromisoformat(key['to']) + timedelta(days=1)).isoformat()
+    def exact(column, value, parameter):
+        if value is None or value == '':
+            clauses.append(f"NULLIF(F.[{column}], '') IS NULL")
+        else:
+            clauses.append(f'F.[{column}] = :{parameter}')
+            values[parameter] = value
+    key, view = segment['key'], segment['view']
+    if view == 'Altersstaffel':
+        exact('Staffel_Text', key, 'ds_age')
+    elif view == 'Standort':
+        exact('Client_DB', key['client'], 'ds_client')
+        exact('Standort_ID', key['site'], 'ds_site')
+    elif view == 'Verursacher':
+        if 'id' in key:
+            exact('Verursacher_Benutzer_ID', key['id'], 'ds_person')
+        else:
+            exact('Verursacher_Benutzer_ID', None, 'ds_person')
+            exact('Verursacher_Text', key['text'], 'ds_person_text')
+    else:
+        dates(key, 'ds')
+    if 'follow_up' in segment:
+        dates(segment['follow_up'], 'ds_follow')
+    if 'department' in segment:
+        exact('Abteilung', segment['department'], 'ds_department')
+    if segment.get('only_invoices'):
+        exact('Rechnung_Gutschrift', 'Rechnung', 'ds_invoice_type')
+    return clauses, values
+
+
+def segment_label(segment, rows=()):
+    key, view = segment['key'], segment['view']
+    sample = rows[0] if rows else {}
+    if view == 'Altersstaffel':
+        label = key or 'Ohne Altersstaffel'
+    elif view == 'Standort':
+        label = f"{sample.get('Standort_Name') or 'Standort'} · {key['site'] or 'ohne ID'} ({sample.get('Hauptbetrieb_Name') or 'Mandant ' + key['client']})"
+    elif view == 'Verursacher':
+        label = sample.get('Verursacher_Text') or key.get('id') or key.get('text') or 'Ohne Verursacher'
+        if key.get('id') and label != key['id']:
+            label += ' (' + key['id'] + ')'
+    elif key is None:
+        label = 'Ohne Datum'
+    else:
+        fmt = lambda value: date.fromisoformat(value).strftime('%d.%m.%Y')
+        if key['from'] == key['to']:
+            label = 'Am ' + fmt(key['from'])
+        else:
+            label = ' / '.join(filter(None, ['Ab ' + fmt(key['from']) if key['from'] else '',
+                                             'Bis ' + fmt(key['to']) if key['to'] else '']))
+    text = f'{view}: {label}'
+    if 'department' in segment:
+        text += ' · Abteilung: ' + (segment['department'] or 'Ohne Abteilung')
+    if segment.get('only_invoices'):
+        text += ' · Nur Rechnungen'
+    if 'follow_up' in segment:
+        period = segment['follow_up']
+        if period is None:
+            text += ' · Wiedervorlage: Ohne Datum'
+        else:
+            fmt = lambda value: date.fromisoformat(value).strftime('%d.%m.%Y')
+            text += ' · Wiedervorlage: ' + ' / '.join(filter(None, [
+                'Ab ' + fmt(period['from']) if period['from'] else '',
+                'Bis ' + fmt(period['to']) if period['to'] else '']))
+    return text

+ 70 - 8
app/db.py

@@ -1,17 +1,79 @@
-import os
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import Session, declarative_base, sessionmaker
 
-from dotenv import load_dotenv
-from sqlalchemy import create_engine
-from sqlalchemy.orm import declarative_base, sessionmaker
+from .config import settings
+from .logging_setup import db_operation, db_query, log_query_error, query_origin
 
-load_dotenv()
 
-DATABASE_URL = os.environ.get("DATABASE_URL") or "sqlite:///./dev.db"
+def install_engine_logging(engine):
+    if getattr(engine, '_gc_logging', False): return
+    engine._gc_logging = True
+
+    @event.listens_for(engine, 'before_cursor_execute')
+    def executing(conn, cursor, statement, parameters, context, executemany):
+        context._gc_operation = 'execute'
+
+    @event.listens_for(engine, 'after_cursor_execute')
+    def executed(conn, cursor, statement, parameters, context, executemany):
+        context._gc_operation = 'fetch'
+
+    @event.listens_for(engine, 'handle_error')
+    def query_failed(context):
+        # Observational only: never replace exceptions or affect connection invalidation.
+        error = context.sqlalchemy_exception or context.original_exception
+        options = getattr(context.execution_context, 'execution_options', {}) or {}
+        active = db_query.get() or {}
+        statement = context.statement if context.statement is not None else active.get('statement')
+        log_query_error(error, statement, options.get('query_name') or active.get('query_name'),
+                        db_operation.get() or getattr(context.execution_context, '_gc_operation', 'connect_or_transaction'),
+                        parameters=context.parameters)
+
+
+class LoggingSession(Session):
+    def execute(self, statement, params=None, *, execution_options=None, **kwargs):
+        options = dict(execution_options or {})
+        origin = options.setdefault('query_name', getattr(statement, '_execution_options', {}).get('query_name') or query_origin())
+        token = db_operation.set('execute')
+        query_token = db_query.set({'statement': statement, 'query_name': origin})
+        try:
+            return super().execute(statement, params, execution_options=options, **kwargs)
+        except Exception as error:
+            log_query_error(error, statement, origin, 'execute', parameters=params)
+            raise
+        finally:
+            db_query.reset(query_token)
+            db_operation.reset(token)
+
+    def _transaction_operation(self, operation):
+        token = db_operation.set(operation)
+        try:
+            return getattr(super(), operation)()
+        except Exception as error:
+            log_query_error(error, operation=operation)
+            raise
+        finally:
+            db_operation.reset(token)
+
+    def commit(self): return self._transaction_operation('commit')
+    def rollback(self): return self._transaction_operation('rollback')
+
+    def flush(self, objects=None):
+        token = db_operation.set('flush')
+        try:
+            return super().flush(objects)
+        except Exception as error:
+            log_query_error(error, operation='flush')
+            raise
+        finally:
+            db_operation.reset(token)
 
 engine = create_engine(
-    DATABASE_URL, connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False} if settings.DATABASE_URL.startswith("sqlite") else {},
+    hide_parameters=True,
 )
-SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
+install_engine_logging(engine)
+SessionLocal = sessionmaker(bind=engine, class_=LoggingSession, autoflush=False, autocommit=False)
 Base = declarative_base()
 
 

+ 12 - 12
app/docuware_search.py

@@ -1,8 +1,12 @@
 import json
 import os
+import logging
 
 import docuware
 from dotenv import load_dotenv
+from .logging_setup import run_cli
+
+logger = logging.getLogger(__name__)
 
 load_dotenv()
 
@@ -19,18 +23,11 @@ def main():
     dw = docuware.connect()
 
     for org in dw.organizations:
-        print(org)
+        logger.debug('DocuWare-Organisation verfügbar')
         for fc in org.file_cabinets:
-            print("   ", fc)
+            logger.debug('DocuWare-Ablage verfügbar')
         for b in org.baskets:
-            print("   ", b)
-        # dlg = fc.search_dialog()
-        # for field in dlg.fields.values():
-        #     print("Id    =", field.id)
-        #     print("Length=", field.length)
-        #     print("Name  =", field.name)
-        #     print("Type  =", field.type)
-        #     print("-------")
+            logger.debug('DocuWare-Briefkorb verfügbar')
 
 
 def get_file_cabinet(client_db: str) -> docuware.FileCabinet:
@@ -104,7 +101,7 @@ def get_invoice_pdf_by_document_no(client_db: str, document_no: str) -> bytes:
 
     for doc in dlg.search(search_condition):
         # return os.getenv("DW_URL").strip("/") + doc.document.endpoints["content"]
-        data, content_type, filename = doc.download(keep_annotations=True)
+        data, content_type, filename = doc.document.download(keep_annotations=True)
         return data
     raise ValueError(f"Document with document_no {document_no} not found in client_db {client_db}")
 
@@ -112,4 +109,7 @@ def get_invoice_pdf_by_document_no(client_db: str, document_no: str) -> bytes:
 if __name__ == "__main__":
     # main()
     # search_files(client_db="1", vehicle_no="WBA21FZ070FT19353")
-    print(get_invoice_pdf_by_document_no("1", "WRG25117581"))
+    def download_sample():
+        data = get_invoice_pdf_by_document_no('1', 'WRG25117581')
+        logger.info('PDF abgerufen', extra={'event': 'docuware_pdf_downloaded', 'size_bytes': len(data)})
+    run_cli(download_sample)

+ 220 - 14
app/file_storage.py

@@ -1,22 +1,228 @@
+"""Document storage, including legacy folders and collision-safe uploads."""
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime
+import hashlib
+import logging
 import os
 from pathlib import Path
-from urllib.parse import unquote
+import re
+import tempfile
+import threading
+import time
+from weakref import WeakValueDictionary
+from zoneinfo import ZoneInfo
 
-from dotenv import load_dotenv
+from .config import settings
 
-load_dotenv()
+logger = logging.getLogger(__name__)
+BERLIN = ZoneInfo('Europe/Berlin')
+_THREAD_LOCKS = WeakValueDictionary()
+_LOCK_GUARD = threading.Lock()
+_RESERVED = {'CON', 'PRN', 'AUX', 'NUL', 'CONIN$', 'CONOUT$'} | {
+    f'{prefix}{digit}' for prefix in ('COM', 'LPT') for digit in '123456789¹²³'
+}
 
 
-def get_files(primary_key: dict[str, str]):
-    fileserver = os.environ.get("LOCAL_STORAGE")
-    files = [
-        f.relative_to(fileserver)
-        for f in Path(f"{fileserver}\\{primary_key['Client_DB']}\\{primary_key['Beleg_Nr']}").glob("*")
-    ]
-    return files
+class UploadError(ValueError):
+    """An actionable error which can be displayed next to an individual file."""
 
 
-def get_file(name: str):
-    fileserver = os.environ.get("LOCAL_STORAGE")
-    filename = Path(f"{fileserver}\\{unquote(name)}")
-    return filename
+@dataclass(frozen=True)
+class StoredFile:
+    name: str
+    relative_path: str
+    modified_at: datetime
+    size: int
+
+
+def validate_filename(name: str) -> str:
+    if (not name or name in {'.', '..'} or name.endswith(('.', ' '))
+            or re.search(r'[<>:"/\\|?*\x00-\x1f\x7f]', name)
+            or name.split('.')[0].rstrip(' ').upper() in _RESERVED
+            or len(name.encode('utf-16-le', errors='surrogatepass')) // 2 > 255):
+        raise UploadError('Dieser Dateiname kann unter Windows nicht gespeichert werden.')
+    return name
+
+
+def _root() -> Path:
+    if not settings.LOCAL_STORAGE:
+        raise UploadError('Die Dateiablage ist nicht konfiguriert.')
+    return Path(settings.LOCAL_STORAGE).resolve()
+
+
+def _checked(root: Path, *parts: str) -> Path:
+    for part in parts:
+        validate_filename(part)
+    candidate = root.joinpath(*parts)
+    resolved = candidate.resolve()
+    if root not in resolved.parents or resolved != candidate:
+        raise UploadError('Der Ablagepfad ist nicht zulässig.')
+    return candidate
+
+
+def _folders(root: Path, key: dict[str, str]) -> tuple[Path, Path]:
+    tenant, number = str(key['Client_DB']), str(key['Beleg_Nr'])
+    validate_filename(tenant)
+    validate_filename(number)
+    return _checked(root, f'{tenant}_{number}'), _checked(root, tenant, number)
+
+
+def file_primary_key(name: str) -> dict[str, str]:
+    # Query parameters are already URL-decoded by the framework. Do not decode twice.
+    parts = name.replace('\\', '/').split('/')
+    if len(parts) not in (2, 3):
+        raise FileNotFoundError(name)
+    try:
+        for part in parts:
+            validate_filename(part)
+        if len(parts) == 2:
+            tenant, separator, number = parts[0].partition('_')
+            if not separator or not tenant or not number:
+                raise FileNotFoundError(name)
+        else:
+            tenant, number = parts[:2]
+    except UploadError as error:
+        raise FileNotFoundError(name) from error
+    return {'Client_DB': tenant, 'Beleg_Nr': number}
+
+
+def get_files(primary_key: dict[str, str]) -> list[StoredFile]:
+    if not settings.LOCAL_STORAGE:
+        return []
+    root = _root()
+    try:
+        folders = _folders(root, primary_key)
+    except UploadError:
+        return []
+    files = []
+    for folder in folders:
+        for entry in folder.glob('*'):
+            try:
+                filename = _checked(root, *entry.relative_to(root).parts)
+                if not filename.is_file():
+                    continue
+                stat = filename.stat()
+                files.append(StoredFile(filename.name, filename.relative_to(root).as_posix(),
+                                        datetime.fromtimestamp(stat.st_mtime, BERLIN), stat.st_size))
+            except (FileNotFoundError, UploadError):
+                continue
+    return sorted(files, key=lambda item: (-item.modified_at.timestamp(), item.name.casefold(), item.relative_path))
+
+
+def get_file(name: str) -> Path:
+    if not settings.LOCAL_STORAGE:
+        raise FileNotFoundError(name)
+    file_primary_key(name)
+    try:
+        filename = _checked(_root(), *name.replace('\\', '/').split('/'))
+        if not filename.is_file():
+            raise FileNotFoundError(name)
+        return filename
+    except UploadError as error:
+        raise FileNotFoundError(name) from error
+
+
+@contextmanager
+def _beleg_lock(root: Path, folder: Path):
+    lock_dir = _checked(root, '.upload-locks')
+    lock_dir.mkdir(parents=True, exist_ok=True)
+    digest = hashlib.sha256(str(folder).casefold().encode('utf-8')).hexdigest()
+    lock_path = _checked(root, '.upload-locks', digest + '.lock')
+    with _LOCK_GUARD:
+        lock = _THREAD_LOCKS.setdefault(str(lock_path), threading.Lock())
+    deadline = time.monotonic() + 30
+    if not lock.acquire(timeout=30):
+        raise UploadError('Die Dateiablage ist gerade belegt. Bitte erneut abschicken.')
+    try:
+        with lock_path.open('a+b') as handle:
+            if handle.tell() == 0:
+                handle.write(b'0')
+                handle.flush()
+            locked = False
+            try:
+                while not locked:
+                    try:
+                        handle.seek(0)
+                        if os.name == 'nt':
+                            import msvcrt
+                            msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+                        else:
+                            import fcntl
+                            fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                        locked = True
+                    except OSError:
+                        if time.monotonic() >= deadline:
+                            raise UploadError('Die Dateiablage ist gerade belegt. Bitte erneut abschicken.')
+                        time.sleep(.05)
+                yield
+            finally:
+                if locked:
+                    handle.seek(0)
+                    if os.name == 'nt':
+                        import msvcrt
+                        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+                    else:
+                        import fcntl
+                        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+    finally:
+        lock.release()
+
+
+def _archive_name(root: Path, original: Path) -> Path:
+    stamp = datetime.now(BERLIN).strftime('%Y%m%d_%H%M%S_%f')
+    counter = 0
+    while True:
+        suffix = f'_{counter}' if counter else ''
+        name = f'{original.stem}_{stamp}{suffix}{original.suffix}'
+        archive = _checked(root, *original.parent.relative_to(root).parts, name)
+        if not archive.exists():
+            return archive
+        counter += 1
+
+
+def save_upload(primary_key: dict[str, str], name: str, stream, max_bytes: int) -> str:
+    """Stage and finalize one file; keep earlier successful files independent."""
+    validate_filename(name)
+    root = _root()
+    destination, legacy = _folders(root, primary_key)
+    staging = _checked(root, '.upload-staging')
+    staging.mkdir(parents=True, exist_ok=True)
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(dir=staging, suffix='.tmp', delete=False) as output:
+            temporary = Path(output.name)
+            stream.seek(0)
+            size = 0
+            while chunk := stream.read(1024 * 1024):
+                size += len(chunk)
+                if size > max_bytes:
+                    raise UploadError(f'Die Datei überschreitet die erlaubten {settings.UPLOAD_MAX_FILE_SIZE_MB} MB.')
+                output.write(chunk)
+            output.flush()
+            os.fsync(output.fileno())
+        with _beleg_lock(root, destination):
+            destination.mkdir(parents=True, exist_ok=True)
+            target = _checked(root, *destination.relative_to(root).parts, name)
+            previous = []
+            try:
+                for folder in (destination, legacy):
+                    existing = _checked(root, *folder.relative_to(root).parts, name)
+                    if existing.exists():
+                        if not existing.is_file():
+                            raise UploadError('Unter diesem Dateinamen besteht bereits ein Ordner.')
+                        archive = _archive_name(root, existing)
+                        existing.rename(archive)
+                        previous.append((existing, archive))
+                os.replace(temporary, target)
+            except Exception:
+                for existing, archive in reversed(previous):
+                    try:
+                        archive.rename(existing)
+                    except OSError:
+                        logger.exception('Archivierte Datei konnte nicht zurückbenannt werden', extra={'event': 'file_archive_rollback_failed'})
+                raise
+        return target.relative_to(root).as_posix()
+    finally:
+        if temporary and temporary.exists():
+            temporary.unlink()

+ 196 - 0
app/forderung_dashboard.py

@@ -0,0 +1,196 @@
+"""Aggregate authorized invoices by rubric and selectable stack dimension."""
+
+import hashlib
+from collections import Counter
+from datetime import date, datetime, timedelta
+from decimal import Decimal
+from urllib.parse import urlencode
+from zoneinfo import ZoneInfo
+
+from .dashboard_segment import DASHBOARD_VIEWS, pack_segment
+from .forderung_data import read_invoices
+from .jinja_templates import number_format
+
+BERLIN = ZoneInfo("Europe/Berlin")
+STACKS = ("abteilung", "wiedervorlage")
+
+
+def _key(value):
+    return None if value is None or str(value) == "" else str(value)
+
+
+def _date(value):
+    return (
+        value.date()
+        if isinstance(value, datetime)
+        else value if isinstance(value, date) else date.fromisoformat(str(value)[:10]) if value else None
+    )
+
+
+def color(department):
+    hue = int.from_bytes(hashlib.sha256((department or "").encode()).digest()[:2], "big") % 360
+    return f"hsl({hue}, 23%, 70%)"
+
+
+def follow_up_bands(today):
+    return [
+        dict(
+            id="overdue",
+            label="Überfällig",
+            color="#d4aaaa",
+            key={"from": None, "to": (today - timedelta(days=1)).isoformat()},
+        ),
+        dict(
+            id="soon",
+            label="In 3 Tagen fällig",
+            color="#e0cd9c",
+            key={"from": today.isoformat(), "to": (today + timedelta(days=3)).isoformat()},
+        ),
+        dict(
+            id="not_due",
+            label="Noch nicht fällig",
+            color="#b4c5b5",
+            key={"from": (today + timedelta(days=4)).isoformat(), "to": (today + timedelta(days=14)).isoformat()},
+        ),
+        dict(
+            id="deferred",
+            label="zurückgestellt",
+            color="#b2bccd",
+            key={"from": (today + timedelta(days=15)).isoformat(), "to": None},
+        ),
+        dict(id="undated", label="Ohne Datum", color="#c5c5c5", key=None),
+    ]
+
+
+def _url(view, key, segment=..., only_invoices=False, stack="abteilung"):
+    selection = {"view": view, "key": key}
+    if segment is not ...:
+        selection["department" if stack == "abteilung" else "follow_up"] = segment
+    if only_invoices:
+        selection["only_invoices"] = True
+    return "/app/forderungen/liste?" + urlencode({"dashboard_segment": pack_segment(selection)})
+
+
+def build_dashboard(db, username, now=None, only_invoices=False, stack="abteilung"):
+    if stack not in STACKS:
+        raise ValueError("Ungültige Stapelung")
+    now = now or datetime.now(BERLIN)
+    today = now.astimezone(BERLIN).date()
+    if only_invoices:
+        columns, source = read_invoices(
+            db, username, ["F.[Rechnung_Gutschrift] = :dashboard_invoice_type"], {"dashboard_invoice_type": "Rechnung"}
+        )
+    else:
+        columns, source = read_invoices(db, username)
+    groups = {view: {} for view in DASHBOARD_VIEWS}
+    total, departments, observed = Decimal(0), set(), set()
+    bands = follow_up_bands(today)
+    for values in source:
+        row = dict(zip(columns, values))
+        department = _key(row.get("Abteilung"))
+        departments.add(department)
+        if stack == "abteilung":
+            segment_id = department
+        else:
+            when = _date(row.get("Wiedervorlage") or row.get("Beleg_Faellig_Datum"))
+            bucket = (
+                4
+                if when is None
+                else (
+                    0
+                    if when < today
+                    else 1 if when <= today + timedelta(days=3) else 2 if when <= today + timedelta(days=14) else 3
+                )
+            )
+            segment_id = bands[bucket]["id"]
+        observed.add(segment_id)
+        amount = Decimal(str(row["Beleg_Offen"] or 0))
+        total += amount
+        age = _key(row.get("Staffel_Text"))
+        site = {"client": str(row["Client_DB"]), "site": _key(row.get("Standort_ID"))}
+        person_id = _key(row.get("Verursacher_Benutzer_ID"))
+        person = {"id": person_id} if person_id else {"text": _key(row.get("Verursacher_Text"))}
+        definitions = [
+            (
+                "Altersstaffel",
+                age,
+                age or "Ohne Altersstaffel",
+                int(row["Beleg_Tage_offen"]) if age and row.get("Beleg_Tage_offen") is not None else 10**12,
+            ),
+            (
+                "Standort",
+                site,
+                f"{row.get('Standort_Name') or site['site'] or 'Ohne Standort'} ({row.get('Hauptbetrieb_Name') or 'Mandant ' + site['client']})",
+                0,
+            ),
+            ("Verursacher", person, row.get("Verursacher_Text") or person_id or "Ohne Verursacher", 0),
+        ]
+        for view, key, label, order in definitions:
+            identity = pack_segment(key)
+            group = groups[view].setdefault(
+                identity, dict(key=key, label=label, order=order, count=0, amount=Decimal(0), segments={})
+            )
+            group["order"] = min(group["order"], order)
+            group["count"] += 1
+            group["amount"] += amount
+            segment = group["segments"].setdefault(segment_id, dict(count=0, amount=Decimal(0)))
+            segment["count"] += 1
+            segment["amount"] += amount
+    items = (
+        [
+            dict(id=dep, label=dep or "Ohne Abteilung", color=color(dep), key=dep)
+            for dep in sorted(departments, key=lambda value: (value is None, value or ""))
+        ]
+        if stack == "abteilung"
+        else [band for band in bands if band["id"] != "undated" or "undated" in observed]
+    )
+
+    def serialized(amount):
+        return str(amount.quantize(Decimal("0.01")))
+
+    output = {}
+    for view, mapping in groups.items():
+        result = []
+        labels = Counter(group["label"].casefold() for group in mapping.values())
+        for group in mapping.values():
+            label = group["label"]
+            if labels[label.casefold()] > 1:
+                if view == "Verursacher":
+                    label += " (" + (group["key"].get("id") or "ohne Benutzer-ID") + ")"
+                elif view == "Standort":
+                    label += " · Standort-ID " + (group["key"]["site"] or "ohne ID")
+            segments = [
+                dict(
+                    id=item["id"],
+                    department=item["id"] if stack == "abteilung" else None,
+                    label=item["label"],
+                    count=group["segments"][item["id"]]["count"],
+                    amount=serialized(group["segments"][item["id"]]["amount"]),
+                    color=item["color"],
+                    url=_url(view, group["key"], item["key"], only_invoices, stack),
+                )
+                for item in items
+                if item["id"] in group["segments"]
+            ]
+            result.append(
+                dict(
+                    label=label,
+                    order=group["order"],
+                    count=group["count"],
+                    amount=serialized(group["amount"]),
+                    segments=segments,
+                    url=_url(view, group["key"], only_invoices=only_invoices),
+                )
+            )
+        output[view] = result
+    return dict(
+        count=len(source),
+        amount=serialized(total),
+        amount_display=number_format(total),
+        views=output,
+        only_invoices=only_invoices,
+        stack=stack,
+        stack_label="Abteilung" if stack == "abteilung" else "Wiedervorlage",
+        stack_items=[{name: value for name, value in item.items() if name != "key"} for item in items],
+        generated=now.astimezone(BERLIN).strftime("%d.%m.%Y %H:%M"),
+    )

+ 19 - 0
app/forderung_data.py

@@ -0,0 +1,19 @@
+"""One authorized projection for list results and dashboard aggregates."""
+from sqlalchemy import text
+from .jinja_templates import templates
+
+
+def read_invoices(db, username, clauses=(), values=None):
+    query = templates.env.get_template('forderungen/liste/queries/forderungen_liste.sql').render()
+    if clauses:
+        query = query.replace('AND 1 = 1', 'AND 1 = 1 AND ' + ' AND '.join(clauses))
+    result = db.execute(text(query).execution_options(query_name='forderungen/liste/queries/forderungen_liste.sql'), dict(values or {}, auth_username=username))
+    columns = list(result.keys())
+    tenant, number = columns.index('Client_DB'), columns.index('Beleg_Nr')
+    seen, rows = set(), []
+    for row in result.fetchall():
+        identity = (str(row[tenant]), str(row[number]))
+        if identity not in seen:
+            rows.append(row)
+            seen.add(identity)
+    return columns, rows

+ 39 - 0
app/forderung_history.py

@@ -0,0 +1,39 @@
+from typing import Literal
+from urllib.parse import quote
+
+from fastapi import HTTPException
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from .jinja_templates import templates
+
+HistoryScope = Literal["invoice", "open", "vehicle", "debtor"]
+
+
+def history_context(db: Session, pkey: dict[str, str], section: str, scope: HistoryScope = "invoice") -> dict:
+    values = {"client_db": pkey["Client_DB"], "beleg_nr": pkey["Beleg_Nr"], "scope": scope}
+    invoice = db.execute(
+        text("SELECT TOP 1 * FROM dbo.Forderungen_Kopf WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr"),
+        values,
+    ).mappings().first()
+    if invoice is None:
+        raise HTTPException(status_code=404, detail="Forderung nicht gefunden")
+    return section_context(db, pkey, invoice, section, scope)
+
+
+def section_context(db: Session, pkey: dict[str, str], invoice, section: str, scope: HistoryScope = "invoice") -> dict:
+    # Neither the customer nor the vehicle can be supplied by the browser.
+    invoice = getattr(invoice, "_mapping", invoice)
+    vehicle_missing = not str(invoice["Fahrzeug_Nr"] or "").strip()
+    values = {"client_db": pkey["Client_DB"], "beleg_nr": pkey["Beleg_Nr"], "scope": scope}
+    rows = []
+    if scope != "vehicle" or not vehicle_missing:
+        query = templates.env.get_template(f"forderungen/details/queries/forderungen_{section}.sql").render(scope=scope)
+        rows = db.execute(text(query).execution_options(query_name=f'forderungen/details/queries/forderungen_{section}.sql'), values).fetchall()
+    return {
+        "forderungen_details": [invoice],
+        f"forderungen_{section}": rows,
+        f"{section}_scope": scope,
+        "vehicle_missing": vehicle_missing,
+        "detail_url": "/app/forderungen/details/" + quote(f"{pkey['Client_DB']}_{pkey['Beleg_Nr']}", safe=""),
+    }

+ 27 - 0
app/forderung_summary.py

@@ -0,0 +1,27 @@
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+CURRENT_SUMMARY_SQL = text("""
+    SELECT TOP 1 Beleg_Nr, Beleg_Datum, Kunde_Text, Beleg_Betrag, Beleg_Offen
+    FROM dbo.Forderungen_Kopf
+    WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+    """)
+
+HISTORY_SUMMARY_SQL = text("""
+    SELECT TOP 1 Beleg_Nr, Beleg_Datum, Auszifferung_Datum
+    FROM dbo.Forderungen_Historie
+    WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+    ORDER BY Auszifferung_Datum DESC, Beleg_Datum DESC
+    """)
+
+
+def get_forderung_summary(db: Session, client_db: str, beleg_nr: str) -> dict:
+    """Explicitly permitted minimal information, independent of the detail scope."""
+    params = {"client_db": client_db, "beleg_nr": beleg_nr}
+    current = db.execute(CURRENT_SUMMARY_SQL, params).mappings().first()
+    if current is not None:
+        return {"kind": "open", "forderung": dict(current)}
+    historical = db.execute(HISTORY_SUMMARY_SQL, params).mappings().first()
+    if historical is not None:
+        return {"kind": "settled", "forderung": dict(historical)}
+    return {"kind": "missing", "forderung": None}

+ 70 - 0
app/http_logging.py

@@ -0,0 +1,70 @@
+"""ASGI response logging outside authentication, without consuming request bodies."""
+import logging
+import time
+from uuid import uuid4
+
+from starlette.responses import PlainTextResponse
+
+from .logging_setup import request_context
+
+logger = logging.getLogger(__name__)
+
+
+class RequestLoggingMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope['type'] != 'http':
+            return await self.app(scope, receive, send)
+        request_id = uuid4().hex
+        scope.setdefault('state', {})['request_id'] = request_id
+        token = request_context.set({'request_id': request_id, 'scope': scope})
+        started = time.perf_counter()
+        status, completed, failed = None, False, False
+
+        def finish(outcome, level=None):
+            nonlocal completed
+            if completed: return
+            completed = True
+            level = level or (logging.ERROR if status and status >= 500 else logging.WARNING if status and status >= 400 else
+                              logging.DEBUG if scope['path'] == '/health' or scope['path'].startswith('/static/') else logging.INFO)
+            logger.log(level, 'HTTP-Anfrage abgeschlossen', extra={
+                'event': 'http_completed', 'status': status,
+                'duration_ms': round((time.perf_counter()-started)*1000, 2), 'outcome': outcome,
+            })
+
+        async def logged_send(message):
+            nonlocal status
+            if message['type'] == 'http.response.start':
+                message = dict(message, headers=[(key, value) for key, value in message.get('headers', [])
+                                                if key.lower() != b'x-request-id'] + [(b'x-request-id', request_id.encode('ascii'))])
+            await send(message)
+            if message['type'] == 'http.response.start': status = message['status']
+            if message['type'] == 'http.response.body' and not message.get('more_body', False):
+                finish('completed')
+
+        try:
+            await self.app(scope, receive, logged_send)
+        except Exception:
+            failed = True
+            streaming = status is not None
+            logger.exception('HTTP-Verarbeitung fehlgeschlagen', extra={'event': 'response_stream_error' if streaming else 'unhandled_exception'})
+            if status is None: status = 500
+            if not completed:
+                finish('stream_failed' if streaming else 'failed', logging.ERROR)
+            raise
+        finally:
+            if not completed and not failed: finish('aborted', logging.WARNING)
+            request_context.reset(token)
+
+
+async def unhandled_error_response(request, exc):
+    request_id = getattr(request.state, 'request_id', None)
+    return PlainTextResponse('Internal Server Error', status_code=500,
+                             headers={'X-Request-ID': request_id} if request_id else {})
+
+
+def install_request_logging(app):
+    app.add_middleware(RequestLoggingMiddleware)
+    app.add_exception_handler(Exception, unhandled_error_response)

+ 15 - 14
app/imap.py

@@ -1,14 +1,17 @@
 import os
 import re
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 
-from db import get_session
+from .db import SessionLocal
+from .logging_setup import run_cli
 from dotenv import load_dotenv
 from imap_tools import MailBox
 from sqlalchemy import text
 
 load_dotenv()
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -18,15 +21,13 @@ class ImapCredentials:
     password: str
 
 
-creds = ImapCredentials(
-    server=os.getenv("IMAP_SERVER"), username=os.getenv("IMAP_USERNAME"), password=os.getenv("IMAP_PASSWORD")
-)
-fileserver = Path(os.environ.get("LOCAL_STORAGE"))
-
-
 def main():
-    db = next(get_session())
-    q = db.execute(text("SELECT [Client_DB], [Beleg_Nr] FROM [dbo].[Forderungen_Kopf]")).fetchall()
+    creds = ImapCredentials(
+        server=os.getenv("IMAP_SERVER"), username=os.getenv("IMAP_USERNAME"), password=os.getenv("IMAP_PASSWORD")
+    )
+    fileserver = Path(os.environ.get("LOCAL_STORAGE"))
+    with SessionLocal() as db:
+        q = db.execute(text("SELECT [Client_DB], [Beleg_Nr] FROM [dbo].[Forderungen_Kopf]")).fetchall()
     lookup = {row[1]: row[0] for row in q}
 
     with MailBox(creds.server).login(creds.username, creds.password) as mb:
@@ -41,21 +42,21 @@ def main():
         for msg in messages:
             match = re.findall(r"([WV]\w+\d+)", msg.subject)
             if not match:
-                print(msg.subject)
+                logger.debug('E-Mail ohne Belegzuordnung übersprungen')
                 continue
-            print(match)
+            logger.debug('Belegkennung in E-Mail erkannt')
             invoice_no = match[0]
             if invoice_no not in lookup:
                 continue
             client_db = lookup[invoice_no]
-            print(invoice_no, client_db)
+            logger.debug('E-Mail einem Beleg zugeordnet')
             attachments = {att.filename: att.payload for att in msg.attachments if att.size > 0}
             for file, content in attachments.items():
                 filename: Path = fileserver / client_db / invoice_no / file
                 filename.parent.mkdir(exist_ok=True, parents=True)
                 filename.write_bytes(content)
-                print(filename)
+                logger.info('Mailanhang abgelegt', extra={'event': 'mail_attachment_saved', 'size_bytes': len(content)})
 
 
 if __name__ == "__main__":
-    main()
+    run_cli(main)

+ 4 - 1
app/jinja_templates.py

@@ -1,11 +1,14 @@
 from datetime import datetime
+from decimal import Decimal
 
 from fastapi.templating import Jinja2Templates
 
 templates = Jinja2Templates(directory="templates")
 
 
-def number_format(input: float) -> str:
+def number_format(input: float | Decimal | None) -> str:
+    if input is None:
+        return "—"
     return format(input, "0,.2f").replace(".", ":").replace(",", ".").replace(":", ",")
 
 

+ 106 - 19
app/ldap.py

@@ -1,26 +1,113 @@
-import os
-from typing import Optional
+import logging
+import re
+import ssl
+from dataclasses import dataclass
+from urllib.parse import urlparse
 
-from dotenv import load_dotenv
-from ldap3 import ALL, Connection, Server
+from ldap3 import AUTO_BIND_NO_TLS, AUTO_BIND_TLS_BEFORE_BIND, SUBTREE, Connection, Server, Tls
+from ldap3.core.exceptions import LDAPException
+from ldap3.utils.conv import escape_filter_chars
 
-load_dotenv()
+from .config import settings
 
+logger = logging.getLogger(__name__)
 
-def ldap_authenticate(username: str, password: str) -> Optional[dict]:
-    ldap_url = os.environ.get("LDAP_URL")
-    ldap_user_dn = os.environ.get("LDAP_USER_DN")
-    ldap_base = os.environ.get("LDAP_BASE_DN")
-    if not ldap_url:
-        # Fallback mock for local development: accept any user with password 'password'
-        if password == "password":
-            return {"username": username, "groups": ["local"]}
-        return None
 
+class DirectoryUnavailable(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class DirectoryUser:
+    username: str
+    distinguished_name: str
+    name: str
+    email: str
+    disabled: bool = False
+
+
+def normalize_username(value: str) -> str:
+    username = value.strip()
+    if "\\" in username:
+        username = username.rsplit("\\", 1)[1]
+    if "@" in username:
+        username = username.split("@", 1)[0]
+    username = username.strip().lower()
+    if not username or not re.fullmatch(r"[a-z0-9._-]+", username):
+        raise ValueError("Ungültige Benutzerkennung")
+    return username
+
+
+def _server() -> tuple[Server, bool]:
+    if not settings.LDAP_URL:
+        raise DirectoryUnavailable("LDAP_URL ist nicht konfiguriert")
+    parsed = urlparse(settings.LDAP_URL if "://" in settings.LDAP_URL else f"ldaps://{settings.LDAP_URL}")
+    use_ssl = parsed.scheme.lower() == "ldaps"
+    use_start_tls = parsed.scheme.lower() == "ldap" and settings.LDAP_START_TLS
+    if not use_ssl and not use_start_tls:
+        raise DirectoryUnavailable("LDAP muss LDAPS oder validiertes StartTLS verwenden")
+    tls = Tls(validate=ssl.CERT_REQUIRED, version=ssl.PROTOCOL_TLS_CLIENT)
+    server = Server(parsed.hostname, port=parsed.port or (636 if use_ssl else 389), use_ssl=use_ssl, tls=tls)
+    return server, use_start_tls
+
+
+def _service_connection() -> Connection:
+    if not settings.LDAP_BIND_DN or not settings.LDAP_BIND_PASSWORD or not settings.LDAP_BASE_DN:
+        raise DirectoryUnavailable("LDAP-Servicekonto ist nicht vollständig konfiguriert")
+    server, start_tls = _server()
+    return Connection(
+        server,
+        user=settings.LDAP_BIND_DN,
+        password=settings.LDAP_BIND_PASSWORD,
+        auto_bind=AUTO_BIND_TLS_BEFORE_BIND if start_tls else AUTO_BIND_NO_TLS,
+        raise_exceptions=True,
+    )
+
+
+def lookup_directory_user(value: str) -> DirectoryUser | None:
+    username = normalize_username(value)
+    try:
+        with _service_connection() as connection:
+            connection.search(
+                settings.LDAP_BASE_DN,
+                f"(&(objectCategory=person)(objectClass=user)(sAMAccountName={escape_filter_chars(username)}))",
+                search_scope=SUBTREE,
+                attributes=["sAMAccountName", "displayName", "mail", "userAccountControl"],
+                size_limit=2,
+            )
+            if len(connection.entries) != 1:
+                return None
+            entry = connection.entries[0]
+            control = int(entry.userAccountControl.value or 0)
+            return DirectoryUser(
+                username=normalize_username(str(entry.sAMAccountName.value)),
+                distinguished_name=entry.entry_dn,
+                name=str(entry.displayName.value or entry.sAMAccountName.value),
+                email=str(entry.mail.value or ""),
+                disabled=bool(control & 2),
+            )
+    except (LDAPException, OSError) as exc:
+        logger.exception("AD-Benutzersuche fehlgeschlagen")
+        raise DirectoryUnavailable("Active Directory ist nicht erreichbar") from exc
+
+
+def ldap_authenticate(username: str, password: str) -> DirectoryUser | None:
+    if not password:
+        return None
+    user = lookup_directory_user(username)
+    if not user or user.disabled:
+        return None
     try:
-        server = Server(ldap_url, get_info=ALL)
-        conn = Connection(server, user=username, password=password, auto_bind=True)
-        # Simple success -> return username; group resolution left for future
-        return {"username": username, "groups": []}
-    except Exception:
+        server, start_tls = _server()
+        connection = Connection(
+            server,
+            user=user.distinguished_name,
+            password=password,
+            auto_bind=AUTO_BIND_TLS_BEFORE_BIND if start_tls else AUTO_BIND_NO_TLS,
+            raise_exceptions=True,
+        )
+        connection.unbind()
+        return user
+    except LDAPException:
+        logger.info("LDAP-Anmeldung für Benutzer %s fehlgeschlagen", user.username)
         return None

+ 321 - 0
app/logging_setup.py

@@ -0,0 +1,321 @@
+"""Safe structured logging shared by HTTP, database and CLI entrypoints."""
+from contextvars import ContextVar
+from datetime import datetime, timedelta, timezone
+import hashlib
+import json
+import logging
+import os
+from pathlib import Path
+import re
+import sys
+import threading
+import time
+import traceback
+from uuid import uuid4
+from zoneinfo import ZoneInfo
+
+from concurrent_log_handler import ConcurrentTimedRotatingFileHandler
+
+request_context = ContextVar('request_logging_context', default=None)
+db_operation = ContextVar('database_logging_operation', default=None)
+db_query = ContextVar('database_logging_query', default=None)
+BERLIN = ZoneInfo('Europe/Berlin')
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+_lock = threading.RLock()
+_configuration = None
+_SAFE_FIELDS = ('event', 'operation', 'query_name', 'query_fingerprint', 'sql', 'sql_truncated',
+                'sqlstate', 'db_code', 'db_message', 'db_diagnostics', 'status', 'duration_ms', 'outcome', 'size_bytes', 'count',
+                'reason', 'error_type')
+
+
+def clean(value):
+    return str(value).replace('\r', '\\r').replace('\n', '\\n').replace('\x00', '\\0')[:8192]
+
+
+def sanitize_sql(statement):
+    """Lex T-SQL literals/comments without modifying quoted identifiers or bind names."""
+    source, output, i = str(statement), [], 0
+    while i < len(source):
+        char = source[i]
+        if source.startswith('--', i):
+            end = source.find('\n', i + 2); i = len(source) if end < 0 else end
+            output.append(' ')
+        elif source.startswith('/*', i):
+            depth = 1; i += 2
+            while i < len(source) and depth:
+                if source.startswith('/*', i): depth += 1; i += 2
+                elif source.startswith('*/', i): depth -= 1; i += 2
+                else: i += 1
+            output.append(' ')
+        elif char == "'" or (char in 'nN' and source[i:i+2].endswith("'") and (i == 0 or not source[i-1].isalnum())):
+            if char != "'": i += 1
+            i += 1
+            while i < len(source):
+                if source[i:i+2] == "''": i += 2
+                elif source[i] == "'": i += 1; break
+                else: i += 1
+            output.append('?')
+        elif char in '["':
+            end_char = ']' if char == '[' else '"'
+            start = i; i += 1
+            while i < len(source):
+                if source[i:i+2] == end_char * 2: i += 2
+                elif source[i] == end_char: i += 1; break
+                else: i += 1
+            output.append(source[start:i] if char == '[' else '?')
+        elif (char.isdecimal() or char == '.' and i+1 < len(source) and source[i+1].isdecimal()) and (i == 0 or not (source[i-1].isalnum() or source[i-1] in '_:@$')):
+            match = re.match(r'(?:0[xX][0-9a-fA-F]+|(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)', source[i:])
+            output.append('?'); i += len(match[0])
+        else:
+            output.append(char); i += 1
+    return ' '.join(''.join(output).split())
+
+
+def exception_roots(error):
+    seen = set()
+    def visit(exc):
+        if id(exc) in seen: return []
+        seen.add(id(exc))
+        if isinstance(exc, BaseExceptionGroup):
+            return [root for child in exc.exceptions for root in visit(child)]
+        original = getattr(exc, 'orig', None) or exc.__cause__
+        return visit(original) if isinstance(original, BaseException) else [exc]
+    return visit(error)
+
+
+def frames(tb=None):
+    extracted = traceback.extract_tb(tb) if tb else traceback.extract_stack()[:-1]
+    return [dict(file=Path(item.filename).name, line=item.lineno, function=item.name) for item in extracted[-45:]]
+
+
+class ContextFilter(logging.Filter):
+    def filter(self, record):
+        if record.name.startswith('uvicorn.') and record.levelno < logging.INFO: return False
+        if not record.name.startswith(('app.', 'uvicorn.', '__main__', 'filter_export')) and record.levelno < logging.WARNING: return False
+        if not hasattr(record, 'event_id'): record.event_id = uuid4().hex
+        context = request_context.get()
+        request_id = context['request_id'] if context else None
+        if record.exc_info and record.exc_info[1]:
+            roots = exception_roots(record.exc_info[1])
+            fresh = [exc for exc in roots if getattr(exc, '_gc_log_event', None) in (None, record.event_id)
+                     or request_id is not None and getattr(exc, '_gc_log_request', None) != request_id]
+            if not fresh: return False
+            for exc in fresh:
+                exc._gc_log_event = record.event_id
+                exc._gc_log_request = request_id
+            record.safe_exceptions = [dict(type=type(exc).__module__ + '.' + type(exc).__name__,
+                                           frames=getattr(exc, '_gc_log_frames', None) or frames(exc.__traceback__)) for exc in fresh]
+        record.request_fields = {}
+        if context:
+            scope = context['scope']
+            principal = scope.get('state', {}).get('principal')
+            record.request_fields = dict(request_id=context['request_id'], user=getattr(principal, 'username', None),
+                                         method=scope['method'], path=scope.get('path', ''))
+        return True
+
+
+def record_data(record):
+    data = dict(timestamp=datetime.fromtimestamp(record.created, BERLIN).isoformat(timespec='milliseconds'),
+                level=record.levelname, logger=record.name, event_id=record.event_id,
+                event=getattr(record, 'event', 'application'),
+                message=clean(record.getMessage()) if record.name.startswith(('app.', 'uvicorn.', '__main__', 'filter_export')) else 'External logger event')
+    data.update({key: clean(value) if isinstance(value, str) else value for key, value in record.request_fields.items()})
+    data.update({key: getattr(record, key) for key in _SAFE_FIELDS if hasattr(record, key)})
+    if hasattr(record, 'safe_exceptions'): data['exceptions'] = record.safe_exceptions
+    return data
+
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record):
+        return json.dumps(record_data(record), ensure_ascii=True, separators=(',', ':'), default=lambda _: '[unsupported]')
+
+
+class ConsoleFormatter(logging.Formatter):
+    def format(self, record):
+        data = record_data(record)
+        suffix = {key: value for key, value in data.items() if key not in ('timestamp', 'level', 'logger', 'message')}
+        return f"{data['timestamp']} {data['level']} {data['logger']}: {data['message']} {json.dumps(suffix, ensure_ascii=True, separators=(',', ':'))}"
+
+
+class SafeConsoleHandler(logging.StreamHandler):
+    def emit(self, record):
+        super().emit(record)
+        record._gc_console_emitted = True
+
+    def handleError(self, record):
+        pass  # A broken console must not change application behavior or expose raw LogRecords.
+
+
+class ApplicationFileHandler(ConcurrentTimedRotatingFileHandler):
+    def __init__(self, filename, retention_days=30):
+        self.retention_days = retention_days
+        self.last_fallback = float('-inf')
+        super().__init__(filename=filename, when='midnight', interval=1, utc=True,
+                         backupCount=retention_days, encoding='utf-8', maxBytes=0)
+        self.cleanup_archives()
+
+    def cleanup_archives(self):
+        cutoff = datetime.now(timezone.utc).date() - timedelta(days=self.retention_days)
+        path = Path(self.baseFilename)
+        for candidate in path.parent.glob(path.name + '.*'):
+            suffix = candidate.name[len(path.name)+1:]
+            if not re.fullmatch(r'\d{4}-\d{2}-\d{2}', suffix): continue
+            try:
+                if datetime.strptime(suffix, '%Y-%m-%d').date() < cutoff: candidate.unlink(missing_ok=True)
+            except (OSError, ValueError):
+                self.fallback(None, 'log_cleanup_failed')
+
+    def doRollover(self):
+        try:
+            super().doRollover()
+        except Exception:
+            self.fallback(None, 'log_rotation_failed')
+            raise
+        self.cleanup_archives()
+
+    def fallback(self, record, event='log_file_unavailable'):
+        handler = SafeConsoleHandler(sys.stderr)
+        handler.setFormatter(ConsoleFormatter())
+        if time.monotonic() - self.last_fallback >= 60:
+            self.last_fallback = time.monotonic()
+            notice = logging.LogRecord('app.logging', logging.ERROR, __file__, 0, 'Logdatei nicht verfügbar; Konsolenfallback aktiv', (), None)
+            notice.event = event
+            ContextFilter().filter(notice); handler.handle(notice)
+        if record is not None and not getattr(record, '_gc_console_emitted', False): handler.handle(record)
+
+    def handleError(self, record):
+        self.fallback(record)
+
+
+def configure_logging(config=None, *, console_stream=None):
+    """Replace only our own handlers; repeated startup in one process is a no-op."""
+    global _configuration
+    if config is None:
+        from .config import settings
+        config = settings
+    directory = Path(config.LOG_DIR)
+    if not directory.is_absolute(): directory = PROJECT_ROOT / directory
+    signature = (os.getpid(), str(directory), config.LOG_LEVEL, config.LOG_TO_FILE, config.LOG_TO_CONSOLE,
+                 config.LOG_RETENTION_DAYS, config.LOG_SQL_STATEMENT, id(console_stream))
+    with _lock:
+        root = logging.getLogger()
+        if _configuration == signature and any(getattr(handler, '_gc_handler', False) for handler in root.handlers): return
+        for handler in list(root.handlers):
+            if getattr(handler, '_gc_handler', False): root.removeHandler(handler); handler.close()
+        handlers, file_failure = [], False
+        if config.LOG_TO_CONSOLE:
+            console = SafeConsoleHandler(console_stream or sys.stderr); console.setFormatter(ConsoleFormatter()); handlers.append(console)
+        if config.LOG_TO_FILE:
+            try:
+                directory.mkdir(parents=True, exist_ok=True)
+                file_handler = ApplicationFileHandler(str(directory / 'application.log'), config.LOG_RETENTION_DAYS)
+                file_handler.setFormatter(JsonFormatter()); handlers.append(file_handler)
+            except Exception:
+                file_failure = True
+                if not handlers:
+                    console = SafeConsoleHandler(console_stream or sys.stderr); console.setFormatter(ConsoleFormatter()); handlers.append(console)
+        if not handlers: handlers.append(logging.NullHandler())
+        for handler in handlers:
+            handler._gc_handler = True; handler.addFilter(ContextFilter()); root.addHandler(handler)
+        root.setLevel(config.LOG_LEVEL)
+        for name in ('uvicorn', 'uvicorn.error', 'uvicorn.access'):
+            logger = logging.getLogger(name); logger.handlers.clear(); logger.propagate = True
+            logger.setLevel(logging.INFO)
+        logging.getLogger('uvicorn.access').disabled = True
+        for name in ('sqlalchemy', 'urllib3', 'httpx', 'httpcore', 'ldap3', 'docuware'):
+            logging.getLogger(name).setLevel(logging.WARNING)
+        _configuration = signature
+        if file_failure: logging.getLogger('app.logging').error('Logverzeichnis nicht verfügbar; Konsolenfallback aktiv', extra={'event': 'log_file_unavailable'})
+
+
+def database_diagnostics(error, statement=None, parameters=None):
+    """Read ODBC diagnostics from the driver, never from SQLAlchemy's formatted exception."""
+    if type(error).__module__ != 'pyodbc':
+        return []
+    state = error.args[0] if error.args and isinstance(error.args[0], str) and re.fullmatch(r'[A-Z0-9]{5}', error.args[0]) else None
+    secrets = set()
+
+    def collect(value):
+        if isinstance(value, str) and value:
+            secrets.add(value)
+        elif isinstance(value, bytes):
+            collect(value.decode('utf-8', errors='replace'))
+        elif isinstance(value, dict):
+            for child in value.values(): collect(child)
+        elif isinstance(value, (tuple, list)):
+            for child in value: collect(child)
+
+    collect(parameters)
+    if statement is not None:
+        for match in re.finditer(r"N?'((?:''|[^'])*)'", str(statement), re.IGNORECASE):
+            collect(match[1].replace("''", "'"))
+
+    diagnostics = []
+    for raw in error.args[1:] if state else error.args:
+        if not isinstance(raw, str): continue
+        # pyodbc concatenates SQLGetDiagRec records, appending native codes and the ODBC function.
+        parts = list(re.finditer(r'(.*?)\s+\((-?\d+)\)(?:\s+\(SQL\w+\))?(?=;\s*|$)', raw, re.DOTALL))
+        records = [(part[1].lstrip('; \t\r\n'), int(part[2])) for part in parts] or [(raw.strip(), None)]
+        for description, code in records:
+            own_state = re.match(r'\[([A-Z0-9]{5})\]', description)
+            description = re.sub(r'^(?:\[[^\]\r\n]*\]\s*)+', '', description)
+            # Error 207 identifies schema metadata, not a parameter value. Only exempt
+            # the canonical English/German message, never arbitrary text with code 207.
+            column_message = description if code == 207 and re.fullmatch(
+                r'''(?:Invalid column name|Ungültiger Spaltenname)\s+(?:'(?:''|[^'])*'|"(?:""|[^"])*"|„[^“]*“|“[^”]*”|‚[^‘]*‘|‘[^’]*’|«[^»]*»)\s*\.?''',
+                description.strip(), re.IGNORECASE,
+            ) else None
+            # Values may also be echoed without quotes (notably duplicate key tuples).
+            for secret in sorted(secrets, key=len, reverse=True):
+                description = description.replace(secret, '?').replace(secret.replace("'", "''"), '?')
+            description = re.sub(r'\([^)]*(?:\)|$)', '(?)', description)
+            description = re.sub(r'(?i)\b(password|pwd|token|secret)\s*[:=]\s*[^;\s]+', r'\1=?', description)
+            description = clean(column_message if column_message is not None else sanitize_sql(description))[:4096]
+            diagnostics.append(dict(sqlstate=own_state[1] if own_state else state, code=code, message=description))
+    return diagnostics[:20]
+
+
+def log_query_error(error, statement=None, query_name=None, operation=None, parameters=None):
+    from .config import settings
+    try:
+        sql = sanitize_sql(statement) if statement is not None else ''
+    except Exception:
+        sql = '[statement unavailable]'
+    metadata = dict(event='database_error', operation=operation or db_operation.get() or 'execute',
+                    query_name=query_name or query_origin(), query_fingerprint=hashlib.sha256(sql.encode()).hexdigest())
+    if settings.LOG_SQL_STATEMENT and sql:
+        metadata.update(sql=sql[:8192], sql_truncated=len(sql) > 8192)
+    roots = exception_roots(error)
+    diagnostics = []
+    for root in roots:
+        if not getattr(root, '_gc_log_frames', None): root._gc_log_frames = frames()
+        first = root.args[0] if root.args else None
+        if isinstance(first, str) and re.fullmatch(r'[A-Z0-9]{5}', first): metadata['sqlstate'] = first
+        code = getattr(root, 'sqlite_errorcode', None)
+        if isinstance(code, int): metadata['db_code'] = code
+        try:
+            diagnostics.extend(database_diagnostics(root, statement, parameters if parameters is not None else getattr(error, 'params', None)))
+        except Exception:
+            pass  # A malformed driver diagnostic must not replace the original database error.
+    if diagnostics:
+        metadata['db_diagnostics'] = diagnostics[:20]
+        metadata['db_message'] = diagnostics[0]['message']
+        if diagnostics[0]['code'] is not None: metadata['db_code'] = diagnostics[0]['code']
+    logging.getLogger('app.db').error('Datenbankoperation fehlgeschlagen', exc_info=(type(error), error, error.__traceback__), extra=metadata)
+
+
+def query_origin():
+    for item in reversed(traceback.extract_stack()[:-1]):
+        path = Path(item.filename)
+        if PROJECT_ROOT / 'app' in path.parents and path.name not in ('logging_setup.py', 'db.py'):
+            return f'{path.name}:{item.name}'
+    return 'database'
+
+
+def run_cli(callback):
+    configure_logging()
+    try:
+        callback()
+    except Exception:
+        logging.getLogger('app.cli').exception('Hilfsprogramm fehlgeschlagen', extra={'event': 'cli_failed'})
+        raise SystemExit(1) from None

+ 14 - 12
app/main.py

@@ -1,24 +1,26 @@
+from contextlib import asynccontextmanager
+
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
-# from .db import Base, engine
+from .auth import AuthenticationMiddleware
 from .routes import router
-
-app = FastAPI(title="GCOutline")
-
-app.include_router(router)
+from .http_logging import install_request_logging
+from .logging_setup import configure_logging
 
 
-@app.on_event("startup")
-def on_startup():
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    configure_logging()
     # Create tables for demo if they do not exist
     # Base.metadata.create_all(bind=engine)
-    pass
+    yield
 
 
-app.mount("/static", StaticFiles(directory="static"), name="static")
+app = FastAPI(title="GCOutline", lifespan=lifespan)
 
+app.add_middleware(AuthenticationMiddleware)
+install_request_logging(app)
+app.include_router(router)
 
-@app.get("/")
-async def root():
-    return {"message": "Hello Bigger Applications!"}
+app.mount("/static", StaticFiles(directory="static"), name="static")

+ 0 - 50
app/main2.py

@@ -1,50 +0,0 @@
-from fastapi import FastAPI, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-from fastapi.security import OAuth2PasswordRequestForm
-from .oauth_token import create_access_token
-from .schemas import User, Token
-from .auth2 import get_current_user
-from .users import UserModel, get_password_hash, authenticate_user
-from .db import get_session
-
-app = FastAPI()
-
-
-@app.post("/token", response_model=Token)
-def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_session)):
-    user = authenticate_user(db, form_data.username, form_data.password)
-    print(user)
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect username or password",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    access_token = create_access_token(data={"sub": user.username})
-    return {"access_token": access_token, "token_type": "bearer"}
-
-
-@app.get("/users/me")
-def read_users_me(current_user: User = Depends(get_current_user)):
-    return current_user
-
-
-@app.post("/users/createUsers")
-def create_user(user: User, db: Session = Depends(get_session), current_user: User = Depends(get_current_user)):
-    # Check if the username already exists
-    existing_user = db.query(UserModel).filter(UserModel.username == user.username).first()
-    if existing_user:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Username already exists",
-        )
-
-    hashed_password = get_password_hash(user.hashed_password)
-    # Create a new user object
-    new_user = UserModel(username=user.username, email=user.email, hashed_password=hashed_password)
-    # Add the new user to the database
-    db.add(new_user)
-    db.commit()
-    db.refresh(new_user)
-
-    return {"message": "User created successfully", "user_id": new_user.id}

+ 0 - 94
app/main3.py

@@ -1,94 +0,0 @@
-from typing import Annotated
-
-from fastapi import Depends, FastAPI, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from pydantic import BaseModel
-
-fake_users_db = {
-    "johndoe": {
-        "username": "johndoe",
-        "full_name": "John Doe",
-        "email": "johndoe@example.com",
-        "hashed_password": "fakehashedsecret",
-        "disabled": False,
-    },
-    "alice": {
-        "username": "alice",
-        "full_name": "Alice Wonderson",
-        "email": "alice@example.com",
-        "hashed_password": "fakehashedsecret2",
-        "disabled": True,
-    },
-}
-
-app = FastAPI()
-
-
-def fake_hash_password(password: str):
-    return "fakehashed" + password
-
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-
-class User(BaseModel):
-    username: str
-    email: str | None = None
-    full_name: str | None = None
-    disabled: bool | None = None
-
-
-class UserInDB(User):
-    hashed_password: str
-
-
-def get_user(db, username: str):
-    if username in db:
-        user_dict = db[username]
-        return UserInDB(**user_dict)
-
-
-def fake_decode_token(token):
-    # This doesn't provide any security at all
-    # Check the next version
-    user = get_user(fake_users_db, token)
-    return user
-
-
-async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
-    user = fake_decode_token(token)
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Not authenticated",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    return user
-
-
-async def get_current_active_user(
-    current_user: Annotated[User, Depends(get_current_user)],
-):
-    if current_user.disabled:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
-
-
-@app.post("/token")
-async def login(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
-    user_dict = fake_users_db.get(form_data.username)
-    if not user_dict:
-        raise HTTPException(status_code=400, detail="Incorrect username or password")
-    user = UserInDB(**user_dict)
-    hashed_password = fake_hash_password(form_data.password)
-    if not hashed_password == user.hashed_password:
-        raise HTTPException(status_code=400, detail="Incorrect username or password")
-
-    return {"access_token": user.username, "token_type": "bearer"}
-
-
-@app.get("/users/me")
-async def read_users_me(
-    current_user: Annotated[User, Depends(get_current_active_user)],
-):
-    return current_user

+ 0 - 62
app/models.py

@@ -1,62 +0,0 @@
-from datetime import datetime, timezone
-
-from sqlalchemy import (
-    Column,
-    Date,
-    DateTime,
-    ForeignKey,
-    Integer,
-    Numeric,
-    String,
-    Text,
-)
-from sqlalchemy.orm import relationship
-
-from .db import Base
-
-
-class Kunde(Base):
-    __tablename__ = "kunden"
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String, nullable=False)
-    historie = Column(Text, default="")
-    forderungen = relationship("Forderung", back_populates="kunde")
-
-
-class Forderung(Base):
-    __tablename__ = "forderungen"
-    id = Column(Integer, primary_key=True, index=True)
-    kunde_id = Column(Integer, ForeignKey("kunden.id"))
-    verkaeufer_id = Column(Integer, index=True)
-    fahrzeug = Column(String, nullable=True)
-    fahrgestellnummer = Column(String, nullable=True)
-    rechnungsnummer: Column[str] = Column(String, nullable=False)
-    betrag = Column(Numeric(12, 2), nullable=False)
-    faelligkeit = Column(Date, nullable=True)
-    status = Column(String, default="offen")
-
-    kunde = relationship("Kunde", back_populates="forderungen")
-    zahlungen = relationship("Zahlung", back_populates="forderung")
-    bemerkungen = relationship("Bemerkung", back_populates="forderung")
-
-
-class Zahlung(Base):
-    __tablename__ = "zahlungen"
-    id = Column(Integer, primary_key=True, index=True)
-    forderung_id = Column(Integer, ForeignKey("forderungen.id"))
-    betrag = Column(Numeric(12, 2), nullable=False)
-    datum = Column(Date, nullable=False)
-
-    forderung = relationship("Forderung", back_populates="zahlungen")
-
-
-class Bemerkung(Base):
-    __tablename__ = "bemerkungen"
-    id = Column(Integer, primary_key=True, index=True)
-    forderung_id = Column(Integer, ForeignKey("forderungen.id"))
-    benutzer = Column(String, nullable=False)
-    bemerkung = Column(Text, nullable=True)
-    wiedervorlage_datum = Column(Date, nullable=True)
-    zeitstempel = Column(DateTime, default=datetime.now(timezone.utc))
-
-    forderung = relationship("Forderung", back_populates="bemerkungen")

+ 132 - 0
app/navigation.py

@@ -0,0 +1,132 @@
+"""Canonical page URLs for return navigation and authentication recovery."""
+import re
+from urllib.parse import parse_qsl, quote, unquote, urlencode, urlsplit
+
+from .query_filter import import_filter_config
+from .dashboard_segment import parse_segment, pack_segment
+
+LIST_PATH = '/app/forderungen/liste'
+DETAIL_PREFIX = '/app/forderungen/details/'
+DETAIL_PAGE = re.compile(r'^/app/forderungen/details/([^/]+)(?:/(?:kommentare|buchungen))?/?$')
+ASSIGNEE_MODAL = re.compile(r'^/app/forderungen/(liste|details)/([^/]+)/verursacher/?$')
+FOLLOW_UP_MODAL = re.compile(r'^/app/forderungen/liste/([^/]+)/wiedervorlage/?$')
+
+
+def valid_focus(value: str | None) -> bool:
+    if not value or any(ord(c) < 32 or ord(c) == 127 or c in '/\\' for c in value):
+        return False
+    tenant, separator, number = value.partition('_')
+    return bool(separator and tenant and number and len(tenant) <= 20 and len(number) <= 100)
+
+
+def _local_parts(value):
+    if not isinstance(value, str) or not value.startswith('/') or value.startswith('//'):
+        return None
+    if any(ord(c) < 32 or ord(c) == 127 or c == '\\' for c in value):
+        return None
+    try:
+        parts = urlsplit(value)
+    except ValueError:
+        return None
+    decoded = unquote(parts.path)
+    if parts.scheme or parts.netloc or decoded.startswith('//') or '\\' in decoded:
+        return None
+    if any(ord(c) < 32 or ord(c) == 127 for c in decoded):
+        return None
+    return parts
+
+
+def list_url(filters=None, focus: str | None = None) -> str:
+    filters = filters or {}
+    params = {f.name: filters[f.name] for f in import_filter_config('forderungen')
+              if f.name in filters and filters[f.name] not in ('', None)}
+    if filters.get('dashboard_segment'):
+        try:
+            params['dashboard_segment'] = pack_segment(parse_segment(filters['dashboard_segment']))
+        except ValueError:
+            pass  # Untrusted return/login URLs must never carry malformed selections.
+    if valid_focus(focus):
+        params['focus'] = focus
+    return LIST_PATH + ('?' + urlencode(params) if params else '')
+
+
+def list_return_url(value: str | None, primary_key: str) -> str:
+    parts = _local_parts(value)
+    filters = dict(parse_qsl(parts.query)) if parts and parts.path == LIST_PATH else {}
+    return list_url(filters, primary_key)
+
+
+def _current_parts(value):
+    """Extract context, never a redirect origin, from the browser's current URL."""
+    if not value:
+        return None
+    try:
+        parts = urlsplit(value)
+    except ValueError:
+        return None
+    if parts.scheme and parts.scheme not in ('http', 'https'):
+        return None
+    return _local_parts(parts.path + ('?' + parts.query if parts.query else ''))
+
+
+def return_url_for_request(request, primary_key: str, explicit: str | None = None) -> str:
+    value = explicit if explicit is not None else request.query_params.get('return_to')
+    if value is None:
+        current = _current_parts(request.headers.get('HX-Current-URL'))
+        match = DETAIL_PAGE.fullmatch(unquote(current.path)) if current else None
+        if match and match[1] == primary_key:
+            value = dict(parse_qsl(current.query)).get('return_to')
+    return list_return_url(value, primary_key)
+
+
+def detail_navigation_context(request, primary_key: str, explicit: str | None = None) -> dict:
+    return_url = return_url_for_request(request, primary_key, explicit)
+    return {
+        'return_url': return_url,
+        'detail_post_url': DETAIL_PREFIX + quote(primary_key, safe='') + '?' + urlencode({'return_to': return_url}),
+    }
+
+
+def normalize_page_url(value: str | None, default='/select', current_url: str | None = None) -> str:
+    parts = _local_parts(value)
+    if not parts:
+        return default
+    params = dict(parse_qsl(parts.query))
+    current = _current_parts(current_url)
+    follow_up = FOLLOW_UP_MODAL.fullmatch(unquote(parts.path))
+    if follow_up and valid_focus(follow_up[1]):
+        value = params.get('return_to')
+        if value is None and current and current.path == LIST_PATH:
+            value = current.path + ('?' + current.query if current.query else '')
+        return list_return_url(value, follow_up[1])
+    modal = ASSIGNEE_MODAL.fullmatch(unquote(parts.path))
+    if modal and valid_focus(modal[2]):
+        primary_key = modal[2]
+        value = params.get('return_to')
+        if modal[1] == 'liste':
+            if value is None and current and current.path == LIST_PATH:
+                value = current.path + ('?' + current.query if current.query else '')
+            return list_return_url(value, primary_key)
+        if value is None and current:
+            previous = DETAIL_PAGE.fullmatch(unquote(current.path))
+            if previous and previous[1] == primary_key:
+                value = dict(parse_qsl(current.query)).get('return_to')
+        return DETAIL_PREFIX + quote(primary_key, safe='') + '?' + urlencode({'return_to': list_return_url(value, primary_key)})
+    if parts.path == LIST_PATH:
+        focus = params.get('focus')
+        if not focus and current and current.path == LIST_PATH:
+            previous = dict(parse_qsl(current.query))
+            if list_url(params) == list_url(previous):
+                focus = previous.get('focus')
+        return list_url(params, focus)
+    match = DETAIL_PAGE.fullmatch(unquote(parts.path))
+    if match and valid_focus(match[1]):
+        primary_key = match[1]
+        value = params.get('return_to')
+        if value is None and current:
+            previous = DETAIL_PAGE.fullmatch(unquote(current.path))
+            if previous and previous[1] == primary_key:
+                value = dict(parse_qsl(current.query)).get('return_to')
+        detail = DETAIL_PREFIX + quote(primary_key, safe='')
+        return detail + ('?' + urlencode({'return_to': list_return_url(value, primary_key)}) if value else '')
+    return parts.path + ('?' + parts.query if parts.query else '') + ('#' + parts.fragment if parts.fragment else '')

+ 89 - 19
app/oauth_token.py

@@ -1,30 +1,100 @@
 from datetime import datetime, timedelta, timezone
+from secrets import token_urlsafe
+from uuid import uuid4
+
 from jose import JWTError, jwt
-from fastapi import HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
+
 from .config import settings
 
-SECRET_KEY = settings.SECRET_KEY
-ALGORITHM = settings.ALGORITHM
-ACCESS_TOKEN_EXPIRE_MINUTES = settings.ACCESS_TOKEN_EXPIRE_MINUTES
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+class InvalidSessionToken(ValueError):
+    pass
+
 
+def utcnow() -> datetime:
+    return datetime.now(timezone.utc)
 
-def create_access_token(data: dict):
-    to_encode = data.copy()
-    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    to_encode.update({"exp": expire})
-    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
 
+def create_access_token(
+    *,
+    username: str,
+    name: str,
+    email: str,
+    role: str,
+    auth_source: str,
+    session_started: datetime | None = None,
+    csrf: str | None = None,
+    now: datetime | None = None,
+) -> str:
+    now = now or utcnow()
+    session_started = session_started or now
+    absolute_expiry = session_started + timedelta(hours=settings.JWT_ABSOLUTE_HOURS)
+    expiry = min(now + timedelta(minutes=settings.JWT_IDLE_MINUTES), absolute_expiry)
+    payload = {
+        "sub": username,
+        "name": name,
+        "email": email,
+        "role": role,
+        "auth_source": auth_source,
+        "iss": settings.JWT_ISSUER,
+        "aud": settings.JWT_AUDIENCE,
+        "iat": int(now.timestamp()),
+        "nbf": int(now.timestamp()),
+        "exp": int(expiry.timestamp()),
+        "session_exp": int(absolute_expiry.timestamp()),
+        "jti": str(uuid4()),
+        "csrf": csrf or token_urlsafe(32),
+    }
+    return jwt.encode(payload, settings.JWT_SECRET, algorithm="HS256")
 
-def verify_token(token: str):
+
+def decode_access_token(token: str) -> dict:
     try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        return payload
-    except JWTError:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or expired token",
-            headers={"WWW-Authenticate": "Bearer"},
+        payload = jwt.decode(
+            token,
+            settings.JWT_SECRET,
+            algorithms=["HS256"],
+            audience=settings.JWT_AUDIENCE,
+            issuer=settings.JWT_ISSUER,
         )
+    except JWTError as exc:
+        raise InvalidSessionToken("Invalid or expired session token") from exc
+
+    required = {"sub", "name", "email", "role", "auth_source", "exp", "session_exp", "csrf"}
+    if not required.issubset(payload):
+        raise InvalidSessionToken("Session token is missing required claims")
+    if payload["auth_source"] not in {"iis", "ldap", "debug"}:
+        raise InvalidSessionToken("Unknown authentication source")
+    if payload["auth_source"] == "debug" and not settings.debug_auth_enabled:
+        raise InvalidSessionToken("Debug authentication is disabled")
+    if int(payload["session_exp"]) <= int(utcnow().timestamp()):
+        raise InvalidSessionToken("Absolute session lifetime exceeded")
+    return payload
+
+
+def token_needs_renewal(payload: dict, role: str, now: datetime | None = None) -> bool:
+    now = now or utcnow()
+    renew_at = datetime.fromtimestamp(int(payload["exp"]), timezone.utc) - timedelta(
+        minutes=settings.JWT_RENEW_BEFORE_MINUTES
+    )
+    return role != payload["role"] or now >= renew_at
+
+
+def renew_access_token(payload: dict, role: str, now: datetime | None = None) -> str:
+    started = datetime.fromtimestamp(int(payload["session_exp"]), timezone.utc) - timedelta(
+        hours=settings.JWT_ABSOLUTE_HOURS
+    )
+    return create_access_token(
+        username=payload["sub"],
+        name=payload["name"],
+        email=payload["email"],
+        role=role,
+        auth_source=payload["auth_source"],
+        session_started=started,
+        csrf=payload["csrf"],
+        now=now,
+    )
+
+
+def verify_token(token: str) -> dict:
+    return decode_access_token(token)

+ 92 - 0
app/permissions.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+
+from fastapi import HTTPException, status
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+
+@dataclass(frozen=True)
+class Entitlement:
+    hauptbetrieb_id: str
+    standort_id: str
+    abteilung: str | None
+    role: str
+    priority: int
+
+
+@dataclass(frozen=True)
+class Principal:
+    username: str
+    name: str
+    email: str
+    role: str
+    auth_source: str
+    csrf: str
+    entitlements: tuple[Entitlement, ...]
+
+
+RIGHTS_SQL = text("""
+    SELECT BR.Hauptbetrieb_ID,
+           BR.Standort_ID,
+           BR.Abteilung,
+           BR.Rolle_Name,
+           BR.Rolle_Prio
+    FROM dbo.Benutzer_Rechte AS BR
+    WHERE BR.Benutzer_ID = :username
+    ORDER BY BR.Rolle_Prio DESC, BR.Rolle_Name ASC
+    """)
+
+
+def load_entitlements(db: Session, username: str) -> tuple[Entitlement, ...]:
+    rows = db.execute(RIGHTS_SQL, {"username": username}).mappings().all()
+    return tuple(
+        Entitlement(
+            hauptbetrieb_id=str(row["Hauptbetrieb_ID"]),
+            standort_id=str(row["Standort_ID"]),
+            abteilung=row["Abteilung"],
+            role=row["Rolle_Name"],
+            priority=int(row["Rolle_Prio"]),
+        )
+        for row in rows
+    )
+
+
+def highest_role(entitlements: tuple[Entitlement, ...]) -> str:
+    if not entitlements:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Keine Berechtigung für diese Anwendung")
+    return sorted(entitlements, key=lambda item: (-item.priority, item.role))[0].role
+
+
+FORDERUNG_ACCESS_SQL = text("""
+    SELECT TOP 1 1
+    FROM dbo.Forderungen_Kopf AS F
+    WHERE F.Client_DB = :client_db
+      AND F.Beleg_Nr = :beleg_nr
+      AND EXISTS (
+          SELECT 1
+          FROM dbo.Benutzer_Rechte AS BR
+          WHERE BR.Benutzer_ID = :auth_username
+            AND BR.Hauptbetrieb_ID = F.Hauptbetrieb_ID
+            AND BR.Standort_ID = F.Standort_ID
+            AND BR.Abteilung = F.Abteilung
+      )
+    """)
+
+
+def has_forderung_access(db: Session, principal: Principal, client_db: str, beleg_nr: str) -> bool:
+    return db.execute(
+        FORDERUNG_ACCESS_SQL,
+        {"client_db": client_db, "beleg_nr": beleg_nr, "auth_username": principal.username},
+    ).first() is not None
+
+
+def ensure_forderung_access(db: Session, principal: Principal, client_db: str, beleg_nr: str) -> None:
+    if not has_forderung_access(db, principal, client_db, beleg_nr):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Forderung nicht gefunden")
+
+
+def current_principal(request) -> Principal:
+    principal = getattr(request.state, "principal", None)
+    if principal is None:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Nicht angemeldet")
+    return principal

+ 388 - 232
app/routes.py

@@ -1,15 +1,15 @@
 import io
+import logging
 import re
+import secrets
 from datetime import datetime, timedelta
+from decimal import Decimal
 from pathlib import Path
 from typing import Annotated
 from urllib.parse import unquote, urlencode
 
-import pandas as pd
-import requests
-from docx import Document
 from docxtpl import DocxTemplate
-from fastapi import APIRouter, Depends, Form, HTTPException, Request, Response
+from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
 from fastapi.responses import (
     FileResponse,
     HTMLResponse,
@@ -19,50 +19,170 @@ from fastapi.responses import (
 from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from app.file_storage import get_file, get_files
-from app.query_filter import filter_type_option, import_filter_config
-
+from app.file_storage import file_primary_key, get_file, get_files
+from app.query_filter import import_filter_config
+
+from .auth import clear_session_cookie, safe_next_url, set_session_cookie
+from .comment_submission import submit_comment
+from .config import settings
+from .dashboard_segment import (
+    DASHBOARD_VIEWS,
+    pack_segment,
+    parse_segment,
+    segment_label,
+    segment_sql,
+)
 from .db import get_session
 from .docuware_search import get_invoice_pdf_by_document_no
+from .forderung_dashboard import STACKS, build_dashboard
+from .forderung_data import read_invoices
+from .forderung_history import HistoryScope, history_context, section_context
+from .forderung_summary import get_forderung_summary
 from .jinja_templates import templates
-from .ldap import ldap_authenticate
-from .models import Forderung
+from .ldap import (
+    DirectoryUnavailable,
+    DirectoryUser,
+    ldap_authenticate,
+    normalize_username,
+)
+from .navigation import (
+    detail_navigation_context,
+    list_url,
+    return_url_for_request,
+    valid_focus,
+)
+from .oauth_token import create_access_token
+from .permissions import (
+    current_principal,
+    ensure_forderung_access,
+    has_forderung_access,
+    highest_role,
+    load_entitlements,
+)
+from .verursacher import router as verursacher_router
+from .wiedervorlage import router as wiedervorlage_router
 
 router = APIRouter()
+router.include_router(verursacher_router)
+router.include_router(wiedervorlage_router)
+logger = logging.getLogger(__name__)
 
 
 @router.get("/", response_class=HTMLResponse)
 def index(request: Request):
-    return RedirectResponse(url="/login")
+    return RedirectResponse(url="/select")
 
 
-@router.get("/login", response_class=HTMLResponse)
-def login_get(request: Request):
-    return templates.TemplateResponse(request, "base/login.html", {"request": request})
+@router.get("/health")
+def health():
+    return {"status": "ok"}
 
 
-@router.get("/select", response_class=HTMLResponse)
-def select_get(request: Request):
-    return templates.TemplateResponse(request, "base/select.html", {"request": request})
+def _login_response(request: Request, next: str | None, error: str | None = None, status_code: int = 200):
+    # Keep open login forms valid when another tab loads the login page.
+    csrf = request.cookies.get(settings.LOGIN_CSRF_COOKIE_NAME, "")
+    if not re.fullmatch(r"[A-Za-z0-9_-]{43}", csrf):
+        csrf = secrets.token_urlsafe(32)
+    response = templates.TemplateResponse(
+        request,
+        "base/login.html",
+        {"request": request, "csrf": csrf, "next": safe_next_url(next), "error": error},
+        status_code=status_code,
+        headers={"Cache-Control": "no-store"},
+    )
+    response.set_cookie(
+        settings.LOGIN_CSRF_COOKIE_NAME,
+        csrf,
+        secure=settings.COOKIE_SECURE,
+        httponly=True,
+        samesite="lax",
+        path="/login",
+    )
+    return response
+
+
+@router.get("/login", response_class=HTMLResponse)
+def login_get(request: Request, next: str | None = None):
+    if getattr(request.state, "principal", None):
+        return RedirectResponse(safe_next_url(next), status_code=303)
+    return _login_response(request, next)
 
 
 @router.post("/login")
-def login_post(username: str = Form(...), password: str = Form(...)):
-    user = ldap_authenticate(username, password)
+def login_post(
+    request: Request,
+    username: Annotated[str, Form()],
+    password: Annotated[str, Form()],
+    csrf: Annotated[str, Form(alias="_csrf")] = "",
+    next: Annotated[str | None, Form()] = None,
+    db: Session = Depends(get_session),
+):
+    if getattr(request.state, "principal", None):
+        return RedirectResponse(safe_next_url(next), status_code=303)
+    expected_csrf = request.cookies.get(settings.LOGIN_CSRF_COOKIE_NAME, "")
+    if not expected_csrf or not secrets.compare_digest(expected_csrf, csrf):
+        return _login_response(
+            request,
+            next,
+            error="Das Anmeldeformular ist nicht mehr gültig. Bitte melden Sie sich erneut an. "
+            "Falls der Fehler erneut auftritt, prüfen Sie, ob Cookies für diese Website erlaubt sind.",
+            status_code=status.HTTP_403_FORBIDDEN,
+        )
+
+    try:
+        if settings.debug_auth_enabled:
+            user = None
+            if username and secrets.compare_digest(username.encode("utf-8"), password.encode("utf-8")):
+                normalized = normalize_username(username)
+                user = DirectoryUser(
+                    username=normalized,
+                    distinguished_name="",
+                    name=normalized,
+                    email="",
+                )
+        else:
+            user = ldap_authenticate(username, password)
+    except DirectoryUnavailable:
+        logger.exception("LDAP-Anmeldedienst nicht verfügbar")
+        return _login_response(request, next, error="Anmeldedienst ist derzeit nicht verfügbar", status_code=503)
+    except ValueError:
+        user = None
     if not user:
-        raise HTTPException(status_code=401, detail="Invalid credentials")
-    # For a simple demo we set a cookie (not secure) -- replace with real session in production
-    response = RedirectResponse(url="/forderungen", status_code=302)
-    response.set_cookie("user", user["username"])
+        return _login_response(request, next, error="Anmeldung fehlgeschlagen", status_code=401)
+
+    entitlements = load_entitlements(db, user.username)
+    role = highest_role(entitlements)
+    token = create_access_token(
+        username=user.username,
+        name=user.name,
+        email=user.email,
+        role=role,
+        auth_source="debug" if settings.debug_auth_enabled else "ldap",
+    )
+    response = RedirectResponse(url=safe_next_url(next), status_code=303)
+    set_session_cookie(response, token)
+    response.delete_cookie(settings.LOGIN_CSRF_COOKIE_NAME, path="/login")
     return response
 
 
-def single_quote(text: str):
-    return "'" + unquote(text) + "'"
+@router.post("/logout")
+def logout(request: Request):
+    request.state.suppress_session_refresh = True
+    response = templates.TemplateResponse(request, "base/logout.html", {"request": request})
+    clear_session_cookie(response)
+    return response
+
+
+@router.get("/select", response_class=HTMLResponse)
+def select_get(request: Request):
+    return templates.TemplateResponse(request, "base/select.html", {"request": request})
 
 
 @router.get("/app/forderungen/liste", response_class=HTMLResponse)
-def forderungen_liste(request: Request, db: Session = Depends(get_session), limit: int = 100, page: int = 0):
+def forderungen_liste(
+    request: Request, db: Session = Depends(get_session), limit: int = 100, page: int = 0, focus: str | None = None
+):
+    principal = current_principal(request)
     forderung_filter_config = import_filter_config("forderungen")
 
     params = {
@@ -70,29 +190,39 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
         for f in forderung_filter_config
         if request.query_params.get(f.name, "") != ""
     }
-    if page == 0 and len(params) < len(request.query_params):
-        return RedirectResponse(url="/app/forderungen/liste?" + urlencode(params))
-
-    context = {}
+    try:
+        selection = parse_segment(request.query_params.get("dashboard_segment"))
+    except ValueError as error:
+        raise HTTPException(400, "Ungültiger Dashboardfilter") from error
+    if selection:
+        params["dashboard_segment"] = pack_segment(selection)
+    if not valid_focus(focus):
+        focus = None
+    if page == 0:
+        canonical = list_url(params, focus)
+        if request.url.path + ("?" + request.url.query if request.url.query else "") != canonical:
+            return RedirectResponse(url=canonical)
+
+    query_clauses = []
+    query_values = {"auth_username": principal.username}
     for f in forderung_filter_config:
-        context[f.name] = {filter_type_option[f.filter_type]: single_quote(params.get(f.name, f.default_value))}
-        if f.name in params:
-            f.current_value = params[f.name]
+        f.current_value = unquote(params.get(f.name, f.default_value))
+        if f.filter_type == "hidden" or not f.current_value:
+            continue
+        parameter = f"filter_{f.name.lower()}"
+        if f.filter_type == "date":
+            operator = "<=" if "bis" in f.name.lower() else ">="
+            query_clauses.append(f"F.[{f.key_column}] {operator} :{parameter}")
+            query_values[parameter] = f.current_value
+        else:
+            query_clauses.append(f"F.[{f.key_column}] LIKE :{parameter}")
+            query_values[parameter] = f"%{f.current_value}%"
 
-    query = templates.TemplateResponse(request, "forderungen/liste/queries/forderungen_liste.sql", context).body.decode(
-        "utf-8"
-    )
-    query_params = [
-        f.query_param for f in forderung_filter_config if f.query_param is not None and f.filter_type != "hidden"
-    ]
-    if query_params:
-        query = query.replace("1 = 1", " AND ".join(query_params))
-    print(query)
-    print(query_params)
-    # q = db.execute(text("SELECT * FROM [dbo].[Forderungen]"))
-    q_res = db.execute(text(query))
-    col_names = list(q_res.keys())
-    q = q_res.fetchall()
+    if selection:
+        clauses, values = segment_sql(selection)
+        query_clauses.extend(clauses)
+        query_values.update(values)
+    col_names, q = read_invoices(db, principal.username, query_clauses, query_values)
 
     filters = {}
     for f in forderung_filter_config:
@@ -107,27 +237,38 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
             for row in q
         ]
         if filter_temp:
-            print(filter_temp[0])
-            filters[f.name] = {item[1]: item[2] for item in sorted(list(set(filter_temp)))}
+            filters[f.name] = {
+                item[1]: item[2]
+                for item in sorted(set(filter_temp), key=lambda item: tuple(str(value or "") for value in item))
+                if item[1]
+            }
         else:
-            print(f"Filter {f.name} has no options, skipping")
             filters[f.name] = {}
         f.options = filters[f.name]
 
     summary = {
-        "Beleg_offen": sum([r[col_names.index("Beleg_offen")] for r in q]),
+        "Beleg_Offen": sum((Decimal(str(r[col_names.index("Beleg_Offen")] or 0)) for r in q), Decimal(0)),
         "Anzahl": len(q),
     }
 
-    q_limit = q[page * limit : (page + 1) * limit]
+    end = (page + 1) * limit
+    focus_found = False
+    if page == 0 and focus:
+        tenant_column, number_column = col_names.index("Client_DB"), col_names.index("Beleg_Nr")
+        for index, row in enumerate(q):
+            if f"{row[tenant_column]}_{row[number_column]}" == focus:
+                end = max(end, (index // limit + 1) * limit)
+                focus_found = True
+                break
+    q_limit = q[page * limit : end]
 
     defaults = {}
     for f in forderung_filter_config:
         defaults[f.name] = unquote(request.query_params.get(f.name, f.default_value))
         f.current_value = defaults[f.name]
 
-    if len(q_limit) == 0:
-        return None
+    if page > 0 and not q_limit:
+        return HTMLResponse("")
 
     template = "base/liste.html"
     if page > 0:
@@ -143,246 +284,248 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
             "defaults": defaults,
             "summary": summary,
             "page": page,
+            "limit": limit,
+            "has_more": end < len(q),
+            "next_page": end // limit,
+            "list_url": list_url(params),
+            "focus": focus if page == 0 else None,
+            "focus_missing": bool(page == 0 and focus and not focus_found),
             "filter_config": forderung_filter_config,
+            "dashboard_segment": params.get("dashboard_segment"),
+            "dashboard_segment_label": (
+                segment_label(selection, [dict(zip(col_names, q[0]))] if q else []) if selection else None
+            ),
+            "without_dashboard_segment": list_url(
+                {key: value for key, value in params.items() if key != "dashboard_segment"}
+            ),
         },
+        headers={"Cache-Control": "no-store"},
     )
 
 
 @router.get("/app/forderungen/details/{primary_key}", response_class=HTMLResponse)
 def forderungen_details(request: Request, primary_key: str, db: Session = Depends(get_session)):
-
+    principal = current_principal(request)
     pkey = convert_primary_key("forderungen", primary_key)
-
+    if not has_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"]):
+        context = get_forderung_summary(db, pkey["Client_DB"], pkey["Beleg_Nr"])
+        context["return_url"] = return_url_for_request(request, primary_key)
+        return templates.TemplateResponse(request, "forderungen/details/notice.html", context)
     template_context = get_template_context(request, pkey, db)
+    template_context.update(detail_navigation_context(request, primary_key))
     return templates.TemplateResponse(request, "forderungen/details/details.html", template_context)
 
 
 def get_template_context(request: Request, pkey: dict[str, str], db: Session) -> dict:
-    context = {
-        "appsmith": {
-            "URL": {
-                "queryParams": {
-                    "Client_DB": "'" + pkey["Client_DB"] + "'",
-                    "Beleg_Nr": "'" + pkey["Beleg_Nr"] + "'",
-                }
-            }
-        },
-        "BelegeFilter": {"selectedOptionValue": "D"},
-        "BenutzerSelect": {"selectedOptionValue": "winter"},
-    }
-
     template_context = {}
     for filename in [
         "auftraege_positionen",
-        "forderungen_buchungen",
-        "forderungen_kommentare",
         "forderungen_details",
         "forderungen_mahnungen",
         "versicherungen",
     ]:
-        query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", context).body.decode(
+        query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", {}).body.decode(
             "utf-8"
         )
-        template_context[filename] = db.execute(text(query)).fetchall()
-    template_context["forderung"] = {
-        "id": "12345",
-        "rechnungsnummer": "WERE123445",
-        "kunde": "Burghard",
-        "betrag": "120,00",
-        "faelligkeit": "23.12.1983",
-    }
-    template_context["files"] = get_files(pkey)
+        values = {"client_db": pkey["Client_DB"], "beleg_nr": pkey["Beleg_Nr"]}
+        template_context[filename] = db.execute(
+            text(query).execution_options(query_name=f"forderungen/details/queries/{filename}.sql"), values
+        ).fetchall()
+    for section in ("kommentare", "buchungen"):
+        template_context.update(section_context(db, pkey, template_context["forderungen_details"][0], section))
+    try:
+        template_context["files"] = get_files(pkey)
+    except OSError:
+        logger.exception("Dateiliste konnte nicht geladen werden")
+        template_context["files"] = []
+        template_context["files_error"] = "Die Dateiliste konnte nicht geladen werden."
+    template_context["upload_max_mb"] = settings.UPLOAD_MAX_FILE_SIZE_MB
+    template_context["upload_max_bytes"] = settings.UPLOAD_MAX_FILE_SIZE_MB * 1024 * 1024
     template_context["add7days"] = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
     return template_context
 
 
+@router.get("/app/forderungen/details/{primary_key}/kommentare", response_class=HTMLResponse)
+def forderungen_kommentare(
+    request: Request, primary_key: str, scope: HistoryScope = "invoice", db: Session = Depends(get_session)
+):
+    pkey = convert_primary_key("forderungen", primary_key)
+    ensure_forderung_access(db, current_principal(request), pkey["Client_DB"], pkey["Beleg_Nr"])
+    context = history_context(db, pkey, "kommentare", scope)
+    return templates.TemplateResponse(request, "forderungen/details/details_kommentare.html", context)
+
+
+@router.get("/app/forderungen/details/{primary_key}/buchungen", response_class=HTMLResponse)
+def forderungen_buchungen(
+    request: Request, primary_key: str, scope: HistoryScope = "invoice", db: Session = Depends(get_session)
+):
+    pkey = convert_primary_key("forderungen", primary_key)
+    ensure_forderung_access(db, current_principal(request), pkey["Client_DB"], pkey["Beleg_Nr"])
+    context = history_context(db, pkey, "buchungen", scope)
+    return templates.TemplateResponse(request, "forderungen/details/details_buchungen.html", context)
+
+
 @router.post("/app/forderungen/details/{primary_key}", response_class=HTMLResponse)
 async def post_forderungen_details(
     request: Request,
     primary_key: str,
     source: Annotated[str, Form()],
     redirect: Annotated[str | None, Form()] = None,
+    return_to: Annotated[str | None, Form()] = None,
+    comment_scope: Annotated[HistoryScope, Form()] = "invoice",
     db: Session = Depends(get_session),
 ):
+    principal = current_principal(request)
     pkey = convert_primary_key("forderungen", primary_key)
+    ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
 
     if source == "comments":
-        data = {
-            "Client_DB": "",
-            "Beleg_Nr": "",
-            "Timestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
-            "Benutzer_ID": "winter",
-            "Kommentar": "",
-        }
-    else:
-        data = {
-            "Client_DB": "",
-            "Beleg_Nr": "",
-            "Bearbeitet": "J",
-            "Versicherung": "N",
-            "Rechtsanwalt": "N",
-            "Reklamation": "N",
-            "Mahnen_aussetzen": "N",
-            "Selbstbeteiligung": "",
-            "Selbstbeteiligung_Betrag": "0.0",
-            "Mwst": "",
-            "Mwst_Betrag": "0.0",
-            "Wiedervorlage": "",
-            "Vers_Adresse_ID": "",
-            "Versicherung_Typ": "",
-            "Reklamation_Begruendung": "",
-            "Rechtsanwalt_Begruendung": "",
-            "Rechtsanwalt_Aktenzeichen": "",
-            "Rechtsanwalt_Stand": "",
-            "Mahnen_Begruendung": "",
-        }
+        return await submit_comment(request, pkey, db, comment_scope)
+    if source != "details":
+        raise HTTPException(status_code=400, detail="Ungültige Datenquelle")
+
+    data = {
+        "Client_DB": "",
+        "Beleg_Nr": "",
+        "Bearbeitet": "J",
+        "Versicherung": "N",
+        "Rechtsanwalt": "N",
+        "Reklamation": "N",
+        "Mahnen_aussetzen": "N",
+        "Selbstbeteiligung": "",
+        "Selbstbeteiligung_Betrag": "0.0",
+        "Mwst": "",
+        "Mwst_Betrag": "0.0",
+        "Wiedervorlage": "",
+        "Vers_Adresse_ID": "",
+        "Versicherung_Typ": "",
+        "Reklamation_Begruendung": "",
+        "Rechtsanwalt_Begruendung": "",
+        "Rechtsanwalt_Aktenzeichen": "",
+        "Rechtsanwalt_Stand": "",
+        "Mahnen_Begruendung": "",
+    }
     data.update(pkey)
 
     async with request.form() as form:
         for k, v in form.items():
-            if k in data:
+            if k in data and k not in {"Client_DB", "Beleg_Nr", "Benutzer_ID", "Timestamp"}:
                 if v == "on":
                     v = "J"
                 if re.match(r"\d+,?\d*", v):
                     v = v.replace(",", ".")
                 data[k] = v
 
+    if source not in {"comments", "details"}:
+        raise HTTPException(status_code=400, detail="Ungültige Datenquelle")
     query = templates.TemplateResponse(
         request, f"forderungen/details/queries/post/post_{source}.sql", context={"data": data}
     ).body.decode("utf-8")
-    print(query)
     for subquery in query.split(";"):
-        q = db.execute(text(subquery))
-        print(q.rowcount)
+        if subquery.strip():
+            db.execute(
+                text(subquery).execution_options(query_name=f"forderungen/details/queries/post/post_{source}.sql"), data
+            )
     db.commit()
-    template_context = get_template_context(request, pkey, db)
 
+    return_url = return_url_for_request(request, primary_key, return_to if return_to is not None else redirect)
     if redirect:
-        return RedirectResponse(url=redirect, status_code=302)
-    if source == "comments":
-        return templates.TemplateResponse(request, "base/chat_container.html", template_context)
+        if request.headers.get("HX-Request", "").lower() == "true":
+            return HTMLResponse("", headers={"HX-Redirect": return_url})
+        return RedirectResponse(url=return_url, status_code=303)
+    template_context = get_template_context(request, pkey, db)
+    template_context.update(detail_navigation_context(request, primary_key, return_url))
     return templates.TemplateResponse(request, "forderungen/details/details_formular.html", template_context)
 
 
 def convert_primary_key(area: str, primary_key: str) -> dict[str, str]:
-    if area == "forderungen":
-        pkey = ["Client_DB", "Beleg_Nr"]
-    pkey_values = primary_key.split("_")
-    return dict(zip(pkey, pkey_values))
+    if area != "forderungen" or "_" not in primary_key:
+        raise HTTPException(status_code=400, detail="Ungültiger Primärschlüssel")
+    client_db, beleg_nr = primary_key.split("_", 1)
+    if not client_db or not beleg_nr or len(client_db) > 20 or len(beleg_nr) > 100:
+        raise HTTPException(status_code=400, detail="Ungültiger Primärschlüssel")
+    return {"Client_DB": client_db, "Beleg_Nr": beleg_nr}
 
 
 @router.get("/app/forderungen/dashboard", response_class=HTMLResponse)
-def forderungen_dashboard(request: Request, db: Session = Depends(get_session)):
-    context = {"summary": False}
-    return templates.TemplateResponse(request, "forderungen/dashboard/dashboard.html", context)
-
-
-@router.get("/export/csv")
-def export_csv(db: Session = Depends(get_session)):
-    q = db.query(Forderung).all()
-    rows = []
-    for f in q:
-        rows.append(
-            {
-                "id": f.id,
-                "rechnungsnummer": f.rechnungsnummer,
-                "kunde": f.kunde.name if f.kunde else "",
-                "betrag": float(f.betrag),
-                "faelligkeit": f.faelligkeit.isoformat() if f.faelligkeit else "",
-            }
-        )
-    df = pd.DataFrame(rows)
-    buf = io.StringIO()
-    df.to_csv(buf, index=False)
-    buf.seek(0)
-    return Response(
-        content=buf.getvalue(),
-        media_type="text/csv",
-        headers={"Content-Disposition": "attachment; filename=forderungen.csv"},
-    )
-
-
-@router.get("/export/xlsx")
-def export_xlsx(db: Session = Depends(get_session)):
-    q = db.query(Forderung).all()
-    rows = []
-    for f in q:
-        rows.append(
-            {
-                "id": f.id,
-                "rechnungsnummer": f.rechnungsnummer,
-                "kunde": f.kunde.name if f.kunde else "",
-                "betrag": float(f.betrag),
-                "faelligkeit": f.faelligkeit.isoformat() if f.faelligkeit else "",
-            }
-        )
-    df = pd.DataFrame(rows)
-    buf = io.BytesIO()
-    with pd.ExcelWriter(buf, engine="openpyxl") as writer:
-        df.to_excel(writer, index=False, sheet_name="Forderungen")
-    buf.seek(0)
-    return StreamingResponse(
-        buf,
-        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        headers={"Content-Disposition": "attachment; filename=forderungen.xlsx"},
+def forderungen_dashboard(
+    request: Request,
+    db: Session = Depends(get_session),
+    page: str = "Standort",
+    metric: str = "betrag",
+    only_invoices: bool = False,
+    stack: str = "abteilung",
+):
+    principal = current_principal(request)
+    if page == "Wiedervorlage" and metric in {"betrag", "anzahl"} and stack in STACKS:
+        params = dict(page="Standort", metric=metric, stack="wiedervorlage")
+        if only_invoices:
+            params["only_invoices"] = "true"
+        return RedirectResponse("/app/forderungen/dashboard?" + urlencode(params), status_code=303)
+    if page not in DASHBOARD_VIEWS or metric not in {"betrag", "anzahl"} or stack not in STACKS:
+        raise HTTPException(422, "Ungültige Dashboardansicht")
+    context = dict(
+        summary=False,
+        dashboard_view=page,
+        dashboard_metric=metric,
+        dashboard_stack=stack,
+        dashboard_only_invoices=only_invoices,
+        dashboard=None,
+        dashboard_error=None,
     )
-
-
-@router.get("/detail/{id}/export/docx")
-def export_docx(id: int, db: Session = Depends(get_session)):
-    f = db.query(Forderung).filter(Forderung.id == id).first()
-    if not f:
-        raise HTTPException(status_code=404)
-    doc = Document()
-    doc.add_heading(f"Rechnung {f.rechnungsnummer}", level=1)
-    doc.add_paragraph(f'Kunde: {f.kunde.name if f.kunde else ""}')
-    doc.add_paragraph(f"Betrag: {float(f.betrag)}")
-    doc.add_paragraph(f"Fälligkeit: {f.faelligkeit}")
-    buf = io.BytesIO()
-    doc.save(buf)
-    buf.seek(0)
-    return StreamingResponse(
-        buf,
-        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        headers={"Content-Disposition": f"attachment; filename=rechnung_{f.rechnungsnummer}.docx"},
+    status_code = 200
+    try:
+        context["dashboard"] = build_dashboard(db, principal.username, only_invoices=only_invoices, stack=stack)
+    except Exception:
+        logger.exception("Forderungsdashboard konnte nicht geladen werden")
+        context["dashboard_error"] = "Das Dashboard konnte nicht geladen werden. Bitte erneut versuchen."
+        status_code = 503
+    return templates.TemplateResponse(
+        request,
+        "forderungen/dashboard/dashboard.html",
+        context,
+        status_code=status_code,
+        headers={"Cache-Control": "no-store"},
     )
 
 
 # TODO
 @router.get("/app/forderungen/export/{client_db}_{document_no}/")
 def export_docx2(request: Request, client_db: str, document_no: str, db: Session = Depends(get_session)):
-    context = {
-        "appsmith": {
-            "URL": {
-                "queryParams": {
-                    "Client_DB": "'" + client_db + "'",
-                    "Document_No": "'" + document_no + "'",
-                }
-            }
-        },
-    }
-    query = templates.TemplateResponse(request, "forderungen/details/queries/forderung_kopf.sql", context).body.decode(
-        "utf-8"
-    )
-    q = db.execute(text(query)).fetchone()
-
-    doc = DocxTemplate("templates\\forderungen\\docs\\Mahnung_AHR.docx")
-    filename = Path(
-        f"C:\\Projekte\\Reisacher-Fileserver\\{client_db}\\{document_no}\\Mahnung_{client_db}_{document_no}.docx"
+    principal = current_principal(request)
+    ensure_forderung_access(db, principal, client_db, document_no)
+    q = (
+        db.execute(
+            text("""SELECT TOP 1 F.*, K.Kunde_Name, K.Kunde_Adresse, K.Kunde_PLZ, K.Kunde_Ort
+               FROM dbo.Forderungen_Kopf AS F
+               LEFT JOIN dbo.Kunden AS K ON K.Client_DB = F.Client_DB AND K.Kunde_Nr = F.Kunde_Nr
+               WHERE F.Client_DB = :client_db AND F.Beleg_Nr = :beleg_nr"""),
+            {"client_db": client_db, "beleg_nr": document_no},
+        )
+        .mappings()
+        .first()
     )
+    if not q or not settings.LOCAL_STORAGE:
+        raise HTTPException(status_code=503, detail="Dokumentablage ist nicht konfiguriert")
+
+    doc = DocxTemplate("templates\\forderungen\\details\\docs\\Mahnung_AHR.docx")
+    storage_root = Path(settings.LOCAL_STORAGE).resolve()
+    filename = (storage_root / client_db / document_no / f"Mahnung_{client_db}_{document_no}.docx").resolve()
+    if storage_root not in filename.parents:
+        raise HTTPException(status_code=400, detail="Ungültiger Dokumentpfad")
     filename.parent.mkdir(parents=True, exist_ok=True)
 
     context = {
-        "Kunde_Name": q.Kunde,
-        "Kunde_Adresse": "Im Waldhof 14a",
-        "Kunde_PLZ": "61476",
-        "Kunde_Ort": "Kronberg",
+        "Kunde_Name": q["Kunde_Name"] or "",
+        "Kunde_Adresse": q["Kunde_Adresse"] or "",
+        "Kunde_PLZ": q["Kunde_PLZ"] or "",
+        "Kunde_Ort": q["Kunde_Ort"] or "",
         "Datum_heute": datetime.now().strftime("%d.%m.%Y"),
-        "Kunde_Nr": q.Kunde.split("-")[-1].strip(),
-        "Fahrzeug_Kennzeichen": "OF-RB 512",
-        "Rechnung_Nr": q.Document_No,
-        "Betrag_SB": "250,00",
-        "Betrag_USt": "380,00",
+        "Kunde_Nr": q["Kunde_Nr"] or "",
+        "Fahrzeug_Kennzeichen": q.get("Fahrzeug_Kennzeichen", "") or "",
+        "Rechnung_Nr": q["Beleg_Nr"],
+        "Betrag_SB": q.get("Selbstbeteiligung_Betrag", "") or "",
+        "Betrag_USt": q.get("Mwst_Betrag", "") or "",
     }
     doc.render(context)
     doc.save(filename)
@@ -391,21 +534,34 @@ def export_docx2(request: Request, client_db: str, document_no: str, db: Session
 
 
 @router.get("/files/")
-def get_files2(request: Request):
-    filename = get_file(request.query_params.get("name"))
+def get_files2(request: Request, db: Session = Depends(get_session)):
+    principal = current_principal(request)
+    name = request.query_params.get("name", "")
+    try:
+        pkey = file_primary_key(name)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Datei nicht gefunden")
+    ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
+    try:
+        filename = get_file(name)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Datei nicht gefunden")
     return FileResponse(filename, media_type="application/octet-stream", filename=filename.name)
 
 
-@router.get("/app/forderungen/files/{primary_key}", response_class=HTMLResponse)
+@router.get("/app/forderungen/files/{primary_key}", response_class=StreamingResponse)
 def forderungen_files(request: Request, primary_key: str, db: Session = Depends(get_session)):
+    principal = current_principal(request)
     pkey = convert_primary_key("forderungen", primary_key)
+    ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
     try:
-        filestream = get_invoice_pdf_by_document_no(client_db=pkey["Client_DB"], document_no=pkey["Beleg_Nr"])
-        # filename = "http://localhost:8093/static/assets/pdf/invoice.pdf"
-        # filestream = requests.get(filename, stream=True).raw,
-        return StreamingResponse(
-            filestream,
-            media_type="application/pdf",
-        )
-    except ValueError as e:
-        raise HTTPException(status_code=404, detail=str(e))
+        file_content = get_invoice_pdf_by_document_no(client_db=pkey["Client_DB"], document_no=pkey["Beleg_Nr"])
+        filestream = io.BytesIO(file_content)
+    except Exception:
+        logger.exception("Rechnung konnte nicht aus DocuWare geladen werden")
+        filestream = io.BytesIO(Path("static/assets/pdf/invoice.pdf").read_bytes())
+
+    return StreamingResponse(
+        filestream,
+        media_type="application/pdf",
+    )

+ 0 - 47
app/schemas.py

@@ -1,47 +0,0 @@
-from datetime import date
-from typing import Optional
-
-from pydantic import BaseModel
-
-
-class KundeOut(BaseModel):
-    id: int
-    name: str
-
-    class Config:
-        from_attributes = True
-
-
-class ZahlungOut(BaseModel):
-    id: int
-    betrag: float
-    datum: date
-
-    class Config:
-        from_attributes = True
-
-
-class BemerkungIn(BaseModel):
-    bemerkung: Optional[str]
-    wiedervorlage_datum: Optional[date]
-
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-
-class TokenData(BaseModel):
-    username: str | None = None
-
-
-class User(BaseModel):
-    username: str
-    email: str | None = None
-    hashed_password: str
-
-
-class UserInDB(User):
-    username: str
-    email: str | None = None
-    hashed_password: str

+ 0 - 35
app/users.py

@@ -1,35 +0,0 @@
-from sqlalchemy.orm import Session
-from .schemas import UserInDB
-from .db import Base
-from passlib.context import CryptContext
-from sqlalchemy import Column, Integer, String
-
-# Password hashing configuration
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-
-class UserModel(Base):
-    __tablename__ = "users"
-    id = Column(Integer, primary_key=True, index=True)
-    username = Column(String, unique=True, index=True)
-    email = Column(String, unique=True, index=True)
-    hashed_password = Column(String)
-
-
-def get_password_hash(password: str) -> str:
-    return pwd_context.hash(password)
-
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    return pwd_context.verify(plain_password, hashed_password)
-
-
-def authenticate_user(db: Session, username: str, password: str) -> UserInDB | None:
-    user = get_by_username(db, username)
-    if not user or not verify_password(password, user.hashed_password):
-        return None
-    return user
-
-
-def get_by_username(db: Session, username: str) -> UserInDB | None:
-    return db.query(UserModel).filter(UserModel.username == username).first()

+ 128 - 0
app/verursacher.py

@@ -0,0 +1,128 @@
+"""Change the manual invoice assignee independently of the workflow form."""
+import json
+import logging
+from urllib.parse import quote, urlencode
+
+from fastapi import APIRouter, Depends, Form, HTTPException, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from .db import get_session
+from .jinja_templates import templates
+from .navigation import DETAIL_PREFIX, list_return_url, valid_focus
+from .permissions import current_principal, ensure_forderung_access
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+USERS_SQL = text("""
+SELECT DISTINCT Benutzer_ID,
+       MAX(NULLIF(Name, '')) OVER (PARTITION BY Benutzer_ID) AS Name,
+       Rolle_Name
+FROM dbo.Benutzer_Rolle
+WHERE NULLIF(LTRIM(RTRIM(Benutzer_ID)), '') IS NOT NULL
+ORDER BY Name, Benutzer_ID, Rolle_Name
+""")
+STATE_SQL = text("""
+SELECT F.Client_DB, F.Beleg_Nr, F.Verursacher_Text AS Original_Verursacher_Text,
+       F.Verursacher_Benutzer_ID AS Original_Verursacher_Benutzer_ID,
+       FD.Verursacher_Benutzer_ID AS Override_Verursacher_Benutzer_ID,
+       COALESCE(B.Name, FD.Verursacher_Benutzer_ID, F.Verursacher_Text) AS Verursacher_Text
+FROM dbo.Forderungen_Kopf F
+LEFT JOIN dbo.Forderungen_Details FD ON FD.Client_DB = F.Client_DB AND FD.Beleg_Nr = F.Beleg_Nr
+LEFT JOIN (
+    SELECT Benutzer_ID, MAX(NULLIF(Name, '')) AS Name
+    FROM dbo.Benutzer_Rolle GROUP BY Benutzer_ID
+) B ON B.Benutzer_ID = FD.Verursacher_Benutzer_ID
+WHERE F.Client_DB = :Client_DB AND F.Beleg_Nr = :Beleg_Nr
+""")
+
+
+def _context(request, primary_key, db):
+    if not valid_focus(primary_key):
+        raise HTTPException(400, 'Ungültiger Primärschlüssel')
+    tenant, number = primary_key.split('_', 1)
+    pkey = {'Client_DB': tenant, 'Beleg_Nr': number}
+    ensure_forderung_access(db, current_principal(request), tenant, number)
+    state = db.execute(STATE_SQL, pkey).mappings().first()
+    if state is None:
+        raise HTTPException(404, 'Forderung nicht gefunden')
+    users = {}
+    for row in db.execute(USERS_SQL).mappings().all():
+        identity = row['Benutzer_ID']
+        user = users.setdefault(identity, {'id': identity, 'name': row['Name'] or identity, 'roles': []})
+        if row['Rolle_Name'] and row['Rolle_Name'] not in user['roles']:
+            user['roles'].append(row['Rolle_Name'])
+    users = sorted(users.values(), key=lambda user: (user['name'].casefold(), user['id']))
+    roles = sorted({role for user in users for role in user['roles']}, key=str.casefold)
+    detail = request.url.path.startswith(DETAIL_PREFIX)
+    return_url = list_return_url(request.query_params.get('return_to'), primary_key)
+    page_url = DETAIL_PREFIX + quote(primary_key, safe='') + '?' + urlencode({'return_to': return_url}) if detail else return_url
+    selected = state['Override_Verursacher_Benutzer_ID'] or state['Original_Verursacher_Benutzer_ID'] or ''
+    return dict(pkey=pkey, state=state, users=users, roles=roles, selected=selected,
+                detail=detail, primary_key=primary_key, page_url=page_url, return_url=return_url,
+                modal_url=request.url.path + '?' + urlencode({'return_to': return_url}), role_filter='', error='')
+
+
+def _render(request, context, status_code=200):
+    return templates.TemplateResponse(request, 'forderungen/verursacher/modal.html', context,
+                                      status_code=status_code, headers={'Cache-Control': 'no-store'})
+
+
+@router.get('/app/forderungen/liste/{primary_key}/verursacher', response_class=HTMLResponse)
+@router.get('/app/forderungen/details/{primary_key}/verursacher', response_class=HTMLResponse)
+def edit_verursacher(request: Request, primary_key: str, db: Session = Depends(get_session)):
+    context = _context(request, primary_key, db)
+    if request.headers.get('HX-Request', '').lower() != 'true':
+        return RedirectResponse(context['page_url'], status_code=303)
+    return _render(request, context)
+
+
+@router.post('/app/forderungen/liste/{primary_key}/verursacher', response_class=HTMLResponse)
+@router.post('/app/forderungen/details/{primary_key}/verursacher', response_class=HTMLResponse)
+def save_verursacher(request: Request, primary_key: str, action: str = Form('assign'),
+                     benutzer_id: str = Form(''), rolle: str = Form(''), db: Session = Depends(get_session)):
+    context = _context(request, primary_key, db)
+    context['selected'] = benutzer_id
+    context['role_filter'] = rolle if rolle in context['roles'] else ''
+    user = next((user for user in context['users'] if user['id'] == benutzer_id), None)
+    if action not in {'assign', 'reset'} or (action == 'assign' and user is None):
+        context['error'] = 'Bitte einen gültigen Benutzer auswählen.'
+        return _render(request, context, 422)
+    value = None if action == 'reset' else benutzer_id
+    values = dict(context['pkey'], Verursacher_Benutzer_ID=value)
+    try:
+        # Serializable key-range lock prevents concurrent creation of the same detail record.
+        existing = db.execute(text("""
+            SELECT Verursacher_Benutzer_ID FROM dbo.Forderungen_Details WITH (UPDLOCK, HOLDLOCK)
+            WHERE Client_DB = :Client_DB AND Beleg_Nr = :Beleg_Nr
+        """), context['pkey']).first()
+        if existing is None:
+            if value is not None:
+                db.execute(text("""
+                    INSERT INTO dbo.Forderungen_Details (Client_DB, Beleg_Nr, Verursacher_Benutzer_ID)
+                    VALUES (:Client_DB, :Beleg_Nr, :Verursacher_Benutzer_ID)
+                """), values)
+        else:
+            db.execute(text("""
+                UPDATE dbo.Forderungen_Details SET Verursacher_Benutzer_ID = :Verursacher_Benutzer_ID
+                WHERE Client_DB = :Client_DB AND Beleg_Nr = :Beleg_Nr
+            """), values)
+        db.commit()
+    except Exception:
+        db.rollback()
+        logger.exception('Verursacher konnte für %s nicht gespeichert werden', primary_key)
+        context['error'] = 'Der Verursacher konnte nicht gespeichert werden. Bitte erneut versuchen.'
+        return _render(request, context, 503)
+
+    if request.headers.get('HX-Request', '').lower() != 'true':
+        return RedirectResponse(context['page_url'], status_code=303)
+    if not context['detail']:
+        return HTMLResponse('', headers={'HX-Redirect': context['return_url'], 'Cache-Control': 'no-store'})
+    context['effective_name'] = context['state']['Original_Verursacher_Text'] if value is None else user['name']
+    context['oob'] = True
+    return templates.TemplateResponse(
+        request, 'forderungen/verursacher/detail_field.html', context,
+        headers={'HX-Trigger-After-Swap': json.dumps({'gc:verursacherSaved': {}}), 'Cache-Control': 'no-store'},
+    )

+ 123 - 0
app/wiedervorlage.py

@@ -0,0 +1,123 @@
+"""List follow-up editing, with its audit comment committed atomically."""
+from datetime import date, datetime, timedelta
+import logging
+import re
+from urllib.parse import urlencode
+from zoneinfo import ZoneInfo
+
+from fastapi import APIRouter, Depends, Form, HTTPException, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from .db import get_session
+from .jinja_templates import templates
+from .navigation import list_return_url, valid_focus
+from .permissions import current_principal, ensure_forderung_access
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+BERLIN = ZoneInfo('Europe/Berlin')
+
+
+def _now_berlin():
+    return datetime.now(BERLIN)
+
+
+def _as_date(value):
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, date):
+        return value
+    return date.fromisoformat(str(value)[:10])
+
+
+def _context(request, primary_key, db):
+    if not valid_focus(primary_key):
+        raise HTTPException(400, 'Ungültiger Primärschlüssel')
+    tenant, number = primary_key.split('_', 1)
+    pkey = {'Client_DB': tenant, 'Beleg_Nr': number}
+    ensure_forderung_access(db, current_principal(request), tenant, number)
+    state = db.execute(text("""
+        SELECT F.Beleg_Nr, F.Beleg_Faellig_Datum,
+               COALESCE(FD.Wiedervorlage, F.Beleg_Faellig_Datum) AS Wiedervorlage
+        FROM dbo.Forderungen_Kopf F
+        LEFT JOIN dbo.Forderungen_Details FD ON FD.Client_DB = F.Client_DB AND FD.Beleg_Nr = F.Beleg_Nr
+        WHERE F.Client_DB = :Client_DB AND F.Beleg_Nr = :Beleg_Nr
+    """), pkey).mappings().first()
+    if state is None:
+        raise HTTPException(404, 'Forderung nicht gefunden')
+    today = _now_berlin().date()
+    current = _as_date(state['Wiedervorlage'])
+    return_url = list_return_url(request.query_params.get('return_to'), primary_key)
+    return dict(pkey=pkey, state=state, today=today.isoformat(),
+                next_week=(today + timedelta(days=7)).isoformat(),
+                selected=current.isoformat() if current else '', error='',
+                return_url=return_url,
+                modal_url=request.url.path + '?' + urlencode({'return_to': return_url}))
+
+
+def _render(request, context, status_code=200):
+    return templates.TemplateResponse(request, 'forderungen/wiedervorlage/modal.html', context,
+                                      status_code=status_code, headers={'Cache-Control': 'no-store'})
+
+
+@router.get('/app/forderungen/liste/{primary_key}/wiedervorlage', response_class=HTMLResponse)
+def edit_wiedervorlage(request: Request, primary_key: str, db: Session = Depends(get_session)):
+    context = _context(request, primary_key, db)
+    if request.headers.get('HX-Request', '').lower() != 'true':
+        return RedirectResponse(context['return_url'], status_code=303)
+    return _render(request, context)
+
+
+@router.post('/app/forderungen/liste/{primary_key}/wiedervorlage', response_class=HTMLResponse)
+def save_wiedervorlage(request: Request, primary_key: str, wiedervorlage: str = Form(''),
+                      db: Session = Depends(get_session)):
+    context = _context(request, primary_key, db)
+    context['selected'] = wiedervorlage
+    try:
+        if not re.fullmatch(r'\d{4}-\d{2}-\d{2}', wiedervorlage):
+            raise ValueError
+        selected = date.fromisoformat(wiedervorlage)
+    except ValueError:
+        context['error'] = 'Bitte ein gültiges Wiedervorlagedatum auswählen.'
+        return _render(request, context, 422)
+
+    try:
+        existing = db.execute(text("""
+            SELECT Wiedervorlage FROM dbo.Forderungen_Details WITH (UPDLOCK, HOLDLOCK)
+            WHERE Client_DB = :Client_DB AND Beleg_Nr = :Beleg_Nr
+        """), context['pkey']).mappings().first()
+        current = _as_date(existing['Wiedervorlage'] if existing and existing['Wiedervorlage'] is not None
+                           else context['state']['Beleg_Faellig_Datum'])
+        # Repeated submissions of an unchanged date must not duplicate the audit comment.
+        if selected != current:
+            values = dict(context['pkey'], Wiedervorlage=selected)
+            if existing is None:
+                db.execute(text("""
+                    INSERT INTO dbo.Forderungen_Details (Client_DB, Beleg_Nr, Wiedervorlage)
+                    VALUES (:Client_DB, :Beleg_Nr, :Wiedervorlage)
+                """), values)
+            else:
+                db.execute(text("""
+                    UPDATE dbo.Forderungen_Details SET Wiedervorlage = :Wiedervorlage
+                    WHERE Client_DB = :Client_DB AND Beleg_Nr = :Beleg_Nr
+                """), values)
+            db.execute(text("""
+                INSERT INTO dbo.Forderungen_Kommentar (Client_DB, Beleg_Nr, [Timestamp], Benutzer_ID, Kommentar)
+                VALUES (:Client_DB, :Beleg_Nr, :Timestamp, :Benutzer_ID, :Kommentar)
+            """), dict(context['pkey'], Timestamp=_now_berlin().replace(tzinfo=None),
+                      Benutzer_ID=current_principal(request).username,
+                      Kommentar=f'WV auf {selected.strftime("%d.%m.%Y")} angepasst'))
+        db.commit()
+    except Exception:
+        db.rollback()
+        logger.exception('Wiedervorlage konnte für %s nicht gespeichert werden', primary_key)
+        context['error'] = 'Datum und Kommentar konnten nicht gespeichert werden. Bitte erneut versuchen.'
+        return _render(request, context, 503)
+
+    if request.headers.get('HX-Request', '').lower() == 'true':
+        return HTMLResponse('', headers={'HX-Redirect': context['return_url'], 'Cache-Control': 'no-store'})
+    return RedirectResponse(context['return_url'], status_code=303)

BIN
dev.db


+ 9 - 8
filter_export.py

@@ -1,10 +1,15 @@
 import csv
+import logging
 from dataclasses import asdict
 
-from app.routes import FilterConfig, forderung_filter_config
+from app.query_filter import import_filter_config
+from app.logging_setup import run_cli
+
+logger = logging.getLogger(__name__)
 
 
 def export_filter_config():
+    forderung_filter_config = import_filter_config('forderungen')
     with open("filter_config.csv", "w", newline="", encoding="latin-1") as csvfile:
         writer = csv.DictWriter(csvfile, fieldnames=asdict(forderung_filter_config[0]).keys(), delimiter=";")
         writer.writeheader()
@@ -15,13 +20,9 @@ def export_filter_config():
 
 
 def import_filter_config2():
-    with open("forderungen\\liste\\config\\liste_filter.csv", "r", newline="", encoding="latin-1") as csvfile:
-        reader = csv.DictReader(csvfile, delimiter=";")
-        for row in reader:
-            # Convert the row dictionary to a FilterConfig object
-            config = FilterConfig.from_dict(*row.values())
-            print(config)
+    configs = import_filter_config('forderungen')
+    logger.info('Filterkonfiguration geladen', extra={'event': 'filter_config_loaded', 'count': len(configs)})
 
 
 if __name__ == "__main__":
-    import_filter_config2()
+    run_cli(import_filter_config2)

+ 60 - 0
migrations/001_authentication.sql

@@ -0,0 +1,60 @@
+SET XACT_ABORT ON;
+BEGIN TRANSACTION;
+
+IF COL_LENGTH('dbo.Benutzer_Rechte', 'Abteilung') IS NULL
+BEGIN
+    DECLARE @type nvarchar(128), @length smallint, @collation sysname, @sql nvarchar(max);
+    SELECT @type = TYPE_NAME(system_type_id), @length = max_length, @collation = collation_name
+    FROM sys.columns
+    WHERE object_id = OBJECT_ID('dbo.Forderungen_Kopf') AND name = 'Abteilung';
+
+    IF @type IS NULL
+        THROW 50000, 'Forderungen_Kopf.Abteilung wurde nicht gefunden.', 1;
+
+    IF @type NOT IN ('varchar', 'nvarchar', 'char', 'nchar')
+        THROW 50001, 'Forderungen_Kopf.Abteilung hat einen unerwarteten Datentyp.', 1;
+
+    SET @sql = N'ALTER TABLE dbo.Benutzer_Rechte ADD Abteilung ' + QUOTENAME(@type)
+        + N'(' + CASE WHEN @length = -1 THEN N'MAX'
+                     WHEN @type IN ('nvarchar', 'nchar') THEN CONVERT(nvarchar(10), @length / 2)
+                     ELSE CONVERT(nvarchar(10), @length) END + N')'
+        + CASE WHEN @collation IS NOT NULL THEN N' COLLATE ' + QUOTENAME(@collation) ELSE N'' END
+        + N' NULL;';
+    EXEC sys.sp_executesql @sql;
+END;
+
+IF OBJECT_ID('dbo.Rollen', 'U') IS NULL
+BEGIN
+    CREATE TABLE dbo.Rollen
+    (
+        Rolle nvarchar(50) NOT NULL CONSTRAINT PK_Rollen PRIMARY KEY,
+        Prioritaet int NOT NULL,
+        Aktiv bit NOT NULL CONSTRAINT DF_Rollen_Aktiv DEFAULT (1)
+    );
+END;
+
+MERGE dbo.Rollen AS target
+USING (VALUES
+    (N'Buchhaltung', 400, 1),
+    (N'Standortleitung', 300, 1),
+    (N'Abteilungsleitung', 200, 1),
+    (N'Mitarbeiter', 100, 1)
+) AS source (Rolle, Prioritaet, Aktiv)
+ON target.Rolle = source.Rolle
+WHEN MATCHED THEN UPDATE SET Prioritaet = source.Prioritaet, Aktiv = source.Aktiv
+WHEN NOT MATCHED THEN INSERT (Rolle, Prioritaet, Aktiv)
+VALUES (source.Rolle, source.Prioritaet, source.Aktiv);
+
+IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE object_id = OBJECT_ID('dbo.Benutzer_Rechte') AND name = 'IX_Benutzer_Rechte_Scope')
+BEGIN
+    CREATE INDEX IX_Benutzer_Rechte_Scope
+        ON dbo.Benutzer_Rechte (Benutzer_ID, Hauptbetrieb_ID, Standort_ID, Abteilung)
+        INCLUDE (Rolle);
+END;
+
+-- Leere Benutzer_IDs bleiben zur manuellen Prüfung erhalten, werden von der Anwendung aber nicht mehr ausgewertet.
+SELECT COUNT(*) AS Zu_pruefende_leere_Berechtigungen
+FROM dbo.Benutzer_Rechte
+WHERE NULLIF(LTRIM(RTRIM(Benutzer_ID)), '') IS NULL;
+
+COMMIT TRANSACTION;

+ 2 - 0
pyproject.toml

@@ -18,10 +18,12 @@ dependencies = [
 	"pyodbc>=4.0",
 	"aiofiles>=23.1",
 	"python-dotenv>=1.2.1",
+	"pydantic-settings>=2.0",
 	"docxtpl>=0.20.2",
 	"imap-tools>=1.12.1",
 	"passlib>=1.7.4",
 	"python-jose>=3.5.0",
 	"requests>=2.34.2",
 	"docuware-client>=0.9.0",
+	"concurrent-log-handler>=0.9.31,<1",
 ]

+ 24 - 0
server.py

@@ -0,0 +1,24 @@
+import argparse
+
+import uvicorn
+
+from app.logging_setup import run_cli
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--no-reload", action="store_true", help="Run without the development reloader")
+    args = parser.parse_args()
+    uvicorn.run(
+        "app.main:app",
+        host="127.0.0.1",
+        port=8094,
+        reload=not args.no_reload,
+        proxy_headers=False,
+        log_config=None,
+        access_log=False,
+    )
+
+
+if __name__ == "__main__":
+    run_cli(main)

+ 99 - 0
static/assets/css/app.css

@@ -0,0 +1,99 @@
+/* Shared application theme and navigation. CoreUI remains the component base. */
+:root {
+  --gc-header-height: 64px;
+  --gc-context-height: 130px;
+  --gc-brand-header: #c3ccd4;
+  --gc-brand-section: #cdd4da;
+  --gc-brand-border: #b1bcc7;
+  --gc-brand-action: #72889b;
+  --gc-brand-ink: #182630;
+  --gc-brand-mark: #b30808;
+}
+body {
+  --cui-body-font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --cui-heading-font-family: var(--cui-body-font-family);
+  font-family: var(--cui-body-font-family);
+}
+.gc-app-header { font-family: var(--cui-body-font-family); font-size: 1.125rem; }
+.gc-app-header.header {
+  position: sticky;
+  top: 0;
+  z-index: 1030;
+  padding: 0;
+  margin: 0;
+  background: var(--gc-brand-header);
+  border-bottom: 1px solid var(--gc-brand-border);
+  filter: drop-shadow(0 2px 4px #1826300a);
+}
+/* Extend only the background, keeping navigation aligned with the content. */
+.gc-app-header.header::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  background: var(--gc-brand-header);
+  box-shadow: 0 0 0 100vmax var(--gc-brand-header);
+  clip-path: inset(0 -100vmax);
+  pointer-events: none;
+}
+.gc-app-header.header::after {
+  content: "";
+  position: absolute;
+  inset: auto 0 -1px;
+  height: 1px;
+  background: var(--gc-brand-border);
+  box-shadow: 0 0 0 100vmax var(--gc-brand-border);
+  clip-path: inset(0 -100vmax);
+  pointer-events: none;
+}
+.gc-app-header .gc-header-inner {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: .4rem 1rem;
+  min-height: 64px;
+  padding: .65rem 1.25rem;
+}
+.gc-header-brand { flex: 0 1 180px; min-width: 0; }
+.gc-header-brand img { display: block; width: 100%; max-width: 180px; height: auto; }
+.gc-app-header .header-nav { flex-wrap: wrap; gap: .25rem; }
+.gc-app-header .nav-link { font-size: inherit; color: var(--gc-brand-ink); border-radius: 6px; }
+.gc-app-header .nav-link:hover { background: #ffffff70; }
+.gc-header-account { flex-wrap: wrap; min-width: 0; }
+.gc-header-account span { overflow-wrap: anywhere; }
+.gc-section-title { margin: 0; padding: .8rem 1rem; background: var(--gc-brand-section); border-radius: 9px 9px 0 0; font-size: 1.125rem; font-weight: 700; line-height: 1.5; display: flex; align-items: center; gap: .6rem; font-family: inherit; }
+.gc-section-description { padding: .75rem 1rem 0; margin: 0; font-size: 1.0625rem; color: #52616f; }
+.gc-document-badge { display: inline-flex; justify-content: center; width: 3.25rem; padding: .15rem .5rem; border: 1px solid transparent; border-radius: 5px; font-size: 0.9375rem; font-weight: 700; white-space: nowrap; color: #000; }
+.gc-document-badge--M1 { background: #ffe97e; border-color: #c8af45; }
+.gc-document-badge--M2 { background: #f7d8bf; border-color: #e98751; }
+.gc-document-badge--M3 { background: #f5dddd; border-color: #b30808; }
+.gc-section-title .icon { flex-shrink: 0; width: 1.25rem; height: 1.25rem; font-size: 1.25rem; vertical-align: -.1em; }
+.gc-assignee-value { display: flex; align-items: flex-start; gap: .5rem; }
+.gc-assignee-value > :first-child { min-width: 0; overflow-wrap: anywhere; }
+.gc-assignee-value .gc-verursacher-edit, .gc-list-page .gc-email-btn { flex-shrink: 0; display: inline-flex; align-items: center; justify-content: center; padding: .25rem; width: 30px; height: 30px; color: #354f63; background: #fff; border: 1px solid #72889b; border-radius: 6px; }
+.gc-editor-modal { --cui-modal-width: 560px; font-size: 1.0625rem; }
+.gc-editor-modal .modal-header { background: var(--gc-brand-action); color: #fff; }
+.gc-editor-modal .modal-header .btn-close { filter: invert(1) grayscale(1) brightness(2); }
+.gc-editor-modal :is(.form-select, .form-control, .btn) { font-size: inherit; }
+.gc-editor-modal .btn-primary { --cui-btn-bg: #72889b; --cui-btn-border-color: #72889b; --cui-btn-color: #101b24; --cui-btn-hover-bg: #b1bcc7; --cui-btn-hover-border-color: #72889b; --cui-btn-hover-color: #101b24; --cui-btn-active-bg: #b1bcc7; --cui-btn-active-border-color: #72889b; --cui-btn-active-color: #101b24; --cui-btn-disabled-bg: #72889b; --cui-btn-disabled-border-color: #72889b; --cui-btn-disabled-color: #101b24; }
+.gc-editor-modal :is(.btn-link, .btn-outline-secondary) { --cui-btn-color: #354f63; }
+.gc-date-suggestions { display: flex; flex-wrap: wrap; gap: .5rem; margin-top: .75rem; }
+.gc-date-status { margin: .75rem 0 0; }
+.gc-date-status:empty { display: none; }
+.gc-assignee-original { color: #52616f; }
+.gc-assignee-error { color: #b30808; }
+.gc-assignee-status { margin: .75rem 0 0; }
+.gc-assignee-status:empty { display: none; }
+
+html, body { min-height: 100%; background: #f4f6fb; color: #111827; }
+body { overflow-y: auto; }
+.gc-page { flex: 1; width: 100%; max-width: 1840px; margin: 0 auto; padding: 1.25rem; display: flex; flex-direction: column; gap: 1rem; min-height: calc(100vh - 72px); }
+.gc-card { background: #fff; border: 1px solid #dce2e7; border-radius: 10px; box-shadow: 0 2px 6px #18263004; }
+:is(.gc-detail-page, .gc-list-page, .gc-list-summary) :is(a, button, input, select, summary, [tabindex]):focus-visible,
+.gc-app-header :is(a, button):focus-visible { outline: 3px solid #354f63; outline-offset: 3px; }
+@media (max-width: 575.98px) {
+  .gc-app-header .gc-header-inner { padding: .5rem .75rem; gap: .25rem .65rem; }
+  .gc-header-brand { flex-basis: 140px; }
+  .gc-app-header .gc-header-tools { width: 100%; margin-left: 0 !important; }
+  .gc-header-account { flex: 1; justify-content: flex-end; font-size: 1rem; }
+}

+ 54 - 0
static/assets/css/dashboard.css

@@ -0,0 +1,54 @@
+/* Authorized Forderungen overview; isolated from list and detail layouts. */
+body:has(.gc-dashboard-page) { max-width: 1840px; }
+.gc-dashboard-page { font-size: 1.0625rem; }
+.gc-dashboard-page h1 { margin: 0; font-size: 1.75rem; }
+.gc-dashboard-heading { display: flex; justify-content: space-between; align-items: baseline; flex-wrap: wrap; gap: .5rem; scroll-margin-top: calc(var(--gc-header-height) + 1rem); }
+.gc-dashboard-heading p { margin: 0; color: #52616f; }
+.gc-dashboard-scope label { display: inline-flex; align-items: center; gap: .5rem; cursor: pointer; }
+.gc-dashboard-scope input[type=checkbox] { width: 1.1rem; height: 1.1rem; accent-color: #72889b; }
+.gc-dashboard-kpis { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; }
+.gc-dashboard-kpi { padding: 1.25rem; display: flex; flex-direction: column; gap: .3rem; border-top: 4px solid #72889b; }
+.gc-dashboard-kpi strong { font-size: clamp(1.5rem, 2vw, 2rem); font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
+.gc-dashboard-kpi span { color: #52616f; }
+.gc-dashboard-tabs { display: flex; flex-wrap: wrap; gap: .5rem; padding: 1rem; border-bottom: 1px solid #dce2e7; }
+.gc-dashboard-tabs a, .gc-dashboard-metrics button { padding: .5rem .75rem; border: 1px solid #b1bcc7; border-radius: 6px; color: #354f63; background: #fff; text-decoration: none; }
+.gc-dashboard-tabs a[aria-current], .gc-dashboard-metrics button[aria-pressed=true] { color: #101b24; background: #c3ccd4; border-color: #72889b; font-weight: 600; }
+.gc-dashboard-controls { padding: 1rem; display: flex; flex-wrap: wrap; justify-content: space-between; align-items: flex-start; gap: 1rem; }
+.gc-dashboard-control-label { display: block; margin-bottom: .3rem; }
+.gc-dashboard-metric-options { display: flex; align-items: center; flex-wrap: wrap; gap: .75rem; }
+.gc-dashboard-controls .gc-dashboard-scope label { display: inline-flex; margin: 0; }
+.gc-dashboard-controls label { display: block; margin-bottom: .3rem; }
+.gc-dashboard-controls :is(input, select) { font-size: inherit; width: min(100%, 22rem); }
+.gc-dashboard-metrics { display: flex; flex-wrap: wrap; gap: .5rem; }
+.gc-dashboard-description, .gc-dashboard-status { padding: 0 1rem; margin: .5rem 0; color: #52616f; }
+.gc-dashboard-legend { display: flex; flex-wrap: wrap; gap: .5rem 1.25rem; list-style: none; margin: .5rem 0 1rem; padding: 0 1rem; }
+.gc-dashboard-legend li { display: inline-flex; align-items: center; gap: .4rem; overflow-wrap: anywhere; }
+.gc-dashboard-swatch { width: 1rem; height: 1rem; flex-shrink: 0; border: 1px solid #72889b; border-radius: 3px; }
+.gc-dashboard-chart { position: relative; margin: 0 1rem; min-width: 0; }
+.gc-dashboard-chart canvas { max-width: 100%; }
+.gc-dashboard-chart-error, .gc-dashboard-error { padding: 1rem; }
+.gc-dashboard-pagination { display: flex; align-items: center; justify-content: center; flex-wrap: wrap; gap: .75rem; padding: 1rem; }
+.gc-dashboard-page .btn { font-size: inherit; }
+.gc-dashboard-table { border-top: 1px solid #dce2e7; }
+.gc-dashboard-table summary { padding: 1rem; cursor: pointer; font-weight: 600; }
+.gc-dashboard-table-scroll { overflow-x: auto; }
+.gc-dashboard-table .table { margin: 0; min-width: 620px; }
+.gc-dashboard-table :is(th, td) { padding: .7rem 1rem; vertical-align: top; }
+.gc-dashboard-table thead th { background: #edf2f5; color: #182630; }
+.gc-dashboard-table thead { position: static; }
+.gc-dashboard-table th { font-size: inherit; }
+.gc-dashboard-table :is(th, td):nth-child(2), .gc-dashboard-table :is(th, td):nth-child(3) { text-align: right; white-space: nowrap; font-variant-numeric: tabular-nums; }
+.gc-dashboard-table .gc-dashboard-group-row th { background: #f4f6f8; font-weight: 700; }
+.gc-dashboard-table td:first-child { padding-left: 2rem; }
+.gc-dashboard-page a { color: #354f63; }
+.gc-dashboard-popover { position: fixed; z-index: 1040; width: min(26rem, calc(100vw - 2rem)); padding: 1rem; background: #fff; border: 1px solid #72889b; border-radius: 9px; box-shadow: 0 4px 20px #18263033; max-height: calc(100dvh - 2rem); overflow-y: auto; }
+.gc-dashboard-popover h3 { font-size: 1.125rem; padding-right: 2rem; overflow-wrap: anywhere; }
+.gc-dashboard-popover p { margin: .5rem 0; }
+.gc-dashboard-popover a { display: inline-block; margin-top: .5rem; padding: .5rem .75rem; border-radius: 6px; border: 1px solid #72889b; background: #edf2f5; color: #354f63; }
+.gc-dashboard-popover button { position: absolute; top: .5rem; right: .5rem; background: #fff; border: 0; font-size: 1.5rem; }
+.gc-dashboard-page :is(button, a, input, summary, [tabindex]):focus-visible { outline: 3px solid #354f63; outline-offset: 3px; }
+@media (max-width: 575.98px) {
+  .gc-dashboard-kpis { grid-template-columns: 1fr; }
+  .gc-dashboard-controls > div { width: 100%; }
+  .gc-dashboard-chart { margin: 0 .25rem; }
+}

+ 168 - 0
static/assets/css/details.css

@@ -0,0 +1,168 @@
+/* Invoice detail page. Shared theme rules live in app.css. */
+.gc-page.gc-detail-page {
+  --primary: #526b7e;
+  --primary-light: #72889b;
+  --text-light: #52616f;
+  --border: #dce2e7;
+  --cui-primary: #72889b;
+  font-size: 1.0625rem;
+  width: 100%;
+  padding: 0 0 2rem;
+  gap: 1.25rem;
+  overflow: visible;
+  color: var(--gc-brand-ink);
+}
+body:has(.gc-detail-page) { max-width: 1840px; }
+.gc-detail-page *, .gc-app-header * { min-width: 0; }
+.gc-case-context {
+  position: sticky;
+  top: var(--gc-header-height);
+  z-index: 1020;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: .75rem 1.5rem;
+  padding: 1rem 1.25rem;
+  background: #f4f6f8;
+  border-bottom: 1px solid var(--gc-brand-border);
+}
+.gc-context-heading { flex: 1 1 24rem; }
+.gc-context-heading h1 { margin: .25rem 0; font-size: clamp(1.325rem, 1.6vw, 1.75rem); line-height: 1.4; font-weight: 700; overflow-wrap: anywhere; }
+.gc-context-heading p { margin: 0; font-size: 1.0625rem; }
+.gc-context-heading p span { color: #52616f; }
+.gc-detail-page .gc-back-link { padding: 0; font-size: 1rem; color: #3c5263; text-decoration: none; }
+.gc-context-metrics { display: flex; gap: .65rem; flex-wrap: wrap; }
+.gc-metric { display: flex; flex-direction: column; gap: .15rem; padding: .6rem .85rem; border-radius: 8px; }
+.gc-metric span { font-size: 1rem; }
+.gc-metric strong { font-size: 1.275rem; font-variant-numeric: tabular-nums; white-space: nowrap; }
+.gc-metric-balance { background: #c7dee7; }
+.gc-metric-level { background: #ffe97e; }
+.gc-metric-clear { background: #b6cb9b; }
+.gc-case-grid { display: grid; grid-template-columns: minmax(0, 3fr) minmax(0, 5fr) minmax(0, 4fr); gap: 1.25rem; align-items: start; padding: 0 1.25rem; }
+.gc-case-data, .gc-case-conversation, .gc-case-actions { display: flex; flex-direction: column; gap: 1rem; }
+.gc-detail-card, .gc-detail-page .chat-container { background: #fff; border: 1px solid #dce2e7; border-radius: 10px; box-shadow: 0 2px 6px #18263004; }
+.gc-detail-page :is(#comments-title, #actions-title) { background: var(--gc-brand-action); color: #fff; }
+.gc-data-fields { margin: 0; padding: .4rem 1rem; }
+.gc-data-field { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.2fr); gap: .65rem; padding: .5rem 0; border-bottom: 1px solid #edf0f2; font-size: 1.0625rem; line-height: 1.5; }
+.gc-data-field:last-child { border-bottom: 0; }
+.gc-data-field dt { color: #52616f; font-weight: 500; overflow-wrap: anywhere; }
+.gc-data-field dd { margin: 0; font-weight: 600; overflow-wrap: anywhere; }
+.gc-data-field a { color: #354f63; }
+.gc-data-field.gc-field-money dd { font-variant-numeric: tabular-nums; }
+.gc-field-total dd, .gc-field-age dd { justify-self: start; align-self: start; padding: 0 .3rem; border-radius: 3px; }
+.gc-field-total dd { background: #d3d3d3; }
+.gc-field-age dd { background: #e98751; }
+.gc-data-more { border-top: 1px solid #edf0f2; }
+.gc-data-more summary { cursor: pointer; padding: .65rem 1rem; font-size: 1rem; font-weight: 600; color: #354f63; }
+.gc-data-more[open] summary { background: #f4f6f8; }
+.gc-detail-page .btn { white-space: normal !important; border-radius: 6px; font-size: 1.0625rem; padding: .5rem .75rem; }
+/* Dark text on the exact corporate action color meets text contrast requirements. */
+.gc-detail-page .btn-primary { --cui-btn-bg: #72889b; --cui-btn-border-color: #72889b; --cui-btn-color: #101b24; --cui-btn-hover-bg: #c3ccd4; --cui-btn-hover-color: #101b24; --cui-btn-hover-border-color: #72889b; --cui-btn-active-bg: #b1bcc7; --cui-btn-active-color: #101b24; }
+.gc-detail-page .btn-outline-secondary { --cui-btn-color: #354f63; --cui-btn-border-color: #b1bcc7; --cui-btn-hover-bg: #cdd4da; --cui-btn-hover-color: #182630; --cui-btn-hover-border-color: #72889b; }
+.gc-detail-page .btn-link { color: #354f63; }
+.gc-detail-page .gc-workflow-form { margin: 0; padding: 1rem; --cui-gutter-x: 0; --cui-gutter-y: .75rem; }
+.gc-workflow-form > .col-12 { padding: 0; }
+.gc-workflow-form .form-check { padding: .65rem .75rem .65rem 2.25rem; border-radius: 6px; background: #f4f6f8; }
+.gc-workflow-form .form-check-input:checked { background-color: #526b7e; border-color: #526b7e; }
+.gc-workflow-form .form-check-label { font-size: 1.0625rem; }
+.gc-workflow-form .card-body { padding: .85rem; background: #fafbfc; border-color: #dce2e7; box-shadow: none; }
+.gc-workflow-form .card-body .row, .gc-workflow-form .gc-follow-up .row { display: flex; flex-wrap: wrap; gap: .5rem; margin: 0 0 .85rem; }
+.gc-workflow-form .row > .col-form-label { flex: 0 0 100%; padding: 0; font-size: 1rem; color: #52616f; }
+.gc-workflow-form .row > div { flex: 1 1 7rem; padding: 0; }
+.gc-workflow-form .card-body > .col-3 { width: auto; }
+.gc-workflow-form :is(.form-control, .form-select) { width: 100%; font-size: 1.0625rem; min-height: 38px; border-color: #b1bcc7; }
+.gc-detail-page input[type="date"]::-webkit-datetime-edit-year-field,
+.gc-detail-page input[type="date"]::-webkit-datetime-edit-month-field,
+.gc-detail-page input[type="date"]::-webkit-datetime-edit-day-field,
+.gc-detail-page input[type="date"]::-webkit-datetime-edit-text { color: var(--gc-brand-ink); }
+.gc-workflow-form .form-control:focus, .gc-workflow-form .form-select:focus { border-color: #526b7e; box-shadow: 0 0 0 3px #72889b33; }
+.gc-workflow-form .gc-form-actions { display: flex; flex-wrap: wrap; gap: .5rem; border-top: 1px solid #dce2e7; padding-top: 1rem; }
+.gc-workflow-form .gc-follow-up { border-top: 1px solid #dce2e7; padding-top: 1rem; }
+.gc-detail-page .chat-container { height: clamp(32rem, calc(100dvh - var(--gc-header-height) - var(--gc-context-height) - 2rem), 58rem); }
+.gc-detail-page .chat-container > .gc-section-title { flex: 0 0 auto; }
+.gc-detail-page .chat-container > .gc-section-description { flex: 0 0 auto; padding-bottom: .75rem; overflow-wrap: anywhere; }
+.gc-detail-page .chat-content { padding: 1rem; min-height: 0; gap: 1rem; }
+.gc-detail-page .chat-container .message { max-width: 92%; flex-shrink: 0; }
+.gc-detail-page .chat-container .message-header { flex-wrap: wrap; gap: .3rem .5rem; }
+.gc-detail-page .chat-container .message-bubble {
+  padding: .65rem .85rem;
+  border-radius: 10px;
+  overflow-wrap: anywhere;
+  font-size: 1.0625rem;
+  line-height: 1.55;
+  color: #182630;
+  background: #f3f4f6;
+  background: color-mix(in srgb, var(--gc-role-accent, #72889b) 7%, #f3f4f6);
+  border-inline-start: 3px solid color-mix(in srgb, var(--gc-role-accent, #72889b) 45%, #dce2e7);
+}
+.gc-detail-page .chat-container .avatar { width: 32px; height: 32px; flex: 0 0 32px; border-radius: 7px; }
+.gc-detail-page .chat-container .sender-name { font-size: 1rem; }
+.gc-detail-page .chat-container .timestamp, .gc-detail-page .comment-invoice { font-size: 0.9375rem; }
+.gc-detail-page .chat-container .message-input { font-size: 1.0625rem; }
+.gc-detail-page .chat-container .FIBU { --gc-role-accent: #dc3545; }
+.gc-detail-page .chat-container .GSL { --gc-role-accent: #6e131c; }
+.gc-detail-page .chat-container .GWL { --gc-role-accent: #fd7e14; }
+.gc-detail-page .chat-container .ZD { --gc-role-accent: #6f42c1; }
+.gc-detail-page .chat-container .ALV { --gc-role-accent: #0c408f; }
+.gc-detail-page .chat-container .NAGA { --gc-role-accent: #0d6efd; }
+.gc-detail-page .chat-container .Serviceleiter { --gc-role-accent: #198754; }
+.gc-detail-page .chat-container .SC { --gc-role-accent: #20c997; }
+.gc-detail-page .chat-container .TUZ { --gc-role-accent: #5b6067; }
+.gc-detail-page .chat-container .input-area { padding: .85rem 1rem; flex: 0 0 auto; }
+.gc-detail-page .chat-container .toolbar { margin: 0; }
+.gc-detail-page #comment-form { display: flex; align-items: center; gap: .5rem; }
+.gc-detail-page .chat-container .message-input { min-width: 0; width: 100%; height: 42px; padding: .6rem .75rem; }
+.gc-detail-page .chat-container .message-input:focus { border-color: #526b7e; box-shadow: 0 0 0 3px #72889b33; }
+.gc-detail-page .history-tabs { padding: .25rem .5rem 0; gap: 0; }
+.gc-detail-page .history-tab { font-size: 1rem; padding: .65rem .5rem; white-space: normal; }
+.gc-detail-page .history-tab.active { color: #354f63; border-color: #526b7e; background: #edf2f5; }
+.gc-detail-page .gc-table-scroll { overflow-x: auto; max-width: 100%; }
+.gc-detail-page .table { margin: 0; font-size: 1.0625rem; }
+.gc-detail-page .table :is(th, td) { padding: .6rem .8rem; vertical-align: top; }
+.gc-detail-page .table th { background: #eef1f4; font-size: 1rem; }
+.gc-detail-page .table thead { position: static; }
+.gc-detail-page .table td { overflow-wrap: anywhere; }
+.gc-detail-page .table .text-end { white-space: nowrap; font-variant-numeric: tabular-nums; }
+.gc-case-bookings { margin: 0 1.25rem; }
+.gc-detail-page #bookings-history > p { margin: .75rem 1rem; }
+.gc-detail-page [role="status"] { color: #52616f; }
+/* Keep booking text black, including reminders; only the type badge is colored. */
+.gc-detail-page #bookings-history { padding: .75rem 1rem 1rem; }
+.gc-detail-page #bookings-history .history-tabs { padding-left: 0; padding-right: 0; margin-bottom: .75rem; }
+.gc-detail-page #bookings-history .table { --cui-table-color: #000; --cui-table-striped-color: #000; }
+.gc-detail-page #bookings-history .table td { color: #000; }
+.gc-detail-page .gc-files-table { --cui-table-bg: #fff; }
+.gc-detail-page .gc-files-table :is(th, td) { background: #fff; box-shadow: none; }
+@media (max-width: 1199.98px) {
+  .gc-case-grid { grid-template-columns: minmax(0, 1fr); }
+  .gc-detail-page .chat-container { height: 38rem; }
+}
+@media (max-width: 575.98px) {
+  .gc-case-context { padding: .65rem .75rem; gap: .5rem; }
+  .gc-context-heading { flex-basis: 100%; }
+  .gc-context-heading h1 { font-size: 1.25rem; }
+  .gc-context-metrics { width: 100%; }
+  .gc-metric { flex-direction: row; align-items: center; gap: .5rem; padding: .35rem .6rem; }
+  .gc-metric strong { font-size: 1.075rem; }
+  .gc-case-grid { padding: 0 .5rem; gap: 1rem; }
+  .gc-case-bookings { margin: 0 .5rem; }
+}
+
+/* Pending attachments stay local until the comment form is submitted. */
+.gc-detail-page #comment-form { flex-direction: column; align-items: stretch; }
+.gc-detail-page .gc-comment-compose { display: flex; gap: .5rem; align-items: center; }
+.gc-detail-page .gc-comment-compose button { flex-shrink: 0; }
+.gc-detail-page .gc-upload-hint { margin: 0; color: #4b6072; font-size: .9rem; }
+.gc-detail-page .gc-upload-queue { list-style: none; padding: 0; margin: 0; max-height: 14rem; overflow: auto; }
+.gc-detail-page .gc-upload-queue li { display: flex; align-items: center; justify-content: space-between; gap: .5rem; border-top: 1px solid #dce2e7; padding: .5rem 0; }
+.gc-detail-page .gc-upload-queue li > span { min-width: 0; overflow-wrap: anywhere; }
+.gc-detail-page .gc-upload-error { display: block; color: #b30808; }
+.gc-detail-page .gc-upload-status { margin: 0; overflow-wrap: anywhere; }
+.gc-detail-page .gc-upload-status:empty, .gc-detail-page .gc-upload-queue:empty { display: none; }
+.gc-detail-page .gc-assignee-field { border-top: 1px solid #dce2e7; padding-top: 1rem; }
+.gc-detail-page .gc-assignee-label { display: block; color: #52616f; margin-bottom: .5rem; }
+.gc-detail-page .gc-assignee-value { align-items: center; }
+.gc-detail-page .gc-assignee-value > span { flex: 1; }
+.gc-detail-page .gc-verursacher-edit { padding: .25rem; }
+.gc-detail-page .message-input.gc-drop-active { outline: 3px solid #72889b; background: #edf1f4; }

+ 93 - 0
static/assets/css/list.css

@@ -0,0 +1,93 @@
+/* All list components are scoped; the document, not the table, scrolls vertically. */
+:root { --gc-summary-height: 0px; }
+body:has(.gc-list-page) { max-width: 1840px; }
+.gc-list-page { font-size: 1.0625rem; color: var(--gc-brand-ink); padding-bottom: calc(var(--gc-summary-height) + 1.5rem); gap: 1.25rem; }
+.gc-list-page * { min-width: 0; }
+.gc-list-page h1 { font-size: 1.75rem; font-weight: 700; margin: 0; }
+.gc-list-filter-content { padding: 1rem; }
+.gc-list-filters { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 1.25rem; }
+.gc-filter-group { margin: 0; padding: 0; border: 0; }
+.gc-filter-group + .gc-filter-group { padding-left: 1.25rem; border-left: 1px solid #dce2e7; }
+.gc-filter-group legend { float: none; width: auto; font-size: 1rem; font-weight: 600; margin: 0 0 .75rem; }
+.gc-filter-fields { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: .8rem; }
+.gc-filter-field label { display: block; font-size: 1rem; color: #52616f; margin-bottom: .3rem; }
+.gc-list-page :is(.form-control, .form-select) { font-size: 1.0625rem; min-height: 42px; border-color: #b1bcc7; border-radius: 6px; }
+.gc-list-page :is(.form-control, .form-select):focus { border-color: #526b7e; box-shadow: 0 0 0 3px #72889b33; }
+.gc-list-page input[type="date"]::-webkit-datetime-edit-year-field,
+.gc-list-page input[type="date"]::-webkit-datetime-edit-month-field,
+.gc-list-page input[type="date"]::-webkit-datetime-edit-day-field,
+.gc-list-page input[type="date"]::-webkit-datetime-edit-text { color: var(--gc-brand-ink); }
+.gc-list-table-region { position: relative; }
+.gc-list-table-scroll { position: relative; overflow-x: auto; max-width: 100%; border-radius: 0 0 9px 9px; }
+.gc-list-table { width: 100%; min-width: 1560px; border-collapse: separate; border-spacing: 0; font-size: 1.0625rem; margin: 0; table-layout: fixed; color: #111; }
+.gc-list-table :is(th, td) { padding: .8rem .75rem; vertical-align: top; overflow-wrap: anywhere; }
+.gc-list-table thead { position: static; }
+/* A visually hidden bottom caption extends the scroll height by one pixel. */
+.gc-list-table caption { caption-side: top; }
+.gc-list-table th { background: var(--gc-brand-action); color: #fff; font-size: 1rem; font-weight: 700; border-bottom: 1px solid #526b7e; line-height: 1.45; hyphens: auto; }
+.gc-list-table tbody td { background: #fff; border-bottom: 1px solid #e5e9ed; line-height: 1.5; }
+.gc-list-table .gc-invoice-row:hover td { background: #f6f8fa; }
+.gc-list-table .gc-invoice-row.gc-return-highlight td { background: #dfeaf1; }
+.gc-list-table .gc-invoice-row:focus-visible { outline: 3px solid #354f63; outline-offset: -3px; }
+.gc-return-status { padding: .85rem 1rem; margin: 0; border: 1px solid #b1bcc7; border-radius: 6px; background: #edf2f5; }
+.gc-list-table th:nth-child(1) { width: 8%; }
+.gc-list-table th:nth-child(2) { width: 9%; }
+.gc-list-table th:nth-child(3) { width: 10%; }
+.gc-list-table th:nth-child(4) { width: 10%; }
+.gc-list-table th:nth-child(5) { width: 15%; }
+.gc-list-table th:nth-child(6) { width: 11%; }
+.gc-list-table th:nth-child(7) { width: 8%; }
+.gc-list-table th:nth-child(8) { width: 7%; }
+.gc-list-table th:nth-child(9) { width: 9%; }
+.gc-list-table th:nth-child(10) { width: 9%; }
+.gc-list-table th:nth-child(11) { width: 4%; }
+.gc-list-page a { color: #354f63; text-underline-offset: .15em; }
+.gc-list-page .gc-title { font-weight: 600; }
+.gc-list-page .gc-subtitle { margin-top: .3rem; font-size: 1rem; color: #52616f; line-height: 1.5; }
+.gc-list-page .gc-money, .gc-list-summary strong { font-variant-numeric: tabular-nums; white-space: nowrap; }
+.gc-list-table td:nth-child(6) > .gc-money { font-weight: 700; }
+.gc-list-table td:nth-child(6) .gc-subtitle { font-variant-numeric: tabular-nums; }
+.gc-list-badge { display: inline-flex; align-items: center; justify-content: center; padding: .15rem .5rem; border: 1px solid #b1bcc7; border-radius: 5px; font-size: .9375rem; font-weight: 600; color: #182630; white-space: nowrap; }
+.gc-list-badge-info { background: #edf2f5; }
+.gc-list-badge-warning, .gc-list-badge-1 { background: #fff3bd; border-color: #c8af45; }
+.gc-list-badge-2 { background: #f5dddd; border-color: #b30808; }
+.gc-list-badge-0 { background: #e6eedc; border-color: #92aa78; }
+.gc-wiedervorlage-edit { gap: .3rem; cursor: pointer; }
+.gc-wiedervorlage-edit:hover { filter: brightness(.96); }
+.gc-wiedervorlage-edit .icon { width: 1rem; height: 1rem; flex-shrink: 0; }
+.gc-list-page .btn { font-size: 1rem; border-radius: 6px; }
+.gc-list-page .gc-comment-toggle { display: inline-flex; align-items: center; gap: .4rem; border: 1px solid #b1bcc7; background: #fff; color: #354f63; padding: .4rem .5rem; }
+.gc-comment-toggle[aria-expanded="true"] { background: #e6edf2; }
+.gc-list-page .gc-action-btn { display: inline-flex; align-items: center; justify-content: center; width: 38px; height: 38px; border-radius: 8px; background: #fff; color: #354f63; border: 1px solid #72889b; }
+.gc-list-page .gc-action-btn:hover { background: #c7dee7; }
+.gc-list-page .gc-action-btn .icon { font-size: 18px; width: 18px; height: 18px; }
+.gc-list-page .gc-comment-row > td { background: #f6f8fa; padding: 1rem; }
+.gc-row-comments { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; }
+.gc-row-comments section { background: #fff; border: 1px solid #dce2e7; border-radius: 6px; padding: .85rem 1rem; }
+.gc-row-comments h3 { font-size: 1.125rem; margin: 0 0 .5rem; font-weight: 600; }
+.gc-row-comments p { margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; }
+.gc-list-empty { padding: 2rem !important; text-align: center; color: #52616f; }
+.gc-list-load td { padding: .5rem; text-align: center; color: #52616f; font-size: 1rem; }
+.gc-floating-table-head { position: fixed; z-index: 1020; overflow: hidden; pointer-events: none; box-shadow: 0 3px 7px #18263018; }
+.gc-floating-table-head .gc-list-table { min-width: 0; }
+.gc-list-summary { position: fixed; bottom: 0; left: 0; right: 0; z-index: 1025; background: #edf1f4; border-top: 1px solid #b1bcc7; color: #182630; font-size: 1rem; box-shadow: 0 -2px 8px #18263008; }
+.gc-summary-inner { width: calc(100% - 1.5rem); max-width: 1816px; margin: auto; display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: .5rem 1.5rem; padding: .8rem 1.25rem; }
+.gc-summary-inner > div { display: flex; gap: .65rem; align-items: baseline; }
+.gc-summary-total strong { font-size: 1.125rem; }
+.gc-active-filters summary { cursor: pointer; font-weight: 600; }
+.gc-active-filter-panel { position: absolute; bottom: calc(100% + .5rem); left: max(1rem, calc((100% - 1800px) / 2)); width: min(32rem, calc(100% - 2rem)); max-height: min(40vh, 20rem); overflow-y: auto; padding: 1rem; background: #fff; border: 1px solid #b1bcc7; border-radius: 8px; box-shadow: 0 4px 18px #18263020; }
+.gc-active-filter-panel > div { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.5fr); gap: .75rem; padding: .4rem 0; overflow-wrap: anywhere; }
+.gc-active-filter-panel a { color: #354f63; }
+@media (max-width: 1199.98px) {
+  .gc-list-filters { grid-template-columns: 1fr; }
+  .gc-filter-group + .gc-filter-group { padding: 1rem 0 0; border-left: 0; border-top: 1px solid #dce2e7; }
+  .gc-filter-fields { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+}
+@media (max-width: 575.98px) {
+  .gc-list-page { padding: 1rem .5rem calc(var(--gc-summary-height) + 1rem); }
+  .gc-list-filter-content { padding: .75rem; }
+  .gc-filter-fields { grid-template-columns: minmax(0, 1fr); }
+  .gc-summary-inner { padding: .6rem .75rem; gap: .5rem; font-size: .9375rem; }
+  .gc-summary-total { flex: 1 1 100%; justify-content: space-between; }
+  .gc-row-comments { grid-template-columns: minmax(0, 1fr); }
+}

+ 285 - 121
static/assets/css/main.css

@@ -11,9 +11,11 @@
     --primary: #5468FF;
     --primary-light: #8590FF;
     --primary-dark: #3A4DB2;
-    --student: #E9EFFF;
-    --teacher: #EBFAEF;
-    --teacher-accent: #4CAF50;
+    --myself: #E9EFFF;
+    --myself-accent: #5468FF;
+    --myself-accent-dark: #3A4DB2;
+    --other: #EBFAEF;
+    --other-accent: #4CAF50;
     --text-dark: #1A2138;
     --text-light: #5F6A8A;
     --background: #F9FAFC;
@@ -56,7 +58,7 @@ body {
     position: relative;
 }
 
-.header {
+.chat-container .header {
     padding: 16px 24px;
     background-color: var(--panel);
     border-bottom: 1px solid var(--border);
@@ -68,34 +70,34 @@ body {
     z-index: 10;
 }
 
-.header-left {
+.chat-container .header-left {
     display: flex;
     align-items: center;
     gap: 12px;
 }
 
-.course-info {
+.chat-container .course-info {
     display: flex;
     flex-direction: column;
 }
 
-.course-title {
+.chat-container .course-title {
     font-weight: 600;
     font-size: 16px;
     color: var(--text-dark);
 }
 
-.course-participants {
+.chat-container .course-participants {
     font-size: 12px;
     color: var(--text-light);
 }
 
-.header-actions {
+.chat-container .header-actions {
     display: flex;
     gap: 12px;
 }
 
-.icon-button {
+.chat-container .icon-button {
     width: 36px;
     height: 36px;
     border-radius: 50%;
@@ -109,14 +111,14 @@ body {
     transition: var(--transition);
 }
 
-.icon-button:hover {
+.chat-container .icon-button:hover {
     background-color: var(--primary-light);
     color: white;
     transform: translateY(-2px);
     box-shadow: var(--hover-shadow);
 }
 
-.icon-button svg {
+.chat-container .icon-button svg {
     width: 18px;
     height: 18px;
 }
@@ -150,7 +152,37 @@ body {
     color: var(--text-dark);
 }
 
-.badge {
+.history-tabs {
+    flex-wrap: wrap;
+    flex-shrink: 0;
+    padding: 0 8px;
+}
+
+.history-tab {
+    border: 0;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    font-family: inherit;
+}
+
+.history-tab:disabled {
+    cursor: not-allowed;
+    opacity: 0.5;
+}
+
+.comment-history {
+    display: flex;
+    flex: 1;
+    flex-direction: column;
+    min-height: 0;
+}
+
+.comment-invoice {
+    font-size: 12px;
+    color: var(--text-light);
+}
+
+.chat-container .badge {
     position: absolute;
     top: 8px;
     right: 8px;
@@ -162,7 +194,7 @@ body {
     border-radius: 10px;
 }
 
-.chat-content {
+.chat-container .chat-content {
     flex: 1;
     overflow-y: auto;
     padding: 24px;
@@ -172,20 +204,20 @@ body {
     scroll-behavior: smooth;
 }
 
-.chat-content::-webkit-scrollbar {
+.chat-container .chat-content::-webkit-scrollbar {
     width: 6px;
 }
 
-.chat-content::-webkit-scrollbar-track {
+.chat-container .chat-content::-webkit-scrollbar-track {
     background: transparent;
 }
 
-.chat-content::-webkit-scrollbar-thumb {
+.chat-container .chat-content::-webkit-scrollbar-thumb {
     background-color: var(--border);
     border-radius: 6px;
 }
 
-.message {
+.chat-container .message {
     display: flex;
     flex-direction: column;
     max-width: 80%;
@@ -204,22 +236,22 @@ body {
     }
 }
 
-.message.student {
+.chat-container .message.myself {
     align-self: flex-end;
 }
 
-.message.teacher {
+.chat-container .message.other {
     align-self: flex-start;
 }
 
-.message-header {
+.chat-container .message-header {
     display: flex;
     align-items: center;
     gap: 8px;
     margin-bottom: 4px;
 }
 
-.avatar {
+.chat-container .avatar {
     width: 28px;
     height: 28px;
     border-radius: 50%;
@@ -232,34 +264,18 @@ body {
     flex-shrink: 0;
 }
 
-.student .avatar {
-    background-color: var(--primary);
-}
-
-.teacher .avatar {
-    background-color: var(--teacher-accent);
-}
-
-.sender-name {
+.chat-container .sender-name {
     font-size: 13px;
     font-weight: 600;
 }
 
-.student .sender-name {
-    color: var(--primary-dark);
-}
-
-.teacher .sender-name {
-    color: var(--teacher-accent);
-}
-
-.timestamp {
+.chat-container .timestamp {
     font-size: 11px;
     color: var(--text-light);
     margin-left: auto;
 }
 
-.message-bubble {
+.chat-container .message-bubble {
     padding: 12px 16px;
     border-radius: 16px;
     font-size: 14px;
@@ -268,22 +284,170 @@ body {
     transition: var(--transition);
 }
 
-.student .message-bubble {
-    background-color: var(--student);
+.chat-container .myself .message-bubble {
     border-top-right-radius: 4px;
 }
 
-.teacher .message-bubble {
-    background-color: var(--teacher);
+.chat-container .other .message-bubble {
     border-top-left-radius: 4px;
 }
 
-.message-bubble:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 3px 10px rgba(0, 0, 0, 0.08);
+
+
+.chat-container .myself2 .avatar {
+    background-color: var(--myself-accent);
+}
+
+.chat-container .myself2 .sender-name {
+    color: var(--myself-accent);
+}
+
+.chat-container .myself2 .message-bubble {
+    background-color: var(--myself);
+}
+
+.chat-container .other2 .avatar {
+    background-color: var(--other-accent);
+}
+
+.chat-container .other2 .sender-name {
+    color: var(--other-accent);
+}
+
+.chat-container .other2 .message-bubble {
+    background-color: var(--other);
+}
+
+
+.chat-container .FIBU .avatar {
+
+    /* red */
+    background-color: #dc3545;
+}
+
+.chat-container .FIBU .sender-name {
+    color: #dc3545;
+}
+
+.chat-container .FIBU .message-bubble {
+    background-color: #d7c0c2;
+}
+
+
+.chat-container .GSL .avatar {
+    /* dark red */
+    background-color: #6e131c;
+}
+
+.chat-container .GSL .sender-name {
+    color: #6e131c;
 }
 
-.message-actions {
+.chat-container .GSL .message-bubble {
+    background-color: #d8acb0;
+}
+
+
+.chat-container .GWL .avatar {
+    /* orange  */
+    background-color: #fd7e14;
+}
+
+.chat-container .GWL .sender-name {
+    color: #fd7e14;
+}
+
+.chat-container .GWL .message-bubble {
+    background-color: #f7d8bf;
+}
+
+
+.chat-container .ZD .avatar {
+    /* purple  */
+    background-color: #6f42c1;
+}
+
+.chat-container .ZD .sender-name {
+    color: #6f42c1;
+}
+
+.chat-container .ZD .message-bubble {
+    background-color: #9f8cc2;
+}
+
+
+.chat-container .ALV .avatar {
+    /* dark blue  */
+    background-color: #0c408f;
+}
+
+.chat-container .ALV .sender-name {
+    color: #0c408f;
+}
+
+.chat-container .ALV .message-bubble {
+    background-color: #7e9ecd;
+}
+
+
+.chat-container .NAGA .avatar {
+    /* blue  */
+    background-color: #0d6efd;    
+}
+
+.chat-container .NAGA .sender-name {
+    color: #0d6efd;   
+}
+
+.chat-container .NAGA .message-bubble {
+    background-color: #a1c5fa;
+}
+
+
+.chat-container .Serviceleiter .avatar {
+    /* green  */
+    background-color: #198754;
+}
+
+.chat-container .Serviceleiter .sender-name {
+    color: #198754;
+}
+
+.chat-container .Serviceleiter .message-bubble {
+    background-color: #7aa490;
+}
+
+
+.chat-container .SC .avatar {
+    /* teal  */
+    background-color: #20c997;
+}
+
+.chat-container .SC .sender-name {
+    color: #20c997;
+}
+
+.chat-container .SC .message-bubble {
+    background-color: #93d2bf;
+}
+
+
+.chat-container .TUZ .avatar {
+    /* grey  */
+    background-color: #5b6067;
+}
+
+.chat-container .TUZ .sender-name {
+    color: #5b6067;
+}
+
+.chat-container .TUZ .message-bubble {
+    background-color: #dce7f6;
+}
+
+
+
+.chat-container .message-actions {
     display: flex;
     gap: 8px;
     margin-top: 6px;
@@ -292,11 +456,11 @@ body {
     transition: var(--transition);
 }
 
-.message:hover .message-actions {
+.chat-container .message:hover .message-actions {
     opacity: 1;
 }
 
-.action-button {
+.chat-container .action-button {
     background: none;
     border: none;
     font-size: 12px;
@@ -307,12 +471,12 @@ body {
     transition: var(--transition);
 }
 
-.action-button:hover {
+.chat-container .action-button:hover {
     background-color: rgba(84, 104, 255, 0.1);
     color: var(--primary);
 }
 
-.embed-content {
+.chat-container .embed-content {
     margin-top: 10px;
     border-radius: 8px;
     overflow: hidden;
@@ -321,12 +485,12 @@ body {
     transition: var(--transition);
 }
 
-.embed-content:hover {
+.chat-container .embed-content:hover {
     box-shadow: var(--shadow);
     transform: translateY(-2px);
 }
 
-.embed-header {
+.chat-container .embed-header {
     padding: 10px 12px;
     background-color: rgba(84, 104, 255, 0.05);
     display: flex;
@@ -335,7 +499,7 @@ body {
     border-bottom: 1px solid var(--border);
 }
 
-.embed-icon {
+.chat-container .embed-icon {
     width: 20px;
     height: 20px;
     display: flex;
@@ -344,31 +508,31 @@ body {
     color: var(--primary);
 }
 
-.embed-title {
+.chat-container .embed-title {
     font-size: 12px;
     font-weight: 500;
     flex: 1;
 }
 
-.embed-body {
+.chat-container .embed-body {
     padding: 12px;
 }
 
-.embed-image {
+.chat-container .embed-image {
     width: 100%;
     border-radius: 6px;
     height: auto;
     object-fit: cover;
 }
 
-.embed-text {
+.chat-container .embed-text {
     font-size: 13px;
     color: var(--text-light);
     margin-top: 8px;
     line-height: 1.4;
 }
 
-.embed-footer {
+.chat-container .embed-footer {
     padding: 8px 12px;
     border-top: 1px solid var(--border);
     display: flex;
@@ -376,7 +540,7 @@ body {
     justify-content: space-between;
 }
 
-.embed-button {
+.chat-container .embed-button {
     background-color: var(--primary-light);
     color: white;
     font-size: 12px;
@@ -388,13 +552,13 @@ body {
     transition: var(--transition);
 }
 
-.embed-button:hover {
+.chat-container .embed-button:hover {
     background-color: var(--primary);
     transform: translateY(-1px);
     box-shadow: 0 3px 8px rgba(84, 104, 255, 0.2);
 }
 
-.date-divider {
+.chat-container .date-divider {
     display: flex;
     align-items: center;
     gap: 12px;
@@ -402,19 +566,19 @@ body {
     opacity: 0.7;
 }
 
-.divider-line {
+.chat-container .divider-line {
     flex: 1;
     height: 1px;
     background-color: var(--border);
 }
 
-.divider-text {
+.chat-container .divider-text {
     font-size: 12px;
     color: var(--text-light);
     white-space: nowrap;
 }
 
-.typing-indicator {
+.chat-container .typing-indicator {
     display: flex;
     align-items: center;
     gap: 4px;
@@ -424,7 +588,7 @@ body {
     margin-bottom: 8px;
 }
 
-.typing-dot {
+.chat-container .typing-dot {
     width: 5px;
     height: 5px;
     background-color: var(--text-light);
@@ -432,15 +596,15 @@ body {
     animation: typingAnimation 1.4s infinite ease-in-out;
 }
 
-.typing-dot:nth-child(1) {
+.chat-container .typing-dot:nth-child(1) {
     animation-delay: 0s;
 }
 
-.typing-dot:nth-child(2) {
+.chat-container .typing-dot:nth-child(2) {
     animation-delay: 0.2s;
 }
 
-.typing-dot:nth-child(3) {
+.chat-container .typing-dot:nth-child(3) {
     animation-delay: 0.4s;
 }
 
@@ -458,25 +622,25 @@ body {
     }
 }
 
-.input-area {
+.chat-container .input-area {
     padding: 16px 24px 24px;
     background-color: var(--panel);
     border-top: 1px solid var(--border);
     z-index: 10;
 }
 
-.toolbar {
+.chat-container .toolbar {
     display: flex;
     align-items: center;
     gap: 8px;
     margin-bottom: 12px;
 }
 
-.toolbar form {
+.chat-container .toolbar form {
     width: 100%;
 }
 
-.tool-button {
+.chat-container .tool-button {
     background: none;
     border: none;
     cursor: pointer;
@@ -490,23 +654,23 @@ body {
     transition: var(--transition);
 }
 
-.tool-button:hover {
+.chat-container .tool-button:hover {
     background-color: rgba(84, 104, 255, 0.1);
     color: var(--primary);
 }
 
-.tool-button svg {
+.chat-container .tool-button svg {
     width: 18px;
     height: 18px;
 }
 
-.input-container {
+.chat-container .input-container {
     display: flex;
     gap: 12px;
     align-items: center;
 }
 
-.message-input {
+.chat-container .message-input {
     flex: 1;
     padding: 14px 16px;
     border-radius: 10px;
@@ -520,12 +684,12 @@ body {
     outline: none;
 }
 
-.message-input:focus {
+.chat-container .message-input:focus {
     border-color: var(--primary-light);
     box-shadow: 0 0 0 2px rgba(84, 104, 255, 0.1);
 }
 
-.send-button {
+.chat-container .send-button {
     background-color: var(--primary);
     color: white;
     border: none;
@@ -539,32 +703,32 @@ body {
     transition: var(--transition);
 }
 
-.send-button:hover {
+.chat-container .send-button:hover {
     background-color: var(--primary-dark);
     transform: translateY(-2px);
     box-shadow: 0 4px 12px rgba(84, 104, 255, 0.2);
 }
 
-.poll-container {
+.chat-container .poll-container {
     padding: 12px;
     background-color: rgba(84, 104, 255, 0.05);
     border-radius: 8px;
     margin-top: 8px;
 }
 
-.poll-question {
+.chat-container .poll-question {
     font-weight: 500;
     margin-bottom: 10px;
     font-size: 13px;
 }
 
-.poll-options {
+.chat-container .poll-options {
     display: flex;
     flex-direction: column;
     gap: 8px;
 }
 
-.poll-option {
+.chat-container .poll-option {
     background-color: white;
     border: 1px solid var(--border);
     padding: 8px 12px;
@@ -577,17 +741,17 @@ body {
     justify-content: space-between;
 }
 
-.poll-option:hover {
+.chat-container .poll-option:hover {
     border-color: var(--primary-light);
     background-color: rgba(84, 104, 255, 0.03);
 }
 
-.poll-option.selected {
+.chat-container .poll-option.selected {
     border-color: var(--primary);
     background-color: rgba(84, 104, 255, 0.1);
 }
 
-.poll-option.selected::before {
+.chat-container .poll-option.selected::before {
     content: '';
     position: absolute;
     left: 0;
@@ -599,20 +763,20 @@ body {
     border-bottom-left-radius: 6px;
 }
 
-.poll-percent {
+.chat-container .poll-percent {
     font-size: 12px;
     font-weight: 500;
     color: var(--primary);
 }
 
-.poll-votes {
+.chat-container .poll-votes {
     margin-top: 10px;
     font-size: 12px;
     color: var(--text-light);
     text-align: right;
 }
 
-.resource-link {
+.chat-container .resource-link {
     display: flex;
     align-items: center;
     gap: 8px;
@@ -626,14 +790,14 @@ body {
     border: 1px solid var(--border);
 }
 
-.resource-link:hover {
+.chat-container .resource-link:hover {
     background-color: rgba(84, 104, 255, 0.05);
     border-color: var(--primary-light);
     transform: translateY(-2px);
     box-shadow: var(--shadow);
 }
 
-.resource-icon {
+.chat-container .resource-icon {
     width: 36px;
     height: 36px;
     background-color: rgba(84, 104, 255, 0.1);
@@ -644,16 +808,16 @@ body {
     color: var(--primary);
 }
 
-.resource-info {
+.chat-container .resource-info {
     flex: 1;
 }
 
-.resource-title {
+.chat-container .resource-title {
     font-size: 13px;
     font-weight: 500;
 }
 
-.resource-desc {
+.chat-container .resource-desc {
     font-size: 11px;
     color: var(--text-light);
 }
@@ -666,15 +830,15 @@ body {
         border-radius: 0;
     }
 
-    .message {
+    .chat-container .message {
         max-width: 90%;
     }
 
-    .header-actions {
+    .chat-container .header-actions {
         gap: 8px;
     }
 
-    .icon-button {
+    .chat-container .icon-button {
         width: 32px;
         height: 32px;
     }
@@ -706,27 +870,27 @@ body {
     }
 }
 
-.pop-in {
+.chat-container .pop-in {
     animation: popIn 0.3s forwards;
 }
 
 /* Resource expansion animation */
-.resource-expanded {
+.chat-container .resource-expanded {
     max-height: 0;
     overflow: hidden;
     transition: max-height 0.3s ease;
 }
 
-.resource-expanded.active {
+.chat-container .resource-expanded.active {
     max-height: 200px;
 }
 
 /* Tooltip Styles */
-.tooltip {
+.chat-container .tooltip {
     position: relative;
 }
 
-.tooltip::after {
+.chat-container .tooltip::after {
     content: attr(data-tooltip);
     position: absolute;
     bottom: 130%;
@@ -745,7 +909,7 @@ body {
     z-index: 100;
 }
 
-.tooltip::before {
+.chat-container .tooltip::before {
     content: '';
     position: absolute;
     bottom: 120%;
@@ -761,21 +925,21 @@ body {
     z-index: 100;
 }
 
-.tooltip:hover::after,
-.tooltip:hover::before {
+.chat-container .tooltip:hover::after,
+.chat-container .tooltip:hover::before {
     opacity: 1;
     visibility: visible;
 }
 
 /* Reaction Styles */
-.reactions {
+.chat-container .reactions {
     display: flex;
     flex-wrap: wrap;
     gap: 4px;
     margin-top: 8px;
 }
 
-.reaction {
+.chat-container .reaction {
     font-size: 12px;
     padding: 2px 6px 2px 4px;
     background-color: rgba(84, 104, 255, 0.06);
@@ -787,11 +951,11 @@ body {
     transition: var(--transition);
 }
 
-.reaction:hover {
+.chat-container .reaction:hover {
     background-color: rgba(84, 104, 255, 0.15);
 }
 
-.reaction.active {
+.chat-container .reaction.active {
     background-color: rgba(84, 104, 255, 0.2);
     font-weight: 500;
 }
@@ -840,7 +1004,7 @@ a {
 }
 
 
-.chat-input {
+.chat-container .chat-input {
     padding: 15px 20px;
     border-top: 1px solid var(--border);
     display: flex;
@@ -850,7 +1014,7 @@ a {
     z-index: 10;
 }
 
-.input-container {
+.chat-container .input-container {
     flex: 1;
     display: flex;
     align-items: center;
@@ -860,7 +1024,7 @@ a {
     position: relative;
 }
 
-.input-container input {
+.chat-container .input-container input {
     flex: 1;
     border: none;
     outline: none;
@@ -870,12 +1034,12 @@ a {
     font-size: 15px;
 }
 
-.input-actions {
+.chat-container .input-actions {
     display: flex;
     gap: 10px;
 }
 
-.input-btn {
+.chat-container .input-btn {
     background: none;
     border: none;
     color: #888;
@@ -884,11 +1048,11 @@ a {
     font-size: 18px;
 }
 
-.input-btn:hover {
+.chat-container .input-btn:hover {
     color: var(--primary);
 }
 
-.send-btn {
+.chat-container .send-btn {
     background-color: var(--primary);
     color: white;
     width: 40px;
@@ -903,7 +1067,7 @@ a {
     justify-content: center;
 }
 
-.send-btn:hover {
+.chat-container .send-btn:hover {
     background-color: var(--primary-light);
     transform: scale(1.05);
 }
@@ -935,4 +1099,4 @@ input[type="date"]:in-range::-webkit-datetime-edit-month-field,
 input[type="date"]:in-range::-webkit-datetime-edit-day-field,
 input[type="date"]:in-range::-webkit-datetime-edit-text {
     color: #eee;
-}
+}

+ 0 - 1183
static/assets/css/redesign.css

@@ -1,1183 +0,0 @@
-:root {
-    --gc-bg: #f4f6fb;
-    --gc-surface: #ffffff;
-    --gc-surface-soft: #f8fafc;
-    --gc-border: #e5e7eb;
-    --gc-text: #111827;
-    --gc-muted: #6b7280;
-    --gc-primary: #475569;
-    --gc-primary-dark: #334155;
-    --gc-primary-soft: #eef2f7;
-    --gc-danger: #dc2626;
-    --gc-warning: #d97706;
-    --gc-success: #16a34a;
-    --gc-radius-sm: 10px;
-    --gc-radius-md: 16px;
-    --gc-radius-lg: 22px;
-    --gc-shadow-sm: 0 4px 14px rgba(15, 23, 42, .06);
-    --gc-shadow-md: 0 18px 45px rgba(15, 23, 42, .10);
-    --gc-topbar-height: 72px;
-  }
-  
-  /* Basis */
-  
-  html,
-  body {
-    min-height: 100%;
-    background: var(--gc-bg);
-    color: var(--gc-text);
-  }
-  
-  body {
-    overflow-y: auto;
-    overflow-x: auto;
-    font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  }
-  
-  /* App Shell */
-  
-  .gc-shell {
-    height: 100vh;
-    display: flex;
-    flex-direction: column;
-    background:
-      radial-gradient(circle at top left, rgba(100, 116, 139, .10), transparent 34rem),
-      linear-gradient(180deg, #f8fafc 0%, #eef2f7 100%);
-  }
-  
-  .gc-topbar {
-    height: var(--gc-topbar-height);
-    flex: 0 0 var(--gc-topbar-height);
-    display: flex;
-    align-items: center;
-    padding: 0 1.5rem;
-    background: rgba(255, 255, 255, .86);
-    backdrop-filter: blur(18px);
-    border-bottom: 1px solid rgba(226, 232, 240, .9);
-    z-index: 1000;
-  }
-  
-  .gc-logo {
-    height: 38px;
-    width: auto;
-    object-fit: contain;
-  }
-  
-  .gc-brand {
-    font-size: 1rem;
-    font-weight: 800;
-    letter-spacing: -.02em;
-    color: var(--gc-text);
-  }
-  
-  .gc-nav-link {
-    display: inline-flex;
-    align-items: center;
-    min-height: 38px;
-    padding: .45rem .8rem;
-    border-radius: 999px;
-    color: var(--gc-muted);
-    font-weight: 700;
-    text-decoration: none;
-    transition: all .18s ease;
-  }
-  
-  .gc-nav-link:hover {
-    color: #334155;
-    background: #eef2f7;
-    text-decoration: none;
-  }
-  
-  .gc-page {
-    flex: 1;
-    width: 100%;
-    max-width: 1840px;
-    margin: 0 auto;
-    padding: 1.25rem;
-    overflow: hidden;
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-  }
-  
-  /* Cards */
-  
-  .gc-card {
-    background: rgba(255, 255, 255, .95);
-    border: 1px solid rgba(226, 232, 240, .95);
-    border-radius: var(--gc-radius-lg);
-    box-shadow: var(--gc-shadow-sm);
-  }
-  
-  /* Filter */
-  
-  .gc-filterbar {
-    padding: 1rem;
-  }
-  
-  .gc-filterbar .form-label {
-    font-size: .74rem;
-    font-weight: 800;
-    text-transform: uppercase;
-    color: var(--gc-muted);
-    letter-spacing: .04em;
-  }
-  
-  .gc-filterbar .form-control,
-  .gc-filterbar .form-select {
-    border-radius: 12px;
-    border-color: var(--gc-border);
-    font-weight: 600;
-  }
-  
-  .gc-filterbar .form-control:focus,
-  .gc-filterbar .form-select:focus {
-    border-color: #94a3b8;
-    box-shadow: 0 0 0 .2rem rgba(100, 116, 139, .12);
-  }
-  
-  /* Tabelle */
-  
-  .gc-table-wrap {
-    flex: 1;
-    overflow: auto;
-    border-radius: var(--gc-radius-lg);
-    padding-top: 0 !important;
-  }
-  
-  .gc-table {
-    width: 100%;
-    min-width: 1450px;
-    margin: 0 !important;
-    border-collapse: separate !important;
-    border-spacing: 0 !important;
-    table-layout: auto !important;
-    font-size: .88rem;
-  }
-  
-  .gc-table thead {
-    position: static !important;
-    z-index: auto !important;
-  }
-  
-  .gc-table thead th {
-    position: static !important;
-    top: auto !important;
-    z-index: auto !important;
-    background: #f3f4f6 !important;
-    color: #667085;
-    font-size: .7rem;
-    font-weight: 900;
-    text-transform: uppercase;
-    letter-spacing: .055em;
-    padding: .85rem .8rem !important;
-    border-top: 0 !important;
-    border-bottom: 1px solid #d7dde5 !important;
-    box-shadow: none !important;
-    white-space: nowrap;
-    vertical-align: bottom;
-  }
-  
-  .gc-table tbody td {
-    background: #ffffff;
-    padding: .85rem .8rem !important;
-    border-top: 1px solid #edf2f7;
-    vertical-align: top;
-  }
-  
-  .gc-table tbody tr {
-    transition: background .15s ease;
-  }
-  
-  .gc-table tbody tr:hover td {
-    background: #fafbfc;
-  }
-  
-  /* Spalten */
-  
-  .gc-table th:nth-child(2),
-  .gc-table td:nth-child(2) {
-    width: 120px;
-    white-space: normal !important;
-  }
-  
-  .gc-table th:nth-child(3),
-  .gc-table td:nth-child(3) {
-    padding-left: 14px !important;
-  }
-  
-  .gc-table th:nth-child(8),
-  .gc-table td:nth-child(8),
-  .gc-table td:nth-child(8) *,
-  .gc-table th:nth-child(9),
-  .gc-table td:nth-child(9),
-  .gc-table td:nth-child(9) * {
-    white-space: nowrap !important;
-  }
-  
-  /* Tabellenlinks neutral/grau */
-  
-  .gc-table a {
-    color: #008 !important;
-    text-decoration: none;
-    font-weight: 600;
-  }
-  
-  .gc-table a:hover {
-    color: #1f2937 !important;
-    text-decoration: underline;
-  }
-  
-  /* Typografie */
-  
-  .gc-title {
-    color: var(--gc-text);
-    font-weight: 750;
-    line-height: 1.25;
-  }
-  
-  .gc-subtitle {
-    margin-top: .15rem;
-    color: var(--gc-muted);
-    font-size: .78rem;
-    line-height: 1.35;
-  }
-  
-  .gc-main-cell {
-    min-width: 290px;
-  }
-  
-  .gc-money {
-    font-variant-numeric: tabular-nums;
-    font-weight: 400;
-    white-space: nowrap;
-  }
-  /* Offen / Kunde ges. weiterhin fett */
-.gc-table td:nth-child(8) .gc-money {
-    font-weight: 800 !important;
-  }
-  
-  /* Buttons */
-  
-  .gc-action-btn {
-    border-radius: 10px;
-    font-weight: 700;
-    background: #7b8ea3 !important;
-    border-color: #7b8ea3 !important;
-    color: #ffffff !important;
-    box-shadow: none !important;
-  }
-  
-  .gc-action-btn:hover {
-    background: #66788c !important;
-    border-color: #66788c !important;
-    color: #ffffff !important;
-  }
-  
-  /* Badges */
-  
-  .gc-badge {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    gap: .3rem;
-    min-height: 24px;
-    padding: .22rem .55rem;
-    border-radius: 999px;
-    font-size: .7rem;
-    font-weight: 800;
-    border: 1px solid transparent;
-    white-space: nowrap;
-  }
-  
-  .gc-badge-info {
-    background: #edf2f7;
-    color: #475569;
-    border-color: #dbe3ee;
-  }
-  
-  .gc-badge-warning, .gc-badge-1 {
-    background: #f6ecd2;
-    color: #8a6a1f;
-    border-color: #ead9a7;
-  }
-  
-  .gc-badge-danger, .gc-badge-2 {
-    background: #fee2e2;
-    color: #991b1b;
-    border-color: #fecaca;
-  }
-  
-  .gc-badge-success, .gc-badge-0 {
-    background: #dcfce7;
-    color: #166534;
-    border-color: #bbf7d0;
-  }
-  
-  /* Mahnstufen */
-  
-  .gc-mahnstufe-1 {
-    background: #fee2e2 !important;
-    color: #991b1b !important;
-    border-color: #fecaca !important;
-  }
-  
-  .gc-mahnstufe-2 {
-    background: #fecaca !important;
-    color: #7f1d1d !important;
-    border-color: #fca5a5 !important;
-  }
-  
-  .gc-mahnstufe-3 {
-    background: #dc2626 !important;
-    color: #ffffff !important;
-    border-color: #991b1b !important;
-  }
-  
-  /* Wiedervorlage */
-  
-  .gc-wv-overdue {
-    background: #fee2e2 !important;
-    color: #991b1b !important;
-    border-color: #fecaca !important;
-  }
-  
-  .gc-wv-today {
-    background: #f6ecd2 !important;
-    color: #8a6a1f !important;
-    border-color: #ead9a7 !important;
-  }
-  
-  .gc-wv-future {
-    background: #dcfce7 !important;
-    color: #166534 !important;
-    border-color: #bbf7d0 !important;
-  }
-  
-  /* Infinite Scroll */
-  
-  .gc-load-sentinel,
-  .gc-load-sentinel td {
-    height: 1px !important;
-    padding: 0 !important;
-    border: 0 !important;
-    background: transparent !important;
-  }
-  
-  /* Detailseite Layout */
-  
-  .gc-case-header,
-  .gc-panel,
-  .gc-case-summary {
-    padding: 1.25rem;
-  }
-  
-  .gc-case-summary .gc-panel-title {
-    margin-bottom: 1rem;
-    font-size: .85rem;
-    font-weight: 800;
-    color: #334155;
-  }
-  
-  .gc-summary-section {
-    margin-bottom: 1rem;
-  }
-  
-  .gc-summary-label {
-    font-size: .72rem;
-    font-weight: 800;
-    color: #64748b;
-    text-transform: uppercase;
-    letter-spacing: .05em;
-    margin-bottom: .15rem;
-  }
-  
-  .gc-summary-main {
-    font-size: .98rem;
-    font-weight: 700;
-    color: #172033;
-    line-height: 1.25;
-  }
-  
-  .gc-summary-sub {
-    font-size: .85rem;
-    color: #64748b;
-    margin-top: .15rem;
-  }
-  
-  .gc-summary-grid {
-    display: grid;
-    grid-template-columns: 1fr 1fr;
-    gap: .75rem;
-    margin-bottom: 1rem;
-  }
-  
-  .gc-summary-value {
-    font-size: .98rem;
-    font-weight: 700;
-    color: #172033;
-  }
-  
-  .gc-case-summary hr {
-    margin: 1.25rem 0;
-    border-color: #e6eaf0;
-    opacity: 1;
-  }
-  
-  .gc-detail-grid {
-    display: grid !important;
-    grid-template-columns: 320px minmax(600px, 1fr) 360px !important;
-    gap: 1rem !important;
-    align-items: start !important;
-    width: 100% !important;
-  }
-  
-  .gc-detail-grid > .gc-case-summary {
-    grid-column: 1 !important;
-    width: 100% !important;
-  }
-  
-  .gc-detail-grid > .gc-detail-main {
-    grid-column: 2 !important;
-    min-width: 0 !important;
-    width: 100% !important;
-  }
-  
-  .gc-detail-grid > .gc-action-panel {
-    grid-column: 3 !important;
-    width: 100% !important;
-    position: sticky !important;
-    top: calc(var(--gc-topbar-height) + 1rem) !important;
-  }
-  
-  .gc-accordion-clean .accordion-item {
-    border: 1px solid var(--gc-border);
-    border-radius: var(--gc-radius-md) !important;
-    overflow: hidden;
-    margin-bottom: .75rem;
-  }
-  
-  /* Chat / Timeline */
-  
-  .gc-detail-main .chat-container2 {
-    height: calc(100vh - var(--gc-topbar-height) - 15rem);
-    max-height: 620px;
-    min-height: 420px;
-    display: flex;
-    flex-direction: column;
-    background: #ffffff;
-    border: 1px solid rgba(226, 232, 240, .95);
-    border-radius: var(--gc-radius-lg);
-    box-shadow: var(--gc-shadow-sm);
-    overflow: hidden;
-  }
-  
-  .chat-container2 .header {
-    flex: 0 0 auto;
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: .85rem 1rem;
-    background: #ffffff;
-    border-bottom: 1px solid #e5e7eb;
-  }
-  
-  .chat-container2 .header-left {
-    display: flex;
-    align-items: center;
-    gap: .75rem;
-    min-width: 0;
-  }
-  
-  .chat-container2 .avatar {
-    width: 32px;
-    height: 32px;
-    flex: 0 0 32px;
-    border-radius: 999px;
-    background: #e5e7eb;
-    color: #ffffff;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    font-size: .72rem;
-    font-weight: 900;
-    overflow: hidden;
-  }
-  
-  .chat-container2 .course-title {
-    font-size: .95rem;
-    font-weight: 850;
-    color: #111827;
-    line-height: 1.25;
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-  
-  .chat-container2 .course-participants {
-    margin-top: .1rem;
-    font-size: .76rem;
-    color: #64748b;
-  }
-  
-  .chat-container2 .header-actions {
-    display: flex;
-    align-items: center;
-    gap: .35rem;
-  }
-  
-  .chat-container2 .icon-button {
-    width: 32px;
-    height: 32px;
-    border: 1px solid #e5e7eb;
-    border-radius: 10px;
-    background: #f8fafc;
-    color: #64748b;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-  }
-  
-  .chat-container2 .icon-button:hover {
-    background: #eef2f7;
-    color: #334155;
-    border-color: #cbd5e1;
-  }
-  
-  .chat-container2 .tabs {
-    flex: 0 0 auto;
-    display: flex;
-    gap: .35rem;
-    padding: .65rem .85rem;
-    background: #f8fafc;
-    border-bottom: 1px solid #e5e7eb;
-    overflow-x: auto;
-  }
-  
-  .chat-container2 .tab {
-    padding: .38rem .65rem;
-    border-radius: 999px;
-    font-size: .75rem;
-    font-weight: 800;
-    color: #64748b;
-    white-space: nowrap;
-  }
-  
-  .chat-container2 .tab.active {
-    background: #64748b;
-    color: #ffffff;
-  }
-  
-  .chat-container2 .chat-content {
-    flex: 1;
-    min-height: 0;
-    overflow-y: auto;
-    padding: 1rem;
-    background: linear-gradient(180deg, #ffffff 0%, #f8fafc 100%);
-  }
-  
-  .chat-container2 .date-divider {
-    display: flex;
-    align-items: center;
-    gap: .75rem;
-    margin: .4rem 0 1rem;
-  }
-  
-  .chat-container2 .divider-line {
-    flex: 1;
-    height: 1px;
-    background: #e5e7eb;
-  }
-  
-  .chat-container2 .divider-text {
-    font-size: .7rem;
-    font-weight: 850;
-    color: #64748b;
-    text-transform: uppercase;
-    letter-spacing: .04em;
-  }
-  
-  .chat-container2 .message {
-    max-width: 78%;
-    margin-bottom: .85rem;
-  }
-  
-  .chat-container2 .message.teacher,
-  .chat-container2 .message.Fibu,
-  .chat-container2 .message.fibu {
-    margin-right: auto;
-  }
-  
-  .chat-container2 .message.student,
-  .chat-container2 .message.Abteilung,
-  .chat-container2 .message.abteilung {
-    margin-left: auto;
-  }
-  
-  .chat-container2 .message-header {
-    display: flex;
-    align-items: center;
-    gap: .45rem;
-    margin-bottom: .3rem;
-  }
-  
-  .chat-container2 .sender-name {
-    font-size: .76rem;
-    font-weight: 850;
-    color: #334155;
-  }
-  
-  .chat-container2 .timestamp {
-    font-size: .7rem;
-    color: #94a3b8;
-    margin-left: .25rem;
-  }
-  
-  .chat-container2 .message-bubble {
-    display: inline-block;
-    padding: .65rem .85rem;
-    border-radius: 15px;
-    font-size: .86rem;
-    line-height: 1.42;
-    background: #f1f5f9;
-    color: #172033;
-    border: 1px solid #e2e8f0;
-    box-shadow: 0 3px 10px rgba(15, 23, 42, .04);
-  }
-  
-  .chat-container2 .message.student .message-bubble,
-  .chat-container2 .message.Abteilung .message-bubble,
-  .chat-container2 .message.abteilung .message-bubble {
-    background: #f8fafc;
-    color: #172033;
-    border-color: #cbd5e1;
-  }
-  
-  .chat-container2 .message.teacher .message-bubble,
-  .chat-container2 .message.Fibu .message-bubble,
-  .chat-container2 .message.fibu .message-bubble {
-    background: #ffffff;
-    color: #172033;
-    border-color: #e2e8f0;
-  }
-  
-  .chat-container2 .input-area {
-    flex: 0 0 auto;
-    min-height: 46px;
-    padding: .6rem .85rem;
-    background: #ffffff;
-    border-top: 1px solid #e5e7eb;
-  }
-  
-  .chat-container2 .toolbar {
-    display: flex;
-    align-items: center;
-    gap: .5rem;
-  }
-  
-  .chat-container2 .tool-button {
-    width: 32px;
-    height: 32px;
-    border-radius: 10px;
-    border: 1px dashed #cbd5e1;
-    background: #f8fafc;
-  }
-  
-  /* Responsive */
-  
-  @media (max-width: 1200px) {
-    .gc-detail-grid {
-      grid-template-columns: 1fr !important;
-    }
-  
-    .gc-detail-grid > .gc-case-summary,
-    .gc-detail-grid > .gc-detail-main,
-    .gc-detail-grid > .gc-action-panel {
-      grid-column: auto !important;
-    }
-  
-    .gc-detail-grid > .gc-action-panel {
-      position: static !important;
-    }
-  
-    .gc-detail-main .chat-container2 {
-      height: auto;
-      min-height: 520px;
-      max-height: none;
-    }
-  }
-  
-  @media (max-width: 992px) {
-    body {
-      overflow: auto;
-    }
-  
-    .gc-shell {
-      min-height: 100vh;
-      height: auto;
-    }
-  
-    .gc-page {
-      overflow: visible;
-    }
-  
-    .gc-table-wrap {
-      overflow-x: auto;
-    }
-  }
-  /* =========================================================
-   HAUPTSEITE: SINNVOLLERE SPALTENBREITEN
-========================================================= */
-
-.gc-table {
-    min-width: 1380px;
-  }
-  
-  /* Aktion */
-  .gc-table th:nth-child(12),
-  .gc-table td:nth-child(12) {
-    width: 54px;
-  }
-  
-  /* Filiale / Bereich */
-  .gc-table th:nth-child(1),
-  .gc-table td:nth-child(1) {
-    width: 115px;
-    max-width: 115px;
-    white-space: normal !important;
-  }
-  
-  /* Verursacher */
-  .gc-table th:nth-child(2),
-  .gc-table td:nth-child(2) {
-    width: 145px;
-    min-width: 145px;
-    padding-left: 6px !important;
-  }
-  
-  /* RG-Nr. */
-  .gc-table th:nth-child(3),
-  .gc-table td:nth-child(3) {
-    width: 118px;
-  }
-  
-  /* RG-Datum / Fällig */
-  .gc-table th:nth-child(4),
-  .gc-table td:nth-child(4) {
-    width: 120px;
-  }
-  
-  /* Kunde */
-  .gc-table th:nth-child(5),
-  .gc-table td:nth-child(5) {
-    width: 230px;
-    min-width: 230px;
-    padding-left: 8px !important;
-  }  
-
-  /* offen / Kunde ges. */
-  .gc-table th:nth-child(6),
-  .gc-table td:nth-child(6) {
-    width: 155px;
-  }
-  
-  /* Mahnstufe / Staffel */
-  .gc-table th:nth-child(7),
-  .gc-table td:nth-child(7) {
-    width: 125px;
-  }
-  
-  /* Abw. */
-  .gc-table th:nth-child(8),
-  .gc-table td:nth-child(8) {
-    width: 80px;
-  }
-  
-  /* Kommentar Fibu */
-  .gc-table th:nth-child(9),
-  .gc-table td:nth-child(9) {
-    width: 165px;
-  }
-  
-  /* Kommentar Abteilung */
-  .gc-table th:nth-child(10),
-  .gc-table td:nth-child(10) {
-    width: 165px;
-  }
-  
-  /* Wiedervorlage */
-  .gc-table th:nth-child(11),
-  .gc-table td:nth-child(11) {
-    width: 120px;
-  }
-  
-  /* Abw. wieder im alten Gelb */
-  .gc-table td:nth-child(8) .gc-badge-warning {
-    background: #fef3c7 !important;
-    color: #92400e !important;
-    border-color: #fde68a !important;
-    text-align: left;
-  }
-  /* =========================================================
-   EDIT BUTTON LINKS HELLER
-========================================================= */
-
-.gc-table td:nth-child(12) button,
-.gc-table td:nth-child(12) .btn,
-.gc-table td:nth-child(12) a {
-  width: 34px;
-  height: 34px;
-  border-radius: 12px !important;
-  border: 1px solid #d6dee8 !important;
-
-  background: linear-gradient(
-    180deg,
-    #9db0c2 0%,
-    #879caf 100%
-  ) !important;
-
-  color: #ffffff !important;
-
-  box-shadow:
-    inset 0 1px 0 rgba(255,255,255,.28),
-    0 2px 6px rgba(15,23,42,.08);
-
-  transition: all .18s ease;
-}
-
-/* Hover */
-.gc-table td:nth-child(12) button:hover,
-.gc-table td:nth-child(12) .btn:hover,
-.gc-table td:nth-child(12) a:hover {
-  background: linear-gradient(
-    180deg,
-    #a8b9c9 0%,
-    #92a6b8 100%
-  ) !important;
-
-  transform: translateY(-1px);
-}
-
-/* Icon */
-.gc-table td:nth-child(12) i,
-.gc-table td:nth-child(12) svg {
-  color: #ffffff !important;
-  font-size: .9rem;
-}
-/* =========================================================
-   DETAILSEITE: CHATVERLAUF OPTISCH AUFWERTEN
-========================================================= */
-
-.chat-container2 {
-    background: #ffffff !important;
-    border-radius: 22px !important;
-    overflow: hidden;
-  }
-  
-  .chat-container2 .chat-content {
-    background:
-      radial-gradient(circle at top left, rgba(148, 163, 184, .16), transparent 22rem),
-      linear-gradient(180deg, #f8fafc 0%, #f1f5f9 100%) !important;
-    padding: 1.25rem 1.5rem !important;
-  }
-  
-  .chat-container2 .date-divider {
-    margin: 1.25rem 0 1.5rem !important;
-  }
-  
-  .chat-container2 .divider-line {
-    background: #cbd5e1 !important;
-  }
-  
-  .chat-container2 .divider-text {
-    color: #64748b !important;
-    font-weight: 900 !important;
-    font-size: .76rem !important;
-  }
-  
-  .chat-container2 .message {
-    margin-bottom: 1.15rem !important;
-  }
-  
-  .chat-container2 .message-header {
-    margin-bottom: .4rem !important;
-  }
-  
-  .chat-container2 .message-header .avatar {
-    width: 34px !important;
-    height: 34px !important;
-    min-width: 34px !important;
-    background: linear-gradient(180deg, #cbd5e1 0%, #94a3b8 100%) !important;
-    color: #ffffff !important;
-    border: 2px solid #ffffff !important;
-    box-shadow: 0 3px 10px rgba(15, 23, 42, .10) !important;
-    font-size: .68rem !important;
-    text-transform: uppercase;
-  }
-  
-  .chat-container2 .sender-name {
-    color: #172033 !important;
-    font-weight: 850 !important;
-    font-size: .86rem !important;
-  }
-  
-  .chat-container2 .timestamp {
-    color: #94a3b8 !important;
-    font-size: .72rem !important;
-  }
-  
-  .chat-container2 .message-bubble {
-    background: #ffffff !important;
-    color: #1e293b !important;
-    border: 1px solid #dbe3ee !important;
-    border-radius: 16px 16px 16px 6px !important;
-    padding: .72rem .95rem !important;
-    box-shadow: 0 4px 14px rgba(15, 23, 42, .06) !important;
-    line-height: 1.45 !important;
-  }
-  
-  .chat-container2 .message-bubble:hover {
-    border-color: #cbd5e1 !important;
-    box-shadow: 0 8px 22px rgba(15, 23, 42, .09) !important;
-  }
-  
-  /* Nachrichten rechts / Abteilung etwas anders einfärben */
-  .chat-container2 .message.student .message-bubble,
-  .chat-container2 .message.Abteilung .message-bubble,
-  .chat-container2 .message.abteilung .message-bubble {
-    background: #f8fafc;
-    border-color: #e2e8f0;
-    border-radius: 16px 16px 6px 16px !important;
-  }
-  
-  /* Fibu / Standard links */
-  .chat-container2 .message.teacher .message-bubble,
-  .chat-container2 .message.Fibu .message-bubble,
-  .chat-container2 .message.fibu .message-bubble {
-    background: #ffffff !important;
-  }
-  
-  /* Tabs schöner */
-  .chat-container2 .tabs {
-    background: #f8fafc !important;
-    border-bottom: 1px solid #e2e8f0 !important;
-  }
-  
-  .chat-container2 .tab {
-    color: #64748b !important;
-    font-weight: 850 !important;
-  }
-  
-  .chat-container2 .tab.active {
-    background: #64748b !important;
-    color: #ffffff !important;
-    box-shadow: 0 4px 10px rgba(15, 23, 42, .10) !important;
-  }
-  /* =========================================================
-   BUTTONS: KEIN ZEILENUMBRUCH
-========================================================= */
-
-.gc-action-btn,
-.gc-action-btn span,
-.gc-action-btn button,
-.btn {
-  white-space: nowrap !important;
-}
-/* =========================================================
-   RECHTE WORKFLOW-SPALTE:
-   KEINE ZEILENUMBRÜCHE
-========================================================= */
-
-.gc-action-panel button,
-.gc-action-panel .btn,
-.gc-action-panel .gc-badge,
-.gc-action-panel label,
-.gc-action-panel .form-label,
-.gc-action-panel .form-check-label,
-.gc-action-panel select,
-.gc-action-panel option {
-  white-space: nowrap !important;
-}
-
-/* Buttons breiter */
-.gc-action-panel .btn {
-  min-width: 150px;
-}
-
-/* Labels links etwas breiter */
-.gc-action-panel .row > div:first-child,
-.gc-action-panel .col-form-label {
-  min-width: 125px;
-}
-
-/* Eingabefelder sauber ausrichten */
-.gc-action-panel .form-control,
-.gc-action-panel .form-select {
-  min-width: 110px;
-}
-.gc-action-panel .btn:last-child {
-    min-width: auto !important;
-    width: auto !important;
-    padding: .45rem .8rem !important;
-    font-size: .92rem !important;
-  }
-
-  /* =========================================================
-   BETRAGS-BUTTON RECHTS – EDLER
-========================================================= */
-
-.gc-action-panel .btn-primary,
-.gc-action-panel .btn-success,
-.gc-action-panel .btn-purple {
-  background: linear-gradient(
-    180deg,
-    #64748b 0%,
-    #475569 100%
-  ) !important;
-
-  border: 1px solid #475569 !important;
-  color: #ffffff !important;
-
-  box-shadow:
-    0 4px 12px rgba(15,23,42,.12),
-    inset 0 1px 0 rgba(255,255,255,.12);
-
-  min-width: auto !important;
-  width: auto !important;
-
-  padding: .45rem .8rem !important;
-  font-size: .92rem !important;
-  border-radius: 10px !important;
-}
-
-/* Hover */
-.gc-action-panel .btn-primary:hover,
-.gc-action-panel .btn-success:hover,
-.gc-action-panel .btn-purple:hover {
-  background: linear-gradient(
-    180deg,
-    #718197 0%,
-    #526174 100%
-  ) !important;
-
-  transform: translateY(-1px);
-}
-
-.btn-warning {
-  background-color: #e80;
-}
-
-/* =========================================================
-   DETAILSEITE: SEITE BEI AUFGEKLAPPTEN BOXEN SCROLLBAR
-========================================================= */
-
-body {
-    overflow-y: auto !important;
-    overflow-x: hidden !important;
-  }
-  
-  .gc-shell {
-    min-height: 100vh !important;
-    height: auto !important;
-  }
-  
-  .gc-page {
-    min-height: calc(100vh - var(--gc-topbar-height)) !important;
-    height: auto !important;
-    overflow: visible !important;
-  }
-  
-  .gc-detail-grid {
-    align-items: start !important;
-    overflow: visible !important;
-  }
-  
-  .gc-detail-main,
-  .gc-case-summary,
-  .gc-action-panel {
-    overflow: visible !important;
-  }
-  
-  /* Falls Accordion/Boxen innen abgeschnitten werden */
-  .accordion,
-  .accordion-item,
-  .accordion-collapse,
-  .accordion-body,
-  .collapse,
-  .show {
-    overflow: visible !important;
-  }
-  
-  /* Chat bleibt trotzdem intern scrollbar */
-  .gc-detail-main .chat-container2 {
-    overflow: hidden !important;
-  }
-  
-  .gc-detail-main .chat-content {
-    overflow-y: auto !important;
-  }
-
-/* =========================================================
-   DETAILSEITE – ALLE AUFKLAPPBAREN BOXEN WIE "MAHNUNGEN"
-   Inhalt bleibt in der Box, horizontaler Scroll erlaubt
-========================================================= */
-
-.gc-detail-main .accordion-item,
-.gc-detail-main .accordion-collapse,
-.gc-detail-main .accordion-body {
-  max-width: 100% !important;
-  overflow: hidden !important;
-}
-
-.gc-detail-main .accordion-body {
-  overflow-x: auto !important;
-  overflow-y: visible !important;
-  padding: 1rem !important;
-}
-
-/* Tabellen dürfen breiter sein, aber sprengen nicht mehr die Box */
-.gc-detail-main .accordion-body table {
-  width: max-content !important;
-  min-width: 100% !important;
-  max-width: none !important;
-  table-layout: auto !important;
-  white-space: nowrap;
-}
-
-/* Zellen kompakt */
-.gc-detail-main .accordion-body table th,
-.gc-detail-main .accordion-body table td {
-  padding: .55rem .65rem !important;
-  vertical-align: top !important;
-  white-space: nowrap;
-}
-
-/* Lange Beschreibungen dürfen umbrechen */
-.gc-detail-main .accordion-body table td:nth-child(4) {
-  white-space: normal !important;
-  min-width: 180px;
-  max-width: 260px;
-}
-
-/* Horizontaler Scroll optisch sauber */
-.gc-detail-main .accordion-body::-webkit-scrollbar {
-  height: 10px;
-}
-
-.gc-detail-main .accordion-body::-webkit-scrollbar-track {
-  background: #eef2f7;
-  border-radius: 999px;
-}
-
-.gc-detail-main .accordion-body::-webkit-scrollbar-thumb {
-  background: #cbd5e1;
-  border-radius: 999px;
-}
-
-.gc-detail-main .accordion-body::-webkit-scrollbar-thumb:hover {
-  background: #94a3b8;
-}
-
-.gc-link {
-  color: #008;
-}

BIN
static/assets/images/SuK.png


+ 86 - 0
static/assets/js/attachments.js

@@ -0,0 +1,86 @@
+(() => {
+  const initialized = new WeakSet();
+  function init(root = document) {
+    const form = root.matches?.('#comment-form') ? root : root.querySelector?.('#comment-form');
+    if (!form || initialized.has(form)) return;
+    initialized.add(form);
+    const picker = form.querySelector('[type=file]'), manifest = form.querySelector('[name=attachment_ids]');
+    const text = form.querySelector('[name=Kommentar]'), send = form.querySelector('[type=submit]');
+    const attach = form.querySelector('[data-gc-attach]'), list = form.querySelector('.gc-upload-queue');
+    const status = form.querySelector('.gc-upload-status');
+    const limit = Number(form.dataset.maxFileSize);
+    let queue = [], busy = false;
+    function render() {
+      const transfer = new DataTransfer(), ids = [];
+      list.replaceChildren();
+      for (const item of queue) {
+        if (item.file.size <= limit) { transfer.items.add(item.file); ids.push(item.id); }
+        const row = document.createElement('li'), info = document.createElement('span');
+        info.textContent = `${item.file.name} (${new Intl.NumberFormat('de-DE', {maximumFractionDigits: 2}).format(item.file.size / 1024)} KB)`;
+        if (item.error) {
+          const error = document.createElement('span'); error.className = 'gc-upload-error';
+          error.textContent = item.error; info.append(error);
+        }
+        const remove = document.createElement('button'); remove.type = 'button'; remove.className = 'btn btn-outline-secondary';
+        remove.textContent = 'Entfernen'; remove.setAttribute('aria-label', `${item.file.name} entfernen`); remove.disabled = busy;
+        remove.addEventListener('click', () => { status.textContent = ''; queue = queue.filter(entry => entry.id !== item.id); render(); });
+        row.append(info, remove); list.append(row);
+      }
+      picker.files = transfer.files; manifest.value = JSON.stringify(ids);
+      picker.disabled = attach.disabled = text.disabled = busy;
+      send.disabled = busy || (!text.value.trim() && !ids.length);
+      form.setAttribute('aria-busy', String(busy));
+    }
+    function add(files) {
+      if (busy) return;
+      status.textContent = '';
+      for (const file of files) queue.push({file, id: crypto.randomUUID?.() || `file_${Date.now()}_${Math.random().toString(36).slice(2)}`, error: file.size > limit ? `Maximal ${form.dataset.maxFileSizeMb} MB je Datei.` : ''});
+      render();
+    }
+    attach.addEventListener('click', () => picker.click());
+    picker.addEventListener('change', () => add(Array.from(picker.files)));
+    text.addEventListener('input', () => { status.textContent = ''; render(); });
+    text.addEventListener('dragover', event => {
+      if (Array.from(event.dataTransfer.types).includes('Files')) { event.preventDefault(); text.classList.add('gc-drop-active'); }
+    });
+    text.addEventListener('dragleave', () => text.classList.remove('gc-drop-active'));
+    text.addEventListener('drop', event => {
+      text.classList.remove('gc-drop-active');
+      if (!Array.from(event.dataTransfer.types).includes('Files')) return;
+      event.preventDefault();
+      const entries = Array.from(event.dataTransfer.items).map(item => item.webkitGetAsEntry?.());
+      if (entries.some(entry => entry?.isDirectory)) { status.textContent = 'Bitte einzelne Dateien statt Ordner auswählen.'; return; }
+      add(Array.from(event.dataTransfer.files));
+    });
+    form.addEventListener('submit', event => { if (busy || send.disabled) { event.preventDefault(); event.stopImmediatePropagation(); } }, true);
+    form.addEventListener('htmx:beforeRequest', event => {
+      if (event.detail.elt !== form) return;
+      busy = true; render(); status.textContent = 'Wird gesendet …';
+    });
+    form.addEventListener('htmx:afterRequest', event => {
+      if (event.detail.elt !== form) return;
+      busy = false;
+      const response = new DOMParser().parseFromString(event.detail.xhr.responseText || '', 'text/html');
+      const metadata = response.querySelector('[data-gc-send-result]');
+      if (metadata) {
+        const result = JSON.parse(metadata.textContent);
+        const successes = new Set(result.files.filter(file => file.success).map(file => file.id));
+        queue = queue.filter(item => !successes.has(item.id));
+        for (const file of result.files) {
+          const item = queue.find(item => item.id === file.id); if (item) item.error = file.error || '';
+        }
+        if (result.comment_saved) text.value = '';
+        status.textContent = [result.comment_saved ? 'Kommentar gespeichert.' : '', successes.size ? `${successes.size} Datei(en) gespeichert.` : '', ...result.messages, queue.some(item => item.error) ? 'Bitte die Hinweise bei den Dateien beachten.' : ''].filter(Boolean).join(' ');
+      } else {
+        status.textContent = event.detail.xhr.status === 413 ? 'Die gesamte Anfrage ist zu groß. Bitte weniger Dateien auf einmal abschicken.' : 'Der Versand konnte nicht bestätigt werden. Die Eingabe bleibt erhalten.';
+      }
+      form.closest('#chat')?.querySelectorAll('[data-gc-send-result]').forEach(node => node.remove());
+      render();
+    });
+    render();
+  }
+  document.addEventListener('DOMContentLoaded', () => init());
+  document.addEventListener('htmx:load', event => init(event.detail.elt));
+  window.addEventListener('pageshow', () => init());
+})();
+

+ 164 - 0
static/assets/js/dashboard.js

@@ -0,0 +1,164 @@
+/* Accessible chart, table and exact list drill-downs share the same authorized aggregates. */
+(() => {
+  let current, dispose = () => {};
+  let library;
+  function loadChart() {
+    if (window.Chart) return Promise.resolve();
+    if (!library) library = new Promise((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = 'https://cdn.jsdelivr.net/npm/chart.js@4.6.1/dist/chart.umd.min.js';
+      script.onload = resolve; script.onerror = reject; document.head.append(script);
+    });
+    return library;
+  }
+  function init() {
+    const page = document.querySelector('.gc-dashboard-page');
+    if (page === current) return;
+    dispose(); dispose = () => {}; current = page;
+    const source = page?.querySelector('#dashboard-data');
+    if (!source) return;
+    const data = JSON.parse(source.textContent), report = page.querySelector('.gc-dashboard-report');
+    const canvas = page.querySelector('canvas'), box = page.querySelector('.gc-dashboard-chart');
+    const popup = page.querySelector('#dashboard-popover'), search = page.querySelector('#dashboard-search');
+    const status = page.querySelector('.gc-dashboard-status'), tbody = page.querySelector('#dashboard-table-body');
+    const previous = page.querySelector('[data-dashboard-prev]'), next = page.querySelector('[data-dashboard-next]');
+    const events = new AbortController(), signal = events.signal;
+    const collator = new Intl.Collator('de', {sensitivity: 'base'});
+    const count = value => new Intl.NumberFormat('de-DE').format(value);
+    const money = value => {
+      const [whole, fraction = '00'] = String(value).split('.');
+      return whole.replace(/\B(?=(\d{3})+(?!\d))/g, '.') + ',' + fraction.padEnd(2, '0') + ' €';
+    };
+    const element = (tag, text, className) => {
+      const node = document.createElement(tag); if (text !== undefined) node.textContent = text;
+      if (className) node.className = className; return node;
+    };
+    const listLink = (url, description) => {
+      const link = element('a', 'Liste öffnen'); link.href = url; link.target = '_blank'; link.rel = 'noopener';
+      link.setAttribute('aria-label', `Liste öffnen – ${description} (neuer Tab)`); return link;
+    };
+    let view = report.dataset.dashboardView, metric = report.dataset.dashboardMetric, index = 0;
+    let chart, visible = [], pinned = false, hideTimer, loading = !window.Chart;
+    const listen = (target, type, callback) => target.addEventListener(type, callback, {signal});
+    function closePopup() { clearTimeout(hideTimer); pinned = false; popup.hidden = true; }
+    function scheduleHide() { if (!pinned) { clearTimeout(hideTimer); hideTimer = setTimeout(closePopup, 350); } }
+    function showPopup(group, segment, event, pin = false) {
+      if (!segment || (pinned && !pin)) return;
+      clearTimeout(hideTimer); pinned = pin; popup.replaceChildren();
+      const close = element('button', '×'); close.type = 'button'; close.setAttribute('aria-label', 'Details schließen');
+      close.addEventListener('click', () => { closePopup(); canvas.focus({preventScroll: true}); });
+      popup.append(close, element('h3', group.label), element('p', `${data.stack_label}: ${segment.label}`),
+        element('p', `Anzahl: ${count(segment.count)}`), element('p', `Offener Betrag: ${money(segment.amount)}`),
+        element('hr'), element('p', `Gesamte Gruppe: ${count(group.count)} Belege · ${money(group.amount)}`),
+        listLink(segment.url, `${group.label}, ${segment.label}`));
+      popup.hidden = false;
+      const rect = canvas.getBoundingClientRect(), pointX = rect.left + (event.x || 0), pointY = rect.top + (event.y || 0);
+      popup.style.left = Math.max(16, Math.min(pointX + 12, innerWidth - popup.offsetWidth - 16)) + 'px';
+      popup.style.top = Math.max(16, Math.min(pointY + 12, innerHeight - popup.offsetHeight - 16)) + 'px';
+      if (pin) close.focus({preventScroll: true});
+    }
+    function segmentAt(hit) {
+      const group = visible[hit.index], department = data.stack_items[hit.datasetIndex];
+      return [group, group?.segments.find(segment => segment.id === department.id)];
+    }
+    function drawChart() {
+      if (!visible.length || !window.Chart) {
+        chart?.destroy(); chart = null; canvas.hidden = true; box.style.height = '0px';
+        page.querySelector('.gc-dashboard-chart-error').hidden = !visible.length || !!window.Chart || loading;
+        if (visible.length && !window.Chart && !loading) page.querySelector('.gc-dashboard-table').open = true;
+        return;
+      }
+      page.querySelector('.gc-dashboard-chart-error').hidden = true; canvas.hidden = false;
+      box.style.height = `${Math.max(240, visible.length * 47 + 55)}px`;
+      const datasets = data.stack_items.map(department => ({label: department.label, backgroundColor: department.color,
+        borderColor: '#72889b', borderWidth: 1, borderRadius: 2, maxBarThickness: 30,
+        data: visible.map(group => { const segment = group.segments.find(item => item.id === department.id);
+          return segment ? (metric === 'anzahl' ? segment.count : Number(segment.amount)) : 0; })}));
+      const config = {type: 'bar', data: {labels: visible.map(group => group.label), datasets}, options: {
+        indexAxis: 'y', responsive: true, maintainAspectRatio: false, animation: false,
+        plugins: {legend: {display: false}, tooltip: {enabled: false}},
+        scales: {x: {stacked: true, beginAtZero: true, min: metric === 'anzahl' ? 0 : undefined,
+          title: {display: true, text: metric === 'anzahl' ? 'Anzahl der Belege' : 'Offener Betrag (€)', font: {size: 17}},
+          ticks: {precision: metric === 'anzahl' ? 0 : undefined, font: {size: 15}, callback: value => metric === 'anzahl' ? count(value) : new Intl.NumberFormat('de-DE', {notation: 'compact'}).format(value)}},
+          y: {stacked: true, grid: {display: false}, ticks: {autoSkip: false, font: {size: 16}, callback: function(value) {
+            const label = this.getLabelForValue(value), width = innerWidth < 600 ? 17 : 32;
+            return label.length <= width ? label : [label.slice(0, width), label.length > width*2 ? label.slice(width, width*2-1)+'…' : label.slice(width)];
+          }}}},
+        onHover: (event, hits) => { canvas.style.cursor = hits.length ? 'pointer' : 'default';
+          if (hits.length) showPopup(...segmentAt(hits[0]), event); else scheduleHide(); },
+        onClick: (event, hits) => { if (hits.length) showPopup(...segmentAt(hits[0]), event, true); },
+      }};
+      if (chart) { chart.data = config.data; chart.options = config.options; chart.update(); }
+      else chart = new Chart(canvas, config);
+    }
+    function renderTable() {
+      tbody.replaceChildren();
+      for (const group of visible) {
+        const total = element('tr', undefined, 'gc-dashboard-group-row'), heading = element('th', group.label);
+        heading.scope = 'row'; const linkCell = element('td'); linkCell.append(listLink(group.url, group.label));
+        total.append(heading, element('td', count(group.count)), element('td', money(group.amount)), linkCell); tbody.append(total);
+        for (const segment of group.segments) {
+          const row = element('tr'), link = element('td'); link.append(listLink(segment.url, `${group.label}, ${segment.label}`));
+          row.append(element('td', segment.label), element('td', count(segment.count)), element('td', money(segment.amount)), link); tbody.append(row);
+        }
+      }
+    }
+    function render() {
+      closePopup();
+      let groups = data.views[view].filter(group => group.label.toLocaleLowerCase('de').includes(search.value.trim().toLocaleLowerCase('de')));
+      groups = groups.slice().sort((a, b) => {
+        const difference = view === 'Altersstaffel' ? a.order-b.order : metric === 'anzahl' ? b.count-a.count : Number(b.amount)-Number(a.amount);
+        return difference || collator.compare(a.label, b.label) || a.url.localeCompare(b.url);
+      });
+      const pages = Math.max(1, Math.ceil(groups.length / 20)); index = Math.min(index, pages-1);
+      visible = groups.slice(index*20, (index+1)*20);
+      status.textContent = groups.length ? `${index*20+1}–${Math.min((index+1)*20, groups.length)} von ${count(groups.length)} Gruppen` : data.count ? 'Keine Gruppen für die Suche gefunden.' : 'Keine zugänglichen Forderungen vorhanden.';
+      page.querySelector('[data-dashboard-pages]').textContent = `Seite ${index+1} von ${pages}`;
+      previous.disabled = index === 0; next.disabled = index >= pages-1;
+      report.querySelectorAll('a[data-dashboard-view]').forEach(link => {
+        if (link.dataset.dashboardView === view) link.setAttribute('aria-current', 'page'); else link.removeAttribute('aria-current');
+        link.href = `?page=${encodeURIComponent(link.dataset.dashboardView)}&metric=${metric}&stack=${data.stack}${data.only_invoices ? '&only_invoices=true' : ''}`;
+      });
+      report.querySelectorAll('button[data-dashboard-metric]').forEach(button => button.setAttribute('aria-pressed', String(button.dataset.dashboardMetric === metric)));
+      page.querySelector('#dashboard-scope [name=page]').value = view;
+      page.querySelector('#dashboard-scope [name=metric]').value = metric;
+      canvas.setAttribute('aria-label', `Forderungen nach ${view}, gestapelt nach ${data.stack_label}, ${metric === 'anzahl' ? 'Anzahl' : 'offener Betrag'}; vollständige Werte in der Datentabelle`);
+      renderTable(); drawChart();
+    }
+    function updateUrl() { const url = new URL(location.href); url.searchParams.set('page', view); url.searchParams.set('metric', metric); url.searchParams.set('stack', data.stack); history.replaceState(history.state, '', url); }
+    for (const link of report.querySelectorAll('a[data-dashboard-view]')) listen(link, 'click', event => {
+      if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+      event.preventDefault(); event.stopPropagation(); view = link.dataset.dashboardView; search.value = ''; index = 0; updateUrl(); render();
+    });
+    for (const button of report.querySelectorAll('button[data-dashboard-metric]')) listen(button, 'click', () => {
+      metric = button.dataset.dashboardMetric; index = 0; updateUrl(); render();
+    });
+    listen(search, 'input', () => { index = 0; render(); });
+    listen(previous, 'click', () => { index--; render(); }); listen(next, 'click', () => { index++; render(); });
+    listen(canvas, 'mouseleave', scheduleHide); listen(popup, 'mouseenter', () => clearTimeout(hideTimer));
+    listen(popup, 'mouseleave', scheduleHide); listen(popup, 'focusin', () => clearTimeout(hideTimer));
+    listen(document, 'keydown', event => { if (event.key === 'Escape' && !popup.hidden) { const focused = popup.contains(document.activeElement); closePopup(); if (focused) canvas.focus({preventScroll: true}); } });
+    listen(document, 'pointerdown', event => { if (!popup.contains(event.target) && event.target !== canvas) closePopup(); });
+    listen(window, 'resize', closePopup); listen(window, 'scroll', closePopup);
+    canvas.tabIndex = 0;
+    const legend = page.querySelector('.gc-dashboard-legend');
+    for (const department of data.stack_items) { const item = element('li'), swatch = element('span', '', 'gc-dashboard-swatch'); swatch.style.background = department.color; swatch.setAttribute('aria-hidden', 'true'); item.append(swatch, document.createTextNode(department.label)); legend.append(item); }
+    dispose = () => { events.abort(); clearTimeout(hideTimer); chart?.destroy(); popup.hidden = true; };
+    render();
+    if (loading && data.count) loadChart().then(() => { loading = false; if (current === page) drawChart(); })
+      .catch(() => { loading = false; if (current === page) drawChart(); });
+  }
+  document.addEventListener('DOMContentLoaded', init);
+  document.addEventListener('change', event => {
+    if (event.target.matches('#dashboard-only-invoices, #dashboard-stack')) {
+      const form = document.getElementById('dashboard-scope');
+      if (event.target.id === 'dashboard-stack') form.querySelector('[name=stack]').value = event.target.value;
+      form.requestSubmit();
+    }
+  });
+  document.addEventListener('htmx:load', init);
+  document.addEventListener('htmx:historyRestore', init);
+  document.addEventListener('htmx:beforeCleanupElement', event => {
+    if (current && (event.detail.elt === current || event.detail.elt.contains?.(current))) { dispose(); dispose = () => {}; current = undefined; }
+  });
+})();

+ 29 - 0
static/assets/js/layout.js

@@ -0,0 +1,29 @@
+/* Navigation can wrap, and HTMX replaces the body on boosted navigation. */
+(() => {
+  let observer;
+  function observeLayout() {
+    observer?.disconnect();
+    const header = document.querySelector('.gc-app-header');
+    const context = document.querySelector('.gc-case-context');
+    const measure = () => {
+      document.documentElement.style.setProperty('--gc-header-height', `${header?.getBoundingClientRect().height || 0}px`);
+      document.documentElement.style.setProperty('--gc-context-height', `${context?.getBoundingClientRect().height || 0}px`);
+    };
+    measure();
+    observer = new ResizeObserver(measure);
+    if (header) observer.observe(header);
+    if (context) observer.observe(context);
+  }
+  // A label dispatches a second click to its checkbox. Use checked state once.
+  document.addEventListener('change', event => {
+    const input = event.target;
+    if (!input.matches('input[data-gc-collapse]')) return;
+    const panel = document.getElementById(input.getAttribute('aria-controls'));
+    if (panel) panel.classList.toggle('show', input.checked);
+    input.setAttribute('aria-expanded', String(input.checked));
+  });
+  document.addEventListener('DOMContentLoaded', observeLayout);
+  document.addEventListener('htmx:load', observeLayout);
+  document.addEventListener('htmx:historyRestore', observeLayout);
+  window.addEventListener('pageshow', observeLayout);
+})();

+ 101 - 0
static/assets/js/list.js

@@ -0,0 +1,101 @@
+/* A visual header mirror lets the document scroll vertically while the table
+   retains its own horizontal scrollbar. The original header stays semantic. */
+(() => {
+  let currentPage;
+  let dispose = () => {};
+  let refresh = () => {};
+
+  function initList() {
+    const page = document.querySelector('.gc-list-page');
+    if (page === currentPage) {
+      refresh();
+      return;
+    }
+    dispose();
+    currentPage = page;
+    document.documentElement.style.setProperty('--gc-summary-height', '0px');
+    if (!page) return;
+
+    document.querySelectorAll('.gc-floating-table-head').forEach(node => node.remove());
+    const table = page.querySelector('#invoice-list');
+    const scroller = page.querySelector('.gc-list-table-scroll');
+    const header = document.querySelector('.gc-app-header');
+    const footer = document.querySelector('.gc-list-summary');
+    if (!table || !scroller) return;
+
+    const events = new AbortController();
+    const floating = document.createElement('div');
+    floating.className = 'gc-floating-table-head';
+    floating.setAttribute('aria-hidden', 'true');
+    floating.inert = true;
+    floating.hidden = true;
+    const mirror = table.cloneNode(false);
+    mirror.removeAttribute('id');
+    const columns = document.createElement('colgroup');
+    const head = table.tHead.cloneNode(true);
+    head.querySelectorAll('[id]').forEach(node => node.removeAttribute('id'));
+    for (const cell of table.tHead.rows[0].cells) columns.append(document.createElement('col'));
+    mirror.append(columns, head);
+    floating.append(mirror);
+    document.body.append(floating);
+
+    let frame;
+    let needsMeasure = true;
+    const update = () => {
+      frame = undefined;
+      if (!page.isConnected) return;
+      const viewport = scroller.getBoundingClientRect();
+      const bounds = table.getBoundingClientRect();
+      const originalHead = table.tHead.getBoundingClientRect();
+      const top = header?.getBoundingClientRect().bottom || 0;
+      if (needsMeasure) {
+        mirror.style.width = `${bounds.width}px`;
+        [...table.tHead.rows[0].cells].forEach((cell, index) => {
+          columns.children[index].style.width = `${cell.getBoundingClientRect().width}px`;
+        });
+        document.documentElement.style.setProperty('--gc-summary-height', `${footer?.offsetHeight || 0}px`);
+        needsMeasure = false;
+      }
+      floating.style.top = `${top}px`;
+      floating.style.left = `${viewport.left}px`;
+      floating.style.width = `${scroller.clientWidth}px`;
+      mirror.style.transform = `translateX(${-scroller.scrollLeft}px)`;
+      floating.hidden = !(originalHead.top < top && bounds.bottom > top + originalHead.height);
+    };
+    const schedule = (measure = false) => {
+      needsMeasure ||= measure;
+      if (!frame) frame = requestAnimationFrame(update);
+    };
+    refresh = () => schedule(true);
+    const sizes = new ResizeObserver(refresh);
+    for (const node of [table, scroller, header, footer]) if (node) sizes.observe(node);
+    window.addEventListener('scroll', () => schedule(), { passive: true, signal: events.signal });
+    window.addEventListener('resize', refresh, { passive: true, signal: events.signal });
+    scroller.addEventListener('scroll', () => schedule(), { passive: true, signal: events.signal });
+    document.addEventListener('htmx:beforeHistorySave', () => floating.remove(), { signal: events.signal });
+    document.fonts?.ready.then(() => { if (page.isConnected) refresh(); });
+    dispose = () => {
+      events.abort();
+      sizes.disconnect();
+      if (frame) cancelAnimationFrame(frame);
+      floating.remove();
+      refresh = () => {};
+    };
+    refresh();
+  }
+
+  document.addEventListener('click', event => {
+    const button = event.target.closest('[data-gc-comments]');
+    if (!button) return;
+    const row = document.getElementById(button.getAttribute('aria-controls'));
+    if (!row) return;
+    row.hidden = !row.hidden;
+    button.setAttribute('aria-expanded', String(!row.hidden));
+    button.querySelector('span').textContent = row.hidden ? 'Anzeigen' : 'Ausblenden';
+    refresh();
+  });
+  document.addEventListener('DOMContentLoaded', initList);
+  document.addEventListener('htmx:load', initList);
+  document.addEventListener('htmx:historyRestore', () => { currentPage = undefined; initList(); });
+  window.addEventListener('pageshow', initList);
+})();

+ 79 - 0
static/assets/js/navigation.js

@@ -0,0 +1,79 @@
+/* Return state is per tab and user; only URLs and invoice keys are stored. */
+(() => {
+  const listPath = '/app/forderungen/liste';
+  let memory;
+  const processed = new WeakSet();
+  const storageKey = () => `gc-list-return:${document.body.dataset.gcUser || ''}`;
+  const canonical = value => {
+    const url = new URL(value, location.origin);
+    url.searchParams.delete('focus');
+    url.searchParams.delete('page');
+    url.searchParams.delete('limit');
+    url.searchParams.sort();
+    return url.pathname + url.search;
+  };
+  const read = () => {
+    try { return JSON.parse(sessionStorage.getItem(storageKey())) || memory; }
+    catch { return memory; }
+  };
+  const clear = () => {
+    memory = undefined;
+    try { sessionStorage.removeItem(storageKey()); } catch { /* Storage can be disabled. */ }
+  };
+  function remember(value) {
+    if (!value) return;
+    const url = new URL(value, location.origin);
+    if (url.origin !== location.origin || url.pathname !== listPath) return;
+    memory = { returnUrl: url.pathname + url.search, listUrl: canonical(url), user: document.body.dataset.gcUser || '' };
+    try { sessionStorage.setItem(storageKey(), JSON.stringify(memory)); } catch { /* Use document memory. */ }
+  }
+  function refreshReturn(event) {
+    if (location.pathname !== listPath) return false;
+    const state = read();
+    if (!state || state.user !== (document.body.dataset.gcUser || '') || state.listUrl !== canonical(location.href)) return false;
+    // Do not let HTMX paint an old history snapshot before the fresh GET.
+    event?.stopImmediatePropagation();
+    const url = new URL(state.returnUrl, location.origin);
+    if (url.origin !== location.origin || url.pathname !== listPath) { clear(); return false; }
+    location.replace(url.pathname + url.search);
+    return true;
+  }
+  async function initialize() {
+    const back = document.querySelector('[data-gc-return-url]');
+    if (back) remember(back.dataset.gcReturnUrl);
+    const state = document.getElementById('gc-list-state');
+    if (!state || processed.has(state)) return;
+    processed.add(state);
+    const focus = state.dataset.focus;
+    if (!focus) return;
+    clear();
+    const row = [...document.querySelectorAll('.gc-invoice-row[data-primary-key]')]
+      .find(node => node.dataset.primaryKey === focus);
+    if (!row) return;
+    await Promise.race([document.fonts?.ready, new Promise(resolve => setTimeout(resolve, 500))]);
+    await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    if (!row.isConnected) return;
+    const top = (document.querySelector('.gc-app-header')?.offsetHeight || 0)
+      + (document.querySelector('#invoice-list thead')?.offsetHeight || 0) + 16;
+    const bottom = (document.querySelector('.gc-list-summary')?.offsetHeight || 0) + 16;
+    const rect = row.getBoundingClientRect();
+    row.focus({ preventScroll: true });
+    window.scrollTo({ top: Math.max(0, scrollY + rect.top - top - Math.max(0, (innerHeight - top - bottom - rect.height) / 2)), behavior: 'instant' });
+    row.classList.add('gc-return-highlight');
+    setTimeout(() => row.classList.remove('gc-return-highlight'), 3000);
+  }
+  document.addEventListener('click', event => {
+    const link = event.target.closest('[data-gc-detail-link]');
+    // New tabs receive their own return_to URL; leave this tab's state alone.
+    if (link && event.button === 0 && !event.ctrlKey && !event.metaKey && !event.shiftKey && link.target !== '_blank') remember(link.dataset.returnUrl);
+  });
+  window.addEventListener('popstate', refreshReturn, { capture: true });
+  window.addEventListener('pageshow', event => {
+    if (!event.persisted || !refreshReturn(event)) initialize();
+  });
+  document.addEventListener('DOMContentLoaded', initialize);
+  document.addEventListener('htmx:load', initialize);
+  document.addEventListener('htmx:historyRestore', event => {
+    if (!refreshReturn(event)) initialize();
+  }, { capture: true });
+})();

+ 84 - 0
static/assets/js/verursacher.js

@@ -0,0 +1,84 @@
+/* A single modal serves both list rows and the independent detail field. */
+(() => {
+  let trigger;
+  const initialized = new WeakSet();
+  const host = () => document.getElementById('verursacher-modal');
+  function init(root = document) {
+    const form = root.matches?.('[data-gc-verursacher-form]') ? root : root.querySelector?.('[data-gc-verursacher-form]');
+    if (!form || initialized.has(form)) return;
+    initialized.add(form);
+    const role = form.querySelector('#verursacher-role'), user = form.querySelector('#verursacher-user');
+    const options = Array.from(user.options).map(option => option.cloneNode(true));
+    const status = form.querySelector('.gc-assignee-status'), save = form.querySelector('[data-gc-assign]');
+    const update = () => { save.disabled = !user.value; };
+    const filterUsers = () => {
+      const previous = user.value;
+      user.replaceChildren(...options.filter(option => !option.value || !role.value || JSON.parse(option.dataset.roles).includes(role.value)).map(option => option.cloneNode(true)));
+      user.value = previous;
+      if (user.selectedIndex < 0) user.value = '';
+      status.textContent = previous && !user.value ? 'Die bisherige Auswahl gehört nicht zur gewählten Rolle. Bitte einen Benutzer auswählen.' : '';
+      if (user.options.length === 1) status.textContent = 'Keine Benutzer für diese Rolle verfügbar.';
+      update();
+    };
+    role.addEventListener('change', filterUsers);
+    user.addEventListener('change', update);
+    form.addEventListener('submit', event => {
+      if (form.dataset.sending === 'true') { event.preventDefault(); event.stopImmediatePropagation(); }
+    }, true);
+    if (role.value) filterUsers();
+    update();
+    if (host()?.classList.contains('show')) role.focus();
+  }
+  document.addEventListener('htmx:beforeRequest', event => {
+    if (event.detail.elt.matches('.gc-verursacher-edit')) {
+      trigger = event.detail.elt;
+      const content = document.getElementById('verursacher-modal-content');
+      content.innerHTML = '<div class="modal-header"><h2 class="modal-title fs-5" id="verursacher-modal-title">Verursacher ändern</h2><button type="button" class="btn-close" data-coreui-dismiss="modal" aria-label="Schließen"></button></div><div class="modal-body" role="status">Benutzer werden geladen …</div>';
+      coreui.Modal.getOrCreateInstance(host()).show();
+    }
+    if (event.detail.elt.matches('[data-gc-verursacher-form]')) {
+      event.detail.elt.dataset.sending = 'true';
+      event.detail.elt.setAttribute('aria-busy', 'true');
+      event.detail.elt.querySelector('.gc-assignee-status').textContent = 'Wird gespeichert …';
+      event.detail.elt.querySelectorAll('select').forEach(select => { select.disabled = true; });
+    }
+  });
+  document.addEventListener('htmx:beforeSwap', event => {
+    if (event.detail.target?.id === 'verursacher-modal-content' && [422, 503].includes(event.detail.xhr.status)) {
+      // Authentication/service errors can be JSON; only swap our own modal form.
+      if (event.detail.xhr.responseText.includes('data-gc-verursacher-form')) {
+        event.detail.shouldSwap = true; event.detail.isError = false;
+      }
+    }
+  });
+  document.addEventListener('htmx:afterRequest', event => {
+    const form = event.detail.elt;
+    if (!form.matches('[data-gc-verursacher-form]')) return;
+    form.dataset.sending = 'false'; form.removeAttribute('aria-busy');
+    form.querySelectorAll('select').forEach(select => { select.disabled = false; });
+  });
+  function requestError(event) {
+    if (event.detail.target?.id !== 'verursacher-modal-content' && !event.detail.elt?.matches('.gc-verursacher-edit, [data-gc-verursacher-form]')) return;
+    const content = document.getElementById('verursacher-modal-content');
+    if (!content) return;
+    let message = content.querySelector('.gc-assignee-status, [role=status]');
+    if (!message) { message = document.createElement('p'); message.setAttribute('role', 'alert'); content.append(message); }
+    message.textContent = 'Die Anfrage konnte nicht abgeschlossen werden. Bitte Verbindung und Zugriffsrechte prüfen und erneut versuchen.';
+  }
+  document.addEventListener('htmx:responseError', requestError);
+  document.addEventListener('htmx:sendError', requestError);
+  document.addEventListener('gc:verursacherSaved', () => {
+    coreui.Modal.getInstance(host())?.hide();
+  });
+  document.addEventListener('hidden.coreui.modal', event => {
+    if (event.target !== host()) return;
+    // The detail button is replaced out-of-band after a successful save.
+    const focus = trigger?.isConnected ? trigger : document.querySelector('#workflow-verursacher .gc-verursacher-edit');
+    focus?.focus({preventScroll: true});
+  });
+  document.addEventListener('shown.coreui.modal', event => {
+    if (event.target === host()) document.getElementById('verursacher-role')?.focus();
+  });
+  document.addEventListener('DOMContentLoaded', () => init());
+  document.addEventListener('htmx:load', event => init(event.detail.elt));
+})();

+ 61 - 0
static/assets/js/wiedervorlage.js

@@ -0,0 +1,61 @@
+/* The date shortcuts only edit the form; saving requires an explicit submit. */
+(() => {
+  let trigger;
+  const host = () => document.getElementById('wiedervorlage-modal');
+  const content = () => document.getElementById('wiedervorlage-modal-content');
+  document.addEventListener('click', event => {
+    const button = event.target.closest('[data-gc-date]');
+    if (!button || !button.closest('[data-gc-wiedervorlage-form]')) return;
+    const field = document.getElementById('wiedervorlage-date');
+    field.value = button.dataset.gcDate;
+    field.dispatchEvent(new Event('input', {bubbles: true}));
+    field.focus();
+  });
+  document.addEventListener('submit', event => {
+    if (event.target.matches('[data-gc-wiedervorlage-form]') && event.target.dataset.sending === 'true') {
+      event.preventDefault(); event.stopImmediatePropagation();
+    }
+  }, true);
+  document.addEventListener('htmx:beforeRequest', event => {
+    if (event.detail.elt.matches('.gc-wiedervorlage-edit')) {
+      trigger = event.detail.elt;
+      content().innerHTML = '<div class="modal-header"><h2 class="modal-title fs-5" id="wiedervorlage-modal-title">Wiedervorlage ändern</h2><button type="button" class="btn-close" data-coreui-dismiss="modal" aria-label="Schließen"></button></div><div class="modal-body" role="status">Datum wird geladen …</div>';
+      coreui.Modal.getOrCreateInstance(host()).show();
+    }
+    const form = event.detail.elt;
+    if (!form.matches('[data-gc-wiedervorlage-form]')) return;
+    form.dataset.sending = 'true'; form.setAttribute('aria-busy', 'true');
+    form.querySelector('[type=date]').disabled = true;
+    form.querySelector('.gc-date-status').textContent = 'Wird gespeichert …';
+  });
+  document.addEventListener('htmx:beforeSwap', event => {
+    if (event.detail.target?.id === 'wiedervorlage-modal-content' && [422, 503].includes(event.detail.xhr.status)
+        && event.detail.xhr.responseText.includes('data-gc-wiedervorlage-form')) {
+      event.detail.shouldSwap = true; event.detail.isError = false;
+    }
+  });
+  document.addEventListener('htmx:afterRequest', event => {
+    const form = event.detail.elt;
+    if (!form.matches('[data-gc-wiedervorlage-form]')) return;
+    form.dataset.sending = 'false'; form.removeAttribute('aria-busy');
+    form.querySelector('[type=date]').disabled = false;
+  });
+  function requestError(event) {
+    if (event.detail.target?.id !== 'wiedervorlage-modal-content' && !event.detail.elt?.matches('.gc-wiedervorlage-edit, [data-gc-wiedervorlage-form]')) return;
+    const message = content()?.querySelector('.gc-date-status, [role=status]');
+    if (message) message.textContent = 'Die Anfrage konnte nicht abgeschlossen werden. Bitte Verbindung und Zugriffsrechte prüfen und erneut versuchen.';
+  }
+  document.addEventListener('htmx:responseError', requestError);
+  document.addEventListener('htmx:sendError', requestError);
+  document.addEventListener('hidden.coreui.modal', event => {
+    if (event.target === host() && trigger?.isConnected) trigger.focus({preventScroll: true});
+  });
+  document.addEventListener('shown.coreui.modal', event => {
+    if (event.target === host()) document.getElementById('wiedervorlage-date')?.focus();
+  });
+  document.addEventListener('htmx:load', event => {
+    if (host()?.classList.contains('show') && event.detail.elt.closest?.('#wiedervorlage-modal')) {
+      document.getElementById('wiedervorlage-date')?.focus();
+    }
+  });
+})();

+ 49 - 137
templates/base/base.html

@@ -8,14 +8,15 @@
   <meta name="description" content="Global Cube">
   <meta name="author" content="Global Cube GmbH - Robert Burghard">
   <meta name="keyword" content="Bootstrap,Admin,Template,Open,Source,jQuery,CSS,HTML,RWD,Dashboard">
-  <title>Global Cube</title>
+  <title>{% block title %}Global Cube{% endblock %}</title>
   <script src="https://cdn.jsdelivr.net/npm/htmx.org@2.0.8/dist/htmx.min.js"></script>
 
-  <link href="https://cdn.jsdelivr.net/npm/@coreui/coreui@5.6.1/dist/css/coreui.min.css" rel="stylesheet">
-  <link href="https://cdn.jsdelivr.net/npm/@coreui/icons@3.0.1/css/all.min.css" rel="stylesheet">
+  <link href="https://cdn.jsdelivr.net/npm/@coreui/coreui-pro@5.27.0/dist/css/coreui.min.css" rel="stylesheet">
+  <script src="https://cdn.jsdelivr.net/npm/@coreui/coreui-pro@5.27.0/dist/js/coreui.bundle.min.js"></script>
 
-  <script src="https://cdn.jsdelivr.net/npm/@coreui/coreui@5.6.1/dist/js/coreui.bundle.min.js"></script>
+  <link href="https://cdn.jsdelivr.net/npm/@coreui/icons@3.0.1/css/all.min.css" rel="stylesheet">
   <script src="https://cdn.jsdelivr.net/npm/@coreui/icons@3.0.1/dist/cjs/index.min.js"></script>
+  
   <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.11.8/dist/umd/popper.min.js"></script>
 
   <link rel="preconnect" href="https://fonts.googleapis.com">
@@ -23,159 +24,70 @@
   <link href="https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap" rel="stylesheet">
 
   <link href="/static/assets/css/main.css" rel="stylesheet">
-  <link href="/static/assets/css/redesign.css" rel="stylesheet">
+  <link href="/static/assets/css/app.css" rel="stylesheet">
+
+  <link href="/static/assets/css/details.css" rel="stylesheet">
+  <link href="/static/assets/css/list.css" rel="stylesheet">
+  <link href="/static/assets/css/dashboard.css" rel="stylesheet">
+  <script src="/static/assets/js/dashboard.js" defer></script>
+  <script src="/static/assets/js/attachments.js" defer></script>
+  <script src="/static/assets/js/navigation.js" defer></script>
+  <script src="/static/assets/js/list.js" defer></script>
+  <script src="/static/assets/js/layout.js" defer></script>
+  <script src="/static/assets/js/verursacher.js" defer></script>
+  <script src="/static/assets/js/wiedervorlage.js" defer></script>
 
   <!-- Favicon icon -->
   <link rel="icon" href="/static/assets/images/favicon.ico" type="image/x-icon">
 </head>
 
-<body class="container" hx-boost="true">
-  <!--<nav class="navbar navbar-expand-lg bg-primary">
-    <div class="container-fluid">
-        <a class="navbar-brand" href="#">Navbar</a>
-        <button class="navbar-toggler" type="button" data-coreui-toggle="collapse" data-coreui-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
-        <span class="navbar-toggler-icon"></span>
-        </button>
-        <div class="collapse navbar-collapse" id="navbarNav">
-        <ul class="navbar-nav">
-            <li class="nav-item">
-            <a class="nav-link active" aria-current="page" href="#">Home</a>
-            </li>
-            <li class="nav-item">
-            <a class="nav-link" href="#">Features</a>
-            </li>
-            <li class="nav-item">
-            <a class="nav-link" href="#">Pricing</a>
-            </li>
-            <li class="nav-item">
-            <a class="nav-link disabled" aria-disabled="true">Disabled</a>
-            </li>
-        </ul>
-        </div>
-    </div>
-    </nav>-->
+<body class="container" data-gc-user="{{ request.state.principal.username }}" hx-boost="true" hx-headers='{"X-CSRF-Token": "{{ request.state.principal.csrf }}"}'>
   <div class="wrapper d-flex flex-column min-vh-100">
-    <header class="header header-sticky p-0 mb-4">
-      <div class="container-fluid border-bottom px-4">
-        <button class="header-toggler" type="button"
-          onclick="coreui.Sidebar.getInstance(document.querySelector('#sidebar')).toggle()"
-          style="margin-inline-start: -14px;">
-          <i class="icon icon-lg cil-menu"></i>
-        </button>
-        <ul class="header-nav d-none d-lg-flex">
+    <header class="header gc-app-header">
+      <div class="container-fluid gc-header-inner">
+        <a class="gc-header-brand" href="/select" aria-label="Reisacher – Startseite">
+          <img src="/static/assets/images/Reisacher.png" alt="Reisacher" width="360" height="94">
+        </a>
+        <ul class="header-nav">
           <li class="nav-item"><a class="nav-link" href="/app/forderungen/liste">Liste</a></li>
-          <li class="nav-item"><a class="nav-link" href="/app/forderungen/dashboard">Dashboard</a></li>
+          <li class="nav-item"><a class="nav-link" href="/app/forderungen/dashboard" hx-boost="false">Dashboard</a></li>
         </ul>
-        <ul class="header-nav ms-auto">
-          <li class="nav-item"><a class="nav-link" href="/select">
+        <ul class="header-nav ms-auto gc-header-tools">
+          <li class="nav-item"><a class="nav-link" href="/select" aria-label="Startseite">
               <i class="icon icon-lg cil-home"></i></a></li>
-          <li class="nav-item"><a class="nav-link" href="/config">
+          <li class="nav-item"><a class="nav-link" href="/config" aria-label="Einstellungen">
               <i class="icon icon-lg cil-cog"></i></a></li>
-          <li class="nav-item"><a class="nav-link" href="/logout">
-              <i class="icon icon-lg cil-user"></i></a></li>
-        </ul>
-        <!--
-        <ul class="header-nav">
-          <li class="nav-item py-1">
-            <div class="vr h-100 mx-2 text-body text-opacity-75"></div>
-          </li>
-
-          <li class="nav-item dropdown">
-            <button class="btn btn-link nav-link py-2 px-2 d-flex align-items-center" type="button"
-              aria-expanded="false" data-coreui-toggle="dropdown">
-              <i class="icon icon-lg theme-icon-active cil-contrast"></i>
-            </button>
-            <ul class="dropdown-menu dropdown-menu-end" style="--cui-dropdown-min-width: 8rem;">
-              <li>
-                <button class="dropdown-item d-flex align-items-center" type="button" data-coreui-theme-value="light">
-                  <i class="icon icon-lg me-3 cil-sun"></i> Light
-                </button>
-              </li>
-              <li>
-                <button class="dropdown-item d-flex align-items-center" type="button" data-coreui-theme-value="dark">
-                  <i class="icon icon-lg me-3 cil-moon"></i> Dark
-                </button>
-              </li>
-              <li>
-                <button class="dropdown-item d-flex align-items-center active" type="button"
-                  data-coreui-theme-value="auto">
-                  <i class="icon icon-lg me-3 cil-contrast"></i> Auto
-                </button>
-              </li>
-            </ul>
-          </li>
-          <li class="nav-item py-1">
-            <div class="vr h-100 mx-2 text-body text-opacity-75"></div>
-          </li>
-          <li class="nav-item dropdown"><a class="nav-link py-0 pe-0" data-coreui-toggle="dropdown" href="#"
-              role="button" aria-haspopup="true" aria-expanded="false">
-              <div class="avatar avatar-md"><img class="avatar-img" src="/static/assets/img/avatars/winter.jpg"
-                  alt="winter@global-cube.de">
-              </div>
-            </a>
-            <div class="dropdown-menu dropdown-menu-end pt-0">
-              <div class="dropdown-header bg-body-tertiary text-body-secondary fw-semibold rounded-top mb-2">Account
-              </div><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-bell"></i> Updates<span class="badge badge-sm bg-info ms-2">42</span></a><a
-                class="dropdown-item" href="#">
-                <i class="icon me-2 cil-envelope-open"></i> Messages<span
-                  class="badge badge-sm bg-success ms-2">42</span></a><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-task"></i> Tasks<span class="badge badge-sm bg-danger ms-2">42</span></a><a
-                class="dropdown-item" href="#">
-                <i class="icon me-2 cil-comment-square"></i> Comments<span
-                  class="badge badge-sm bg-warning ms-2">42</span></a>
-              <div class="dropdown-header bg-body-tertiary text-body-secondary fw-semibold my-2">
-                <div class="fw-semibold">Settings</div>
-              </div><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-user"></i> Profile</a><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-settings"></i> Settings</a><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-credit-card"></i> Payments<span
-                  class="badge badge-sm bg-secondary ms-2">42</span></a><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-file"></i> Projects<span class="badge badge-sm bg-primary ms-2">42</span></a>
-              <div class="dropdown-divider"></div><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-lock-locked"></i> Lock Account</a><a class="dropdown-item" href="#">
-                <i class="icon me-2 cil-account-logout"></i> Logout</a>
-            </div>
+          <li class="nav-item d-flex align-items-center gc-header-account">
+            <span class="me-2">{{ request.state.principal.name }} ({{ request.state.principal.role }})</span>
+            <form method="post" action="/logout" class="m-0">
+              <input type="hidden" name="_csrf" value="{{ request.state.principal.csrf }}">
+              <button type="submit" class="nav-link border-0 bg-transparent" title="Abmelden">
+                <i class="icon icon-lg cil-account-logout"></i>
+              </button>
+            </form>
           </li>
         </ul>
-        -->
       </div>
     </header>
-    <main role="main" class="gc-page">
-      <div class="container-fluid px-6">
-        <img src="/static/assets/images/Reisacher.png">
-        <!--<strong>Forderungsmanagement</strong>-->
-      </div>
-
+    <main role="main" class="gc-page {% block page_class %}{% endblock %}">
       {% block content %}{% endblock %}
     </main>
   </div>
 
   {% if summary %}
-  <footer class="footer footer-sticky">
-    <div class="container-fluid">
-      <div class="row mb-3">
-        <div class="col-sm-3">
-          Datensätze: {{ summary.Anzahl }}
-        </div>
-        <div class="col-sm-6">
-          Filter:
-          {% for f in filter_config %}
-
-          {% if f.filter_type != 'hidden' and f.current_value != f.default_value %}
-          {{ f.text }} = '{{ f.current_value }}' |
-          {% endif %}
-
-          {% endfor %}
-        </div>
-        <div class="col-sm-3 text-end">
-          Gesamt: <strong>{{ summary.Beleg_offen|number_format }}</strong>
-        </div>
-      </div>
-    </div>
-  </footer>
+  {% include 'forderungen/liste/summary.html' %}
   {% endif %}
 
+<div class="modal fade gc-editor-modal" id="verursacher-modal" tabindex="-1" aria-labelledby="verursacher-modal-title" aria-hidden="true">
+  <div class="modal-dialog modal-dialog-centered">
+    <div class="modal-content" id="verursacher-modal-content"></div>
+  </div>
+</div>
+<div class="modal fade gc-editor-modal" id="wiedervorlage-modal" tabindex="-1" aria-labelledby="wiedervorlage-modal-title" aria-hidden="true">
+  <div class="modal-dialog modal-dialog-centered">
+    <div class="modal-content" id="wiedervorlage-modal-content"></div>
+  </div>
+</div>
 </body>
 
-</html>
+</html>

+ 24 - 460
templates/base/chat_container.html

@@ -1,478 +1,42 @@
-<div class="chat-container" id="chat">
-    <div class="header">
-        <div class="header-left">
-            <div class="avatar" style="background-color: #5468FF;">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                    stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                    <path
-                        d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z">
-                    </path>
-                </svg>
-            </div>
-            <div class="course-info">
-                <div class="course-title">{{ forderungen_details[0].Kunde_Text }} / {{ forderungen_details[0].Beleg_Nr }}</div>
-                <div class="course-participants">4 Mitarbeiter involviert</div>
-            </div>
-        </div>
-        <div class="header-actions">
-            <button class="icon-button tooltip" data-tooltip="Search">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                    stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                    <circle cx="11" cy="11" r="8"></circle>
-                    <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
-                </svg>
-            </button>
-            <button class="icon-button tooltip" data-tooltip="Resource Library">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                    stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                    <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"></path>
-                    <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"></path>
-                </svg>
-            </button>
-            <button class="icon-button tooltip" data-tooltip="Settings">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                    stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                    <circle cx="12" cy="12" r="3"></circle>
-                    <path
-                        d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z">
-                    </path>
-                </svg>
-            </button>
-        </div>
-    </div>
-    <div class="tabs">
-        <div class="tab active">Diese Rechnung</div>
-        <div class="tab">Alle offenen Rechnungen</div>
-        <div class="tab">Dieses Fahrzeug</div>
-        <div class="tab">Debitor Historie</div>
-    </div>
-    <div class="chat-content" id="chatContent">
-        <div class="date-divider">
-            <div class="divider-line"></div>
-            <div class="divider-text">{{ forderungen_details[0].Beleg_Datum|date_format }}</div>
-            <div class="divider-line"></div>
-        </div>
-        <!--
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">DKI</div>
-                <div class="sender-name">Daniel Klingenstein</div>
-                <div class="timestamp">04.01.2025</div>
-            </div>
-            <div class="message-bubble">
-                Korrigierte Werkstattrechnung
-            </div>
-            <div class="embed-content">
-                <div class="embed-header">
-                    <div class="embed-icon">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                            stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                            <polygon points="1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6"></polygon>
-                            <line x1="8" y1="2" x2="8" y2="18"></line>
-                            <line x1="16" y1="6" x2="16" y2="22"></line>
-                        </svg>
-                    </div>
-                    <div class="embed-title">Rechnung WRG25400108</div>
-                </div>
-                <div class="embed-body">
-                    <img src="/static/assets/images/vorschau.jpg" alt="Rechnung WRG25400108" class="embed-image"  style="height:30px;">
-                    <div class="embed-text">
-                        ...
-                    </div>
-                </div>
-                <div class="embed-footer">
-                    <button class="embed-button" id="openResourceBtn">Öffnen</button>
-                </div>
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">22.01.2025</div>
-            </div>
-            <div class="message-bubble">
-                AZ 3120/24 HP Schaden Rep RE kann nicht eingereicht werden. ESW Zusatzprodukte fehlen
-            </div>
-        </div>-->
-        {% for row in forderungen_kommentare %}
-        <div class="message teacher {{ row.Rolle }}">
-            <div class="message-header">
-                <div class="avatar">{{ row.Benutzer_ID }}</div>
-                <div class="sender-name">{{ row.Name }}</div>
-                <div class="timestamp">{{ row.Timestamp|date_format }}</div>
-            </div>
-            <div class="message-bubble">
-                {{ row.Kommentar }}
-            </div>
-        </div>
-        {% endfor %}
-
-        <div id="chat-end">
-            &nbsp;
-        </div>
-
-        <!--
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">11.03.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="date-divider">
-            <div class="divider-line"></div>
-            <div class="divider-text">Q2/2025</div>
-            <div class="divider-line"></div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">01.04.2025</div>
-            </div>
-            <div class="message-bubble">
-                Akteneinsicht liegt nun vor, im Diktat
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">14.04.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">22.04.2025</div>
-            </div>
-            <div class="message-bubble">
-                Nachgefordert
-            </div>
-            <div class="embed-content">
-                <div class="embed-header">
-                    <div class="embed-icon">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                            stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                            <polygon points="1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6"></polygon>
-                            <line x1="8" y1="2" x2="8" y2="18"></line>
-                            <line x1="16" y1="6" x2="16" y2="22"></line>
-                        </svg>
-                    </div>
-                    <div class="embed-title">Mahnung</div>
-                </div>
-                <div class="embed-body">
-                    <img src="/static/assets/images/vorschau.jpg" alt="Mahnung 993413" class="embed-image" style="height:30px;">
-                    <div class="embed-text">
-                        ...
-                    </div>
-                </div>
-                <div class="embed-footer">
-                    <button class="embed-button" id="openResourceBtn">Öffnen</button>
-                </div>
-            </div>
-        </div>
-
-
-
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">09.05.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">03.06.2025</div>
-            </div>
-            <div class="message-bubble">
-                RA schreibt KD an ob geklagt werden soll und RS besteht
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">23.06.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">23.06.2025</div>
-            </div>
-            <div class="message-bubble">
-                Akte im Diktat
-            </div>
-        </div>
-        <div class="date-divider">
-            <div class="divider-line"></div>
-            <div class="divider-text">Q3/2025</div>
-            <div class="divider-line"></div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">01.07.2025</div>
-            </div>
-            <div class="message-bubble">
-                Warten auf RÜ Polizei
-            </div>
-        </div>
-
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">15.07.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">22.07.2025</div>
-            </div>
-            <div class="message-bubble">
-                Warten auf Rückmeldung Mdt wg Rechtschutz
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">11.08.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">19.08.2025</div>
-            </div>
-            <div class="message-bubble">
-                ST bez. Mit STN S+W wird nachgefordert
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">08.09.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="date-divider">
-            <div class="divider-line"></div>
-            <div class="divider-text">Q4/2025</div>
-            <div class="divider-line"></div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">14.10.2025</div>
-            </div>
-            <div class="message-bubble">
-                Klage in Vorbereitung WV 18.11.2025
-            </div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">25.11.2025</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">MDE</div>
-                <div class="sender-name">Maria Dietrich</div>
-                <div class="timestamp">30.11.2025</div>
-            </div>
-            <div class="message-bubble">
-                EWB
-            </div>
-            <div class="embed-content">
-                <div class="embed-header">
-                    <div class="embed-icon">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none"
-                            stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                            <polygon points="1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6"></polygon>
-                            <line x1="8" y1="2" x2="8" y2="18"></line>
-                            <line x1="16" y1="6" x2="16" y2="22"></line>
-                        </svg>
-                    </div>
-                    <div class="embed-title">EWB 20% 11/2025</div>
-                </div>
-                <div class="embed-body">
-                    <img src="/static/assets/images/vorschau.jpg" alt="Buchung" class="embed-image" style="height:30px;">
-                    <div class="embed-text">
-                        ...
-                    </div>
-                </div>
-                <div class="embed-footer">
-                    <button class="embed-button" id="openResourceBtn">Öffnen</button>
-                </div>
-            </div>
-        </div>
-
-        <div class="message student">
-            <div class="message-header">
-                <div class="avatar">CVE</div>
-                <div class="sender-name">Carolin Vetter</div>
-                <div class="timestamp">04.12.2025</div>
-            </div>
-            <div class="message-bubble">
-                gerichtliches Verfahren läuft WV 02/26
-            </div>
-        </div>
-
-        <div class="date-divider">
-            <div class="divider-line"></div>
-            <div class="divider-text">Q1/2026</div>
-            <div class="divider-line"></div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">19.02.2026</div>
-            </div>
-            <div class="message-bubble">
-                Stand RA
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">09.03.2026</div>
-            </div>
-            <div class="message-bubble">
-                Schreiben von RAW erhalten. Sehr verwirrend, nochmals nachgefragt
-            </div>
-        </div>
-
-        <div class="message teacher">
-            <div class="message-header">
-                <div class="avatar">JAK</div>
-                <div class="sender-name">Jennifer Walk</div>
-                <div class="timestamp">10.03.2026</div>
-            </div>
-            <div class="message-bubble">
-                Vergleich mit HP Versicherung nun KD angeschrieben ob bei seiner Kasko eingereicht wird oder nicht
-            </div>
-        </div>
-    -->
-
-    </div>
+<div class="chat-container" id="chat"
+    hx-on::after-swap="const content = this.querySelector('#chatContent'); if (content) content.scrollTop = content.scrollHeight;">
+    <h2 class="gc-section-title" id="comments-title"><i class="icon cil-chat-bubble" aria-hidden="true"></i> Kommentare</h2>
+    <p class="gc-section-description">{{ forderungen_details[0].Kunde_Text }} / {{ forderungen_details[0].Beleg_Nr }}</p>
+    {% include 'forderungen/details/details_kommentare.html' %}
     <div class="input-area">
         <div class="toolbar">
-            <form>
-                <button class="btn btn-primary">
+            <form id="comment-form" method="post" action="{{ detail_post_url|default(detail_url) }}" hx-post="{{ detail_post_url|default(detail_url) }}"
+                hx-target="#comments-history" hx-swap="outerHTML" hx-push-url="false"
+                hx-sync="#comments-history:replace"
+                hx-disabled-elt="#comments-history button" enctype="multipart/form-data" hx-encoding="multipart/form-data"
+                data-max-file-size="{{ upload_max_bytes|default(50 * 1024 * 1024) }}" data-max-file-size-mb="{{ upload_max_mb|default(50) }}">
+                <input type="hidden" name="_csrf" value="{{ request.state.principal.csrf }}" />
+                <input type="file" name="attachments" id="comment-attachments" multiple hidden>
+                <input type="hidden" name="attachment_ids" value="[]">
+                <div class="gc-comment-compose">
+                <button type="button" class="btn btn-outline-secondary" data-gc-attach aria-label="Dateien anhängen" title="Dateien anhängen">
                     <i class="icon icon-lg cil-paperclip"></i>
                 </button>
                 <input type="hidden" name="source" value="comments" />
                 <input type="text" class="message-input" id="comment" name="Kommentar" placeholder="Kommentieren ..."
-                    autofocus="autofocus" />
-                <button class="btn btn-primary" hx-post="" hx-trigger="click" hx-swap="outerHTML" hx-target="#chat" hx-push-url="false">
-                    <i class="icon icon-lg cil-chevron-right"></i>
+                    aria-label="Kommentar" aria-describedby="attachment-hint" />
+                <button type="submit" class="btn btn-primary" disabled>Abschicken
                 </button>
+                </div>
+                <p class="gc-upload-hint" id="attachment-hint">Dateien hier ablegen oder über die Büroklammer auswählen. Max. {{ upload_max_mb|default(50) }} MB je Datei.</p>
+                <ul class="gc-upload-queue" aria-label="Ausgewählte Dateien"></ul>
+                <p class="gc-upload-status" role="status" aria-live="polite"></p>
             </form>
 
 
 
-            <div class="chat-input" style="display: none;">
-                <div class="input-container">
-                    <div class="input-actions">
-                        <button class="btn input-btn" id="attachBtn" title="Attach file">
-                            <i class="icon icon-lg cil-paperclip"></i>
-                        </button>
-                    </div>
-                    <input type="text" id="messageInput" placeholder="Type a message, use # for tasks, @ for people...">
-                </div>
-                <button class="send-btn" id="sendBtn">
-                    <i class="icon icon-lg cil-chevron-right"></i>
-                </button>
-
-                <!-- File Upload Preview -->
-                <div class="file-preview" id="filePreview" style="display:none;">
-                    <div class="file-preview-header">
-                        <span>File to upload</span>
-                        <button class="file-preview-close" onclick="closeFilePreview()">
-                            <i class="fas fa-times"></i>
-                        </button>
-                    </div>
-                    <div class="file-preview-content">
-                        <div class="file-preview-icon">
-                            <i class="fas fa-file"></i>
-                        </div>
-                        <div class="file-preview-details">
-                            <div class="file-preview-name">document.pdf</div>
-                            <div class="file-preview-size">3.2 MB</div>
-                        </div>
-                    </div>
-                </div>
-            </div>
         </div>
     </div>
 </div>
 
 <script>
     window.setTimeout(function() {
-        let element = document.getElementById("chat-end");
-        element.scrollIntoView({ behavior: "smooth", block: "end" });
+        const content = document.getElementById("chatContent");
+        if (content) content.scrollTop = content.scrollHeight;
     }, 1000);
-</script>
+</script>

+ 26 - 61
templates/base/liste.html

@@ -1,66 +1,31 @@
 {% extends "base/base.html" %}
-
+{% block title %}Forderungen | Liste{% endblock %}
+{% block page_class %}gc-list-page{% endblock %}
 {% block content %}
-
-
-
-{# =========================================================
-FILTERBEREICH
----------------------------------------------------------
-Oberer Bereich mit:
-- Dropdowns
-- Suchfeldern
-- Datumsfiltern
-- Bereichsfiltern
-========================================================= #}
-<div class="gc-card gc-filterbar">
-
-  {% include 'base/liste_filter.html' %}
-
+<div id="gc-list-state" data-list-url="{{ list_url }}" data-focus="{{ focus or '' }}" hidden></div>
+<h1>Forderungen</h1>
+{% if dashboard_segment %}
+<div class="gc-return-status" role="status"><strong>Dashboardfilter:</strong> {{ dashboard_segment_label }}
+  <a class="ms-2" href="{{ without_dashboard_segment }}">Dashboardfilter entfernen</a>
 </div>
-
-
-
-{# =========================================================
-TABELLEN-CONTAINER
----------------------------------------------------------
-Enthält die komplette Forderungsliste.
-
-Klassen:
-- gc-card → Kartenlayout
-- gc-table-wrap → Scroll-/Tabellencontainer
-========================================================= #}
-<div class="gc-card gc-table-wrap">
-
-  <table class="table gc-table table-hover align-middle">
-
-    {# =====================================================
-    TABELLENKOPF
-    -----------------------------------------------------
-    Enthält:
-    - Spaltenüberschriften
-    - Sticky Header
-    ====================================================== #}
-    <thead>
-
-      {% include 'forderungen/liste/liste_kopfzeile.html' %}
-
-    </thead>
-
-
-    {# =====================================================
-    TABELLENINHALT
-    -----------------------------------------------------
-    Enthält alle Datensätze / Tabellenzeilen
-    ====================================================== #}
-    <tbody>
-
-      {% include 'base/liste_tabelle.html' %}
-
-    </tbody>
-  </table>
-</div>
-
+{% endif %}
+{% if focus_missing %}
+<p class="gc-return-status" role="status">Die betreffende Rechnung ist in der aktualisierten Ergebnisliste nicht mehr enthalten. Ihre Filter wurden beibehalten.</p>
+{% endif %}
+<section class="gc-card" aria-labelledby="list-filter-title">
+  <h2 class="gc-section-title" id="list-filter-title"><i class="icon cil-filter" aria-hidden="true"></i> Filter</h2>
+  <div class="gc-list-filter-content">{% include 'base/liste_filter.html' %}</div>
+</section>
+<section class="gc-card gc-list-table-region" aria-labelledby="list-table-title">
+  <h2 class="gc-section-title" id="list-table-title"><i class="icon cil-list" aria-hidden="true"></i> Forderungsliste</h2>
+  <div class="gc-list-table-scroll" tabindex="0" role="region" aria-label="Forderungstabelle – horizontal scrollbar">
+    <table class="table gc-list-table" id="invoice-list">
+      <caption class="visually-hidden">Gefilterte Forderungen mit Beleg-, Kunden- und Bearbeitungsinformationen</caption>
+      <thead>{% include 'forderungen/liste/liste_kopfzeile.html' %}</thead>
+      <tbody>{% include 'base/liste_tabelle.html' %}</tbody>
+    </table>
+  </div>
+</section>
 <!-- Modal -->
 <div class="modal fade" id="exampleModal" tabindex="-1" aria-labelledby="exampleModalLabel" aria-hidden="true">
   <div class="modal-dialog">
@@ -83,4 +48,4 @@ Klassen:
   </div>
 </div>
 
-{% endblock %}
+{% endblock %}

+ 41 - 33
templates/base/liste_filter.html

@@ -1,37 +1,45 @@
-<form class="row g-3" id="liste-filter"
-      hx-get=""
-      hx-params="*"
-      hx-trigger="change"
-      hx-push-url="true" 
-      hx-swap="innerHTML" 
-      hx-target="body">
-
-  {% for f in filter_config  %}
-  
-  {% if f.filter_type != 'hidden' %}
-  <div class="col-md-{{ f.width }}">
-    <label for="{{ f.name }}" class="form-label">{{ f.text }}</label>
-    {% if f.filter_type == 'select' %}
-    <select id="{{ f.name }}" name="{{ f.name }}" class="form-select">
-        <option value="">-</option>
-      {% for key, value in f.options.items() %}
-        {% if key == f.current_value %}
-        <option value="{{ key }}" selected>{{ value }}</option>
-        {% else %}
-        <option value="{{ key }}">{{ value }}</option>
-        {% endif %}
-      {% endfor %}
-    </select>
-    {% elif f.filter_type == 'date' %}
-    <input type="date" class="form-control" id="{{ f.name }}" name="{{ f.name }}" value="{{ f.current_value|date_format2 }}">
-    {% else %}
-    <input type="text" class="form-control" id="{{ f.name }}" name="{{ f.name }}" value="{{ f.current_value }}">
+{% macro filter_field(f) %}
+<div class="gc-filter-field">
+  <label for="{{ f.name }}">{{ f.text }}</label>
+  {% if f.filter_type == 'select' %}
+  <select id="{{ f.name }}" name="{{ f.name }}" class="form-select">
+    <option value="">Alle</option>
+    {% set selected = namespace(found=false) %}
+    {% for key, value in f.options.items() %}
+      {% set matches = key|string == f.current_value|string %}
+      {% if matches %}{% set selected.found = true %}{% endif %}
+      <option value="{{ key }}"{% if matches %} selected{% endif %}>{{ value }}</option>
+    {% endfor %}
+    {% if f.current_value and not selected.found %}
+    <option value="{{ f.current_value }}" selected>{{ f.current_value }}</option>
     {% endif %}
-  </div>
+  </select>
+  {% elif f.filter_type == 'date' %}
+  <input type="date" class="form-control" id="{{ f.name }}" name="{{ f.name }}" value="{{ f.current_value|date_format2 }}">
+  {% else %}
+  <input type="text" class="form-control" id="{{ f.name }}" name="{{ f.name }}" value="{{ f.current_value or '' }}">
   {% endif %}
-
+</div>
+{% endmacro %}
+{% set organisation = ['Mandant', 'Filiale', 'Abteilung', 'Verursacher'] %}
+{% set beleg = ['RechnungGutschrift', 'Fahrzeug', 'Kunde', 'Rechnungsnummer', 'RechnungsdatumVon', 'RechnungsdatumBis'] %}
+<form class="gc-list-filters" id="liste-filter" hx-get="/app/forderungen/liste"
+      hx-params="*" hx-trigger="change" hx-push-url="true" hx-swap="innerHTML" hx-target="body">
+  {% if dashboard_segment %}<input type="hidden" name="dashboard_segment" value="{{ dashboard_segment }}">{% endif %}
+  {% for group in ['Organisation', 'Kunde und Beleg', 'Bearbeitung und Wiedervorlage'] %}
+  <fieldset class="gc-filter-group">
+    <legend>{{ group }}</legend>
+    <div class="gc-filter-fields">
+    {% for f in filter_config %}
+      {% if f.filter_type != 'hidden' %}
+        {% if (group == 'Organisation' and f.name in organisation) or
+              (group == 'Kunde und Beleg' and f.name in beleg) or
+              (group == 'Bearbeitung und Wiedervorlage' and f.name not in organisation and f.name not in beleg) %}
+          {{ filter_field(f) }}
+        {% endif %}
+      {% endif %}
+    {% endfor %}
+    </div>
+  </fieldset>
   {% endfor %}
-
 </form>
-
-<br>

+ 13 - 7
templates/base/liste_tabelle.html

@@ -1,7 +1,13 @@
-    {% for row in forderungen_liste %}
-      {%include 'forderungen/liste/liste_zeile.html' %}
-    {% endfor %}
-
-    <tr hx-trigger="revealed" hx-swap="outerHTML" hx-get="" hx-vals='{"page" : "{{ page+1 }}"}'>
-
-    </tr>
+{% for row in forderungen_liste %}
+  {% include 'forderungen/liste/liste_zeile.html' %}
+{% else %}
+  {% if page == 0 %}
+  <tr><td colspan="11" class="gc-list-empty" role="status">Keine Forderungen für die gewählten Filter gefunden.</td></tr>
+  {% endif %}
+{% endfor %}
+{% if has_more %}
+<tr class="gc-list-load" hx-trigger="revealed" hx-swap="outerHTML" hx-get="/app/forderungen/liste"
+    hx-include="#liste-filter" hx-vals='{"page": {{ next_page }}, "limit": {{ limit }}}' hx-push-url="false">
+  <td colspan="11">Weitere Forderungen werden geladen …</td>
+</tr>
+{% endif %}

+ 11 - 4
templates/base/login.html

@@ -43,7 +43,13 @@
 					<div class="card-body">
 						<h2 class="mb-4">Reisacher<br> <span class="text-c-blue">Forderungsmanagement 2.0</span></h2>
 						<p>Aus Freude am Zahlen.</p>
+						{% if error %}
+						<div class="alert alert-danger" role="alert">{{ error }}</div>
+						{% endif %}
 						<div class="toggle-block">
+							<form method="post" action="/login">
+							<input type="hidden" name="_csrf" value="{{ csrf }}">
+							<input type="hidden" name="next" value="{{ next }}">
 							<ol class="position-relative carousel-indicators justify-content-start">
 								<li class=""></li>
 								<li class="active"></li>
@@ -52,13 +58,13 @@
 								<div class="input-group-prepend">
 									<span class="input-group-text"><i class="feather icon-user"></i></span>
 								</div>
-								<input type="email" class="form-control" placeholder="Benutzername">
+								<input type="text" class="form-control" name="username" autocomplete="username" placeholder="Benutzername" required autofocus>
 							</div>
 							<div class="input-group mb-4">
 								<div class="input-group-prepend">
 									<span class="input-group-text"><i class="feather icon-lock"></i></span>
 								</div>
-								<input type="password" class="form-control" placeholder="Passwort">
+								<input type="password" class="form-control" name="password" autocomplete="current-password" placeholder="Passwort" required>
 							</div>
 							<!--
 							<div class="form-group text-left">
@@ -67,11 +73,12 @@
 									<label for="checkbox-fill-a1" class="cr"> Anmeldung merken</label>
 								</div>
 							</div> -->
-							<a href="/select"><button class="btn btn-primary mb-4">Anmelden</button></a>
+							<button type="submit" class="btn btn-primary mb-4">Anmelden</button>
+							</form>
 							
 							
 						</div>
-						<div class="toggle-block collapse">
+						<div class="toggle-block collapse" hidden>
 							<ol class="position-relative carousel-indicators justify-content-start">
 								<li class="active"></li>
 								<li class=""></li>

+ 19 - 0
templates/base/logout.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="de">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Abgemeldet – Global Cube</title>
+  <link href="/static/assets/plugins/bootstrap/css/bootstrap.min.css" rel="stylesheet">
+</head>
+<body class="container py-5">
+  <div class="card mx-auto" style="max-width: 36rem">
+    <div class="card-body">
+      <h1 class="h3">Abgemeldet</h1>
+      <p>Die Anwendungssitzung wurde beendet.</p>
+      <p class="text-muted">Bei aktivierter Windows-Anmeldung kann IIS Sie beim nächsten Aufruf automatisch erneut anmelden.</p>
+      <a class="btn btn-primary" href="/">Anwendung öffnen</a>
+    </div>
+  </div>
+</body>
+</html>

+ 65 - 121
templates/forderungen/dashboard/dashboard.html

@@ -1,124 +1,68 @@
-{% extends "base/base.html" %}
+{% extends 'base/base.html' %}
+{% block title %}Forderungen | Dashboard{% endblock %}
+{% block page_class %}gc-dashboard-page{% endblock %}
 {% block content %}
+<div class="gc-dashboard-heading"><h1>Forderungsdashboard</h1>
+{% if dashboard %}<p>Stand: {{ dashboard.generated }} · Europe/Berlin</p>{% endif %}</div>
 
-<br>
-<br>
-
-<h3>Forderungen</h3>
-
-<br>
-
-<ul class="nav nav-pills">
-  <li class="nav-item">
-    <a class="nav-link" aria-current="page" href="?page=Altersstaffel">nach Altersstaffel</a>
-  </li>
-  <li class="nav-item">
-    <a class="nav-link active" href="?page=Standort">nach Standort</a>
-  </li>
-  <li class="nav-item">
-    <a class="nav-link" href="?page=Verursacher">nach Verursacher</a>
-  </li>
-  <li class="nav-item">
-    <a class="nav-link disabled" aria-disabled="true">nach Wiedervorlage</a>
-  </li>
-</ul>
-
-<br>
-<br>
-
-<div class="col-8">
-  <canvas id="myChart"></canvas>
+{% if dashboard_error %}
+<div class="gc-card gc-dashboard-error" role="alert"><p>{{ dashboard_error }}</p>
+<a href="/app/forderungen/dashboard?page={{ dashboard_view }}&amp;metric={{ dashboard_metric }}&amp;stack={{ dashboard_stack }}{% if dashboard_only_invoices %}&amp;only_invoices=true{% endif %}">Erneut laden</a></div>
+{% else %}
+<div class="gc-dashboard-kpis">
+  <section class="gc-card gc-dashboard-kpi"><span>Anzahl der Belege</span><strong>{{ dashboard.count }}</strong></section>
+  <section class="gc-card gc-dashboard-kpi"><span>Offener Betrag</span><strong>{{ dashboard.amount_display }} €</strong></section>
 </div>
-
-<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-
-<script>
-  let CHART_COLORS = {
-    red: 'rgb(255, 99, 132)',
-    orange: 'rgb(255, 159, 64)',
-    yellow: 'rgb(255, 205, 86)',
-    green: 'rgb(75, 192, 192)',
-    blue: 'rgb(54, 162, 235)',
-    purple: 'rgb(153, 102, 255)',
-    grey: 'rgb(201, 203, 207)'
-  };
-
-  let data = {
-    labels: [
-      'MM',
-      'KRU',
-      'ULM',
-      'LL',
-      'GZ',
-      'AAM',
-    ],
-    datasets: [{
-      label: 'Verkauf',
-      data: [12, 19, 3, 5, 2, 3],
-      borderWidth: 1,
-      backgroundColor: CHART_COLORS.red
-    },
-    {
-      label: 'Service',
-      data: [12, 19, 3, 5, 2, 3],
-      borderWidth: 1,
-      backgroundColor: CHART_COLORS.blue
-    },
-    {
-      label: 'TZ',
-      data: [12, 19, 3, 5, 2, 3],
-      borderWidth: 1,
-      backgroundColor: CHART_COLORS.green
-    }, {
-      label: 'Sonstige',
-      data: [12, 19, 3, 5, 2, 3],
-      borderWidth: 1,
-      backgroundColor: CHART_COLORS.yellow
-    }]
-  };
-
-  let myChart = document.getElementById('myChart')
-
-  let myBarChart = new Chart(myChart, {
-    type: 'bar',
-    data: {
-      labels: data.labels,
-      datasets: data.datasets
-    },
-    options: {
-      plugins: {
-        title: {
-          display: false,
-          text: 'Chart.js Bar Chart - Stacked'
-        },
-      },
-      responsive: true,
-      scales: {
-        x: {
-          stacked: true,
-        },
-        y: {
-          stacked: true
-        }
-      }
-    }
-  });
-
-  myChart.onclick = function (e) {
-    var slice = myBarChart.getElementsAtEventForMode(e, 'nearest', { intersect: true }, true);
-    if (!slice.length) return; // return if not clicked on slice
-    console.log(slice);
-    var label = myBarChart.data.labels[slice[0].index];
-    var ids = {
-      'MM': '10',
-      'KRU': '30',
-      'ULM': '40',
-      'LL': '50',
-      'GZ': '55',
-      'AAM': '60',
-    };
-    window.open('/app/forderungen/liste/?Standort=' + ids[label]);
-  }
-</script>
-
-{% endblock %}
+<section class="gc-card gc-dashboard-report" hx-history="false" aria-labelledby="dashboard-title" data-dashboard-view="{{ dashboard_view }}" data-dashboard-metric="{{ dashboard_metric }}">
+  <h2 class="gc-section-title" id="dashboard-title"><i class="icon cil-chart" aria-hidden="true"></i> Auswertung der Forderungen</h2>
+  <nav class="gc-dashboard-tabs" aria-label="Auswertung nach">
+    {% for view in ['Standort', 'Altersstaffel', 'Verursacher'] %}
+    <a href="?page={{ view }}&amp;metric={{ dashboard_metric }}&amp;stack={{ dashboard_stack }}{% if dashboard_only_invoices %}&amp;only_invoices=true{% endif %}" data-dashboard-view="{{ view }}"{% if view == dashboard_view %} aria-current="page"{% endif %}>Nach {{ view }}</a>
+    {% endfor %}
+  </nav>
+  <div class="gc-dashboard-controls">
+    <div class="gc-dashboard-metric-settings" role="group" aria-labelledby="dashboard-metric-label">
+      <span class="gc-dashboard-control-label" id="dashboard-metric-label">Kennzahl</span>
+      <div class="gc-dashboard-metric-options">
+        <div class="gc-dashboard-metrics">
+          <button type="button" data-dashboard-metric="betrag" aria-pressed="{{ 'true' if dashboard_metric == 'betrag' else 'false' }}">Offener Betrag</button>
+          <button type="button" data-dashboard-metric="anzahl" aria-pressed="{{ 'true' if dashboard_metric == 'anzahl' else 'false' }}">Anzahl</button>
+        </div>
+<form class="gc-dashboard-scope" id="dashboard-scope" method="get" action="/app/forderungen/dashboard" hx-boost="false">
+  <input type="hidden" name="page" value="{{ dashboard_view }}">
+  <input type="hidden" name="metric" value="{{ dashboard_metric }}">
+  <input type="hidden" name="stack" value="{{ dashboard_stack }}">
+  <label for="dashboard-only-invoices"><input type="checkbox" id="dashboard-only-invoices" name="only_invoices" value="true"{% if dashboard_only_invoices %} checked{% endif %}> Nur Rechnungen</label>
+</form>
+      </div>
+    </div>
+    <div><label for="dashboard-stack">Balken stapeln nach</label>
+      <select class="form-select" id="dashboard-stack" form="dashboard-scope">
+        <option value="abteilung"{% if dashboard_stack == 'abteilung' %} selected{% endif %}>Abteilung</option>
+        <option value="wiedervorlage"{% if dashboard_stack == 'wiedervorlage' %} selected{% endif %}>Wiedervorlage</option>
+      </select>
+    </div>
+    <div><label for="dashboard-search">Suchen</label><input class="form-control" type="search" id="dashboard-search" placeholder="Name der Gruppe …"></div>
+  </div>
+  <p class="gc-dashboard-description">{% if dashboard_stack == 'wiedervorlage' %}Die Farben zeigen die Wiedervorlagestaffeln: überfällig, heute bis in 3 Tagen, in 4 bis 14 Tagen und danach zurückgestellt. Ohne Wiedervorlage gilt das Beleg-Fälligkeitsdatum.{% else %}Die Farben zeigen die Abteilungen.{% endif %} Bewegen Sie den Mauszeiger auf ein Segment oder tippen Sie es an. Die Datentabelle bietet dieselben Werte und Listenlinks.</p>
+  <ul class="gc-dashboard-legend" aria-label="{{ 'Wiedervorlagestaffeln' if dashboard_stack == 'wiedervorlage' else 'Abteilungen' }}"></ul>
+  <p class="gc-dashboard-status" role="status" aria-live="polite"></p>
+  <div class="gc-dashboard-chart"><canvas id="dashboard-chart" role="img" aria-label="Forderungen nach Abteilung; vollständige Werte in der Datentabelle"></canvas></div>
+  <p class="gc-dashboard-chart-error" role="alert" hidden>Das Diagramm ist nicht verfügbar. Alle Werte und Listenlinks finden Sie in der Datentabelle.</p>
+  <div class="gc-dashboard-pagination" role="group" aria-label="Diagrammseiten">
+    <button type="button" class="btn btn-outline-secondary" data-dashboard-prev>Vorherige</button><span data-dashboard-pages></span>
+    <button type="button" class="btn btn-outline-secondary" data-dashboard-next>Nächste</button>
+  </div>
+  <details class="gc-dashboard-table"><summary>Datentabelle und Listenlinks anzeigen</summary>
+    <div class="gc-dashboard-table-scroll" tabindex="0" role="region" aria-label="Dashboarddaten, horizontal scrollbar">
+      <table class="table"><caption class="visually-hidden">Kennzahlen der angezeigten Diagrammseite</caption>
+        <thead><tr><th scope="col">Gruppe / {{ 'Wiedervorlage' if dashboard_stack == 'wiedervorlage' else 'Abteilung' }}</th><th scope="col">Anzahl</th><th scope="col">Offener Betrag</th><th scope="col">Forderungen</th></tr></thead>
+        <tbody id="dashboard-table-body"></tbody>
+      </table>
+    </div>
+  </details>
+</section>
+<div class="gc-dashboard-popover" id="dashboard-popover" role="dialog" aria-label="Details zum Diagrammsegment" hidden></div>
+<script type="application/json" id="dashboard-data">{{ dashboard|tojson }}</script>
+{% endif %}
+{% endblock %}

+ 0 - 21
templates/forderungen/dashboard/queries/dashboard_betriebe.sql

@@ -1,21 +0,0 @@
--- Nach Betrieben
-SELECT [Dim1_Sortierung]
-     , [Dim2_Sortierung]
-     , [Dim1]
-     , [Dim2]
-     , sum([Kennzahl1]) AS [Kennzahl1]
-     , sum([Kennzahl2]) AS [Kennzahl2]
-FROM (SELECT [Standort_ID] AS [Dim1_Sortierung]
-           , CASE
-                 WHEN [Bereich] = 'Verkauf' THEN 1
-                 WHEN [Bereich] = 'Service' THEN 2
-                 ELSE 9
-             END AS [Dim2_Sortierung]
-           , [Standort_Name] AS [Dim1]
-           , isnull([Bereich], 'Sonstige') AS [Dim2]
-           , [offen] AS [Kennzahl1]
-           , 1 AS [Kennzahl2]
-      FROM [Forderungen]
-      WHERE [Rechnung_Gutschrift] = 'Rechnung') [V1]
-GROUP BY [Dim1_Sortierung], [Dim2_Sortierung], [Dim1], [Dim2]
-ORDER BY 1, 2

+ 0 - 21
templates/forderungen/dashboard/queries/dashboard_staffel.sql

@@ -1,21 +0,0 @@
--- Nach Altersstaffel
-SELECT [Dim1_Sortierung]
-     , [Dim2_Sortierung]
-     , [Dim1]
-     , [Dim2]
-     , sum([Kennzahl1]) AS [Kennzahl1]
-     , sum([Kennzahl2]) AS [Kennzahl2]
-FROM (SELECT [Staffel] AS [Dim1_Sortierung]
-           , CASE
-                 WHEN [Bereich] = 'Verkauf' THEN 1
-                 WHEN [Bereich] = 'Service' THEN 2
-                 ELSE 9
-             END AS [Dim2_Sortierung]
-           , [Staffel] AS [Dim1]
-           , isnull([Bereich], 'Sonstige') AS [Dim2]
-           , [offen] AS [Kennzahl1]
-           , 1 AS [Kennzahl2]
-      FROM [Forderungen]
-      WHERE [Rechnung_Gutschrift] = 'Rechnung') [V1]
-GROUP BY [Dim1_Sortierung], [Dim2_Sortierung], [Dim1], [Dim2]
-ORDER BY 1, 2

+ 0 - 18
templates/forderungen/dashboard/queries/dashboard_verursacher.sql

@@ -1,18 +0,0 @@
--- Nach Verursacher
-SELECT [Dim1_Sortierung]
-     , [Dim2_Sortierung]
-     , [Dim1]
-     , [Dim2]
-     , sum([Kennzahl1]) AS [Kennzahl1]
-     , sum([Kennzahl2]) AS [Kennzahl2]
-FROM (SELECT [Standort_ID] AS [Dim1_Sortierung]
-           , [Verursacher] AS [Dim2_Sortierung]
-           , [Standort_Name] AS [Dim1]
-           , [Verursacher] AS [Dim2]
-           , [offen] AS [Kennzahl1]
-           , 1 AS [Kennzahl2]
-      FROM [Forderungen]
-      WHERE [Rechnung_Gutschrift] = 'Rechnung') [V1]
-GROUP BY [Dim1_Sortierung], [Dim2_Sortierung], [Dim1], [Dim2]
-HAVING sum([Kennzahl2]) >= 10
-ORDER BY 1, 2

+ 3 - 0
templates/forderungen/details/comment_submission.html

@@ -0,0 +1,3 @@
+{% if history_available %}{% include 'forderungen/details/details_kommentare.html' %}{% endif %}
+{% if files_available %}{% include 'forderungen/details/files_panel.html' %}{% endif %}
+<script type="application/json" data-gc-send-result>{{ send_result|tojson }}</script>

+ 39 - 51
templates/forderungen/details/details.html

@@ -1,57 +1,45 @@
 {% extends "base/base.html" %}
+{% block title %}Forderungen | Details: {{ forderungen_details[0].Beleg_Nr }}{% endblock %}
+{% block page_class %}gc-detail-page{% endblock %}
 {% block content %}
-
-<br>
-<h2>{{ forderungen_details[0].Beleg_Text }}</h2>
-<br>
-<div class="col-1">
-<button class="btn btn-warning" hx-get="{{ request.headers.referer }}" hx-trigger="click" hx-push-url="true"
-  hx-swap="innerHTML" hx-target="body">Zurück</button>
-</div>
-
-<div class="row g-3">
-
-  <div class="col-3">
-
-    {%include 'forderungen/details/details_uebersicht.html' %}
-
+{% set row = forderungen_details[0] %}
+<section class="gc-case-context" aria-label="Aktueller Beleg">
+  <div class="gc-context-heading">
+    <a class="btn btn-link gc-back-link" href="{{ return_url }}" hx-boost="false" data-gc-return-url="{{ return_url }}">← Zurück</a>
+    <h1>{{ row.Beleg_Text }}</h1>
+    <p>{{ row.Kunde_Name }} <span>· {{ row.Kunde_Nr }}</span></p>
   </div>
-
-
-  <div class="col-5">
-
-    {%include 'base/chat_container.html' %}
-
-    <br>
-    <br>
-
-    <h3>Dateien</h3>
-
-    {%include 'forderungen/details/details_dateien.html' %}
-
+  <div class="gc-context-metrics">
+    <div class="gc-metric gc-metric-balance"><span>Offener Betrag</span><strong>{{ row.Beleg_Offen|number_format }} €</strong></div>
+    <div class="gc-metric gc-metric-level{% if row.Mahnstufe|string == "0" %} gc-metric-clear{% endif %}"><span>Mahnstufe</span><strong>{{ row.Mahnstufe }}</strong></div>
   </div>
-
-  <div class="col-4">
-
-    {%include 'forderungen/details/details_formular.html' %}
-
-    <br>
-    <br>
-
-    <h3>Auftragspositionen</h3>
-
-    {%include 'forderungen/details/details_positionen.html' %}
-
+</section>
+<div class="gc-case-grid">
+  <aside class="gc-case-data" aria-label="Grunddaten zum Beleg">
+    {% include 'forderungen/details/details_uebersicht.html' %}
+  </aside>
+  <div class="gc-case-conversation">
+    {% include 'base/chat_container.html' %}
+    {% include 'forderungen/details/files_panel.html' %}
   </div>
+  <aside class="gc-case-actions" aria-label="Zusätzliche Informationen">
+    <section class="gc-detail-card" aria-labelledby="actions-title">
+      <h2 class="gc-section-title" id="actions-title"><i class="icon cil-settings" aria-hidden="true"></i> Bearbeitung</h2>
+      {% include 'forderungen/details/details_formular.html' %}
+    </section>
+    {% if auftraege_positionen|length > 0 %}
+    <section class="gc-detail-card" aria-labelledby="positions-title">
+      <h2 class="gc-section-title" id="positions-title"><i class="icon cil-list" aria-hidden="true"></i> Auftragspositionen</h2>
+      <div class="gc-table-scroll" tabindex="0" role="region" aria-label="Auftragspositionen">
+        {% include 'forderungen/details/details_positionen.html' %}
+      </div>
+    </section>
+    {% endif %}
+  </aside>
 </div>
-
-<br>
-
-<h3>Buchungsbelege</h3>
-<p class="lead">
-  Debitorenkonto {{ forderungen_details[0].Kunde_Nr }} - {{ forderungen_details[0].Kunde_Name }}
-</p>
-
-{%include 'forderungen/details/details_buchungen.html' %}
-
-{% endblock %}
+<section class="gc-detail-card gc-case-bookings" aria-labelledby="bookings-title">
+  <h2 class="gc-section-title" id="bookings-title"><i class="icon cil-calculator" aria-hidden="true"></i> Buchungsbelege</h2>
+  <p class="gc-section-description">Debitorenkonto {{ row.Kunde_Nr }} · {{ row.Kunde_Name }}</p>
+  {% include 'forderungen/details/details_buchungen.html' %}
+</section>
+{% endblock %}

+ 17 - 10
templates/forderungen/details/details_buchungen.html

@@ -1,10 +1,13 @@
-<div class="tabs">
-    <div class="tab">Diese Rechnung</div>
-    <div class="tab">Alle offenen Belege</div>
-    <div class="tab">Dieses Fahrzeug</div>
-    <div class="tab active">Debitor Historie</div>
-</div>
-
+{% from 'forderungen/details/history_tabs.html' import history_tabs %}
+<div id="bookings-history">
+{{ history_tabs('buchungen', buchungen_scope, detail_url, vehicle_missing, 'bookings-history') }}
+{% if buchungen_scope == 'vehicle' and vehicle_missing %}
+<p role="status">Zu dieser Rechnung ist kein Fahrzeug hinterlegt.</p>
+{% endif %}
+{% if forderungen_buchungen|length >= 1000 %}
+<p role="status">Es werden die ersten 1.000 Buchungsbelege angezeigt. Bitte grenzen Sie die Auswahl bei Bedarf ein.</p>
+{% endif %}
+<div class="gc-table-scroll" tabindex="0" role="region" aria-label="Buchungsbelege">
 <table class="table table-striped table-bordered">
     <thead>
         <tr>
@@ -22,14 +25,18 @@
         {% for row in forderungen_buchungen %}
         <tr class="beleg-{{ row.Beleg_Art }}">
             <td>{{ row.Fahrzeug_Nr }}</td>
-            <td>{{ row.Beleg_Art }}</td>
+            <td>{% if row.Beleg_Art in ('M1', 'M2', 'M3') %}<span class="gc-document-badge gc-document-badge--{{ row.Beleg_Art }}">{{ row.Beleg_Art }}<span class="visually-hidden"> – Mahnung Stufe {{ row.Beleg_Art[1:] }}</span></span>{% else %}{{ row.Beleg_Art }}{% endif %}</td>
             <td>{{ row.Beleg_Nr }}</td>
             <td>{{ row.Beleg_Datum|date_format }}</td>
             <td>{{ row.Beleg_Beschreibung }}</td>
-            <td>{{ row.Benutzer }}</td>
+            <td>{{ row.Benutzer_ID }}</td>
             <td class="text-end">{{ row.Betrag|number_format }}</td>
             <td>{{ row.Bezahlt }}</td>
         </tr>
+        {% else %}
+        <tr><td colspan="8" role="status">Keine Buchungsbelege für diese Auswahl vorhanden.</td></tr>
         {% endfor %}
     </tbody>
-</table>
+</table>
+</div>
+</div>

+ 6 - 4
templates/forderungen/details/details_dateien.html

@@ -1,4 +1,4 @@
-<table class="table table-striped table-bordered">
+<table class="table table-bordered gc-files-table">
     <thead>
         <tr>
             <th>Datum</th>
@@ -8,9 +8,11 @@
     <tbody>
         {% for row in files %}
         <tr>
-            <td></td>
-            <td><a href="/files/?name={{ row }}" hx-disable="true">{{ row }}</a></td>
+            <td>{{ row.modified_at.strftime('%d.%m.%Y %H:%M') }}</td>
+            <td><a href="/files/?name={{ row.relative_path|urlencode }}" hx-disable="true">{{ row.name }}</a></td>
         </tr>
+        {% else %}
+        <tr><td colspan="2">Keine Dateien vorhanden.</td></tr>
         {% endfor %}
     </tbody>
-</table>
+</table>

+ 32 - 33
templates/forderungen/details/details_formular.html

@@ -1,11 +1,12 @@
 {% set row = forderungen_details[0] %}
 
-<form class="row g-3" id="formular">
+<form class="row g-3 gc-workflow-form" id="formular">
+  <input type="hidden" name="_csrf" value="{{ request.state.principal.csrf }}" />
   <input type="hidden" name="source" value="details" />
+  <input type="hidden" name="return_to" value="{{ return_url }}" />
   <div class="col-12">
-    <div class="form-check" data-coreui-toggle="collapse" data-coreui-target="#VersicherungCollapse"
-      aria-expanded="{{ row.Versicherung|truefalse }}" aria-controls="VersicherungCollapse">
-      <input class="form-check-input" type="checkbox" name="Versicherung" id="Versicherung" {{
+    <div class="form-check">
+      <input class="form-check-input" type="checkbox" name="Versicherung" id="Versicherung" data-gc-collapse aria-controls="VersicherungCollapse" aria-expanded="{{ row.Versicherung|truefalse }}" {{
         row.Versicherung|checked }}>
       <label class="form-check-label" for="Versicherung">
         <strong>Versicherungsfall</strong>
@@ -30,7 +31,7 @@
           </select>
         </div>
         <div class="col-sm-3">
-          <select id="Versicherung_Typ" name="Versicherung_Typ" class="form-select">
+          <select aria-label="Versicherungsart" id="Versicherung_Typ" name="Versicherung_Typ" class="form-select">
             <option value="" selected>-</option>
             {% for v in ('Haftpflicht', 'Teilkasko', 'Vollkasko', 'Ausländisch') %}
             {% if v == row.Versicherung_Typ %}
@@ -62,7 +63,7 @@
         </div>
         <div class="col-sm-3">
           <input type="text" class="form-control" id="Selbstbeteiligung_Betrag" name="Selbstbeteiligung_Betrag"
-            placeholder="Betrag" value="{{ row.Selbstbeteiligung_Betrag }}">
+            aria-label="Selbstbeteiligung Betrag" placeholder="Betrag" value="{{ row.Selbstbeteiligung_Betrag }}">
         </div>
       </div>
       <div class="row mb-3">
@@ -76,18 +77,18 @@
           </select>
         </div>
         <div class="col-sm-3">
-          <input type="text" class="form-control" id="Mwst_Betrag" name="Mwst_Betrag" placeholder="Betrag"
+          <input type="text" class="form-control" id="Mwst_Betrag" name="Mwst_Betrag" aria-label="Mehrwertsteuer Betrag" placeholder="Betrag"
             value="{{ row.Mwst_Betrag|number_format }}">
         </div>
         <div class="col-sm-3">
-          <a class="btn btn-primary" hx-disable="true"
+          <button type="button" class="btn btn-outline-secondary" hx-disable="true"
             onclick="document.getElementById('Mwst_Betrag').value='{{ row.Mwst_Betrag_berechnet|number_format }}';">
             <i class="cil-arrow-thick-left"></i>
-            {{ row.Mwst_Betrag_berechnet|number_format }}</a>
+            {{ row.Mwst_Betrag_berechnet|number_format }}</button>
         </div>
       </div>
       <div class="col-3">
-        <a class="btn btn-secondary" hx-disable="true"
+        <a class="btn btn-outline-secondary" hx-disable="true"
           href="/app/forderungen/export/{{row.Client_DB}}_{{row.Beleg_Nr}}">Mahnung
           erstellen</a>
       </div>
@@ -96,9 +97,8 @@
   </div>
 
   <div class="col-12">
-    <div class="form-check" data-coreui-toggle="collapse" data-coreui-target="#ReklamationCollapse"
-      aria-expanded="{{ row.Reklamation|truefalse }}" aria-controls="ReklamationCollapse">
-      <input class="form-check-input" type="checkbox" id="Reklamation" name="Reklamation" {{
+    <div class="form-check">
+      <input class="form-check-input" type="checkbox" id="Reklamation" data-gc-collapse aria-controls="ReklamationCollapse" aria-expanded="{{ row.Reklamation|truefalse }}" name="Reklamation" {{
         row.Reklamation|checked }}>
       <label class="form-check-label" for="Reklamation">
         <strong>Reklamation</strong>
@@ -119,9 +119,8 @@
   </div>
 
   <div class="col-12">
-    <div class="form-check" data-coreui-toggle="collapse" data-coreui-target="#RechtsanwaltCollapse"
-      aria-expanded="{{ row.Rechtsanwalt|truefalse }}" aria-controls="RechtsanwaltCollapse">
-      <input class="form-check-input" type="checkbox" id="Rechtsanwalt" name="Rechtsanwalt" {{
+    <div class="form-check">
+      <input class="form-check-input" type="checkbox" id="Rechtsanwalt" data-gc-collapse aria-controls="RechtsanwaltCollapse" aria-expanded="{{ row.Rechtsanwalt|truefalse }}" name="Rechtsanwalt" {{
         row.Rechtsanwalt|checked }}>
       <label class="form-check-label" for="Rechtsanwalt">
         <strong>Rechtsanwalt</strong>
@@ -155,7 +154,7 @@
         </div>
       </div>
       <div class="col-3">
-        <a class="btn btn-secondary" hx-disable="true"
+        <a class="btn btn-outline-secondary" hx-disable="true"
           href="/app/forderungen/export/{{row.Client_DB}}_{{row.Beleg_Nr}}">Beitreibungsauftrag</a>
       </div>
     </div>
@@ -163,9 +162,8 @@
 
 
   <div class="col-12">
-    <div class="form-check" data-coreui-toggle="collapse" data-coreui-target="#MahnenCollapse"
-      aria-expanded="{{ row.Mahnen_aussetzen|truefalse }}" aria-controls="MahnenCollapse">
-      <input class="form-check-input" type="checkbox" id="Mahnen" name="Mahnen_aussetzen" {{
+    <div class="form-check">
+      <input class="form-check-input" type="checkbox" id="Mahnen" data-gc-collapse aria-controls="MahnenCollapse" aria-expanded="{{ row.Mahnen_aussetzen|truefalse }}" name="Mahnen_aussetzen" {{
         row.Mahnen_aussetzen|checked }}>
       <label class="form-check-label" for="Mahnen">
         <strong>Mahnlauf aussetzen</strong>
@@ -180,7 +178,7 @@
           Dieser Beleg wird beim nächsten Mahnlauf nicht angemahnt.
         </p>
 
-        <label for="Mahnen_Begründung" class="col-sm-3 col-form-label">Begründung</label>
+        <label for="Mahnen_Begruendung" class="col-sm-3 col-form-label">Begründung</label>
         <div class="col-sm-5">
 
           <input type="text" class="form-control" id="Mahnen_Begruendung" name="Mahnen_Begruendung"
@@ -189,11 +187,12 @@
       </div>
     </div>
   </div>
-  <div class="col-12">
-    <br>
-  </div>
-
-  <div class="col-12">
+  {% with primary_key=row.Client_DB|string ~ '_' ~ row.Beleg_Nr|string,
+          effective_name=row.Verursacher_Aktuell_Text|default(row.Verursacher_Text),
+          modal_url=detail_url ~ '/verursacher?return_to=' ~ (return_url|urlencode) %}
+    {% include 'forderungen/verursacher/detail_field.html' %}
+  {% endwith %}
+  <div class="col-12 gc-follow-up">
     <div class="row mb-3">
       <label for="Wiedervorlage" class="col-sm-3 col-form-label">Wiedervorlage</label>
       <div class="col-sm-5">
@@ -201,18 +200,18 @@
           value="{{ row.Wiedervorlage.strftime("%Y-%m-%d") }}">
       </div>
       <div class="col-3">
-        <a class="btn btn-primary" onclick="document.getElementById('Wiedervorlage').value='{{ add7days }}';" hx-disable="true">
+        <button type="button" class="btn btn-outline-secondary" onclick="document.getElementById('Wiedervorlage').value='{{ add7days }}';" hx-disable="true">
           +7 Tage
-        </a>
+        </button>
       </div>
     </div>
   </div>
 
-  <div class="col-12">
-    <button class="btn btn-warning" hx-post="" hx-trigger="click" hx-swap="outerHTML" hx-target="#formular" hx-push-url="false">Speichern</button>
-    <button class="btn btn-warning" hx-post="" hx-trigger="click" hx-swap="innerHTML" hx-target="body" hx-push-url="true" hx-vals='{"redirect": "{{ request.headers.referer }}"}'">Speichern &amp; Zurück</button>
-    <button class="btn btn-warning" hx-get="{{ request.headers.referer }}" hx-trigger="click" hx-swap="innerHTML" hx-target="body" hx-push-url="true">Zurück</button>
+  <div class="col-12 gc-form-actions">
+    <button type="button" class="btn btn-primary" hx-post="" hx-trigger="click" hx-swap="outerHTML" hx-target="#formular" hx-push-url="false">Speichern</button>
+    <button type="button" class="btn btn-outline-secondary" hx-post="" hx-trigger="click" hx-swap="innerHTML" hx-target="body" hx-push-url="true" hx-vals='{"redirect": "list"}'">Speichern &amp; Zurück</button>
+    <a class="btn btn-link" href="{{ return_url }}" hx-boost="false">Zurück</a>
   </div>
 
 
-</form>
+</form>

+ 24 - 27
templates/forderungen/details/details_kommentare.html

@@ -1,27 +1,24 @@
-<!--
-<br>
-<br>
-<h3>Kommentare</h3>
-
-<table class="table table-striped table-bordered">
-  <thead>
-    <tr>
-      <th>Timestamp</th>
-      <th>Name</th>
-      <th>Rolle</th>
-      <th>Kommentar</th>
-    </tr>
-  </thead>
-  <tbody>
-    {% for row in forderungen_kommentare %}
-    <tr>
-      <td>{{ row.Timestamp|date_format }}</td>
-      <td>{{ row.Name }}</td>
-      <td>{{ row.Rolle }}</td>
-      <td>{{ row.Kommentar or '' }}</td>
-    </tr>
-    {% endfor %}
-  </tbody>
-</table>
-
--->
+{% from 'forderungen/details/history_tabs.html' import history_tabs %}
+<div id="comments-history" class="comment-history">
+    {{ history_tabs('kommentare', kommentare_scope, detail_url, vehicle_missing, 'comments-history') }}
+    <input type="hidden" name="comment_scope" value="{{ kommentare_scope }}" form="comment-form">
+    {% if kommentare_scope == 'vehicle' and vehicle_missing %}
+    <p class="p-3" role="status">Zu dieser Rechnung ist kein Fahrzeug hinterlegt.</p>
+    {% endif %}
+    <div class="chat-content" id="chatContent">
+        {% for row in forderungen_kommentare %}
+        <div class="message {{ 'myself' if row.Benutzer_ID == request.state.principal.username else 'other' }} {{ row.Rolle_ID }}">
+            <div class="message-header">
+                <div class="avatar">{{ row.Benutzer_ID }}</div>
+                <div class="sender-name">{{ row.Name }}</div>
+                <div class="timestamp">{{ row.Timestamp|date_format }}</div>
+                {% if kommentare_scope != 'invoice' %}<span class="comment-invoice">Rechnung {{ row.Beleg_Nr }}</span>{% endif %}
+            </div>
+            <div class="message-bubble">{{ row.Kommentar }}</div>
+        </div>
+        {% else %}
+        <p class="p-3" role="status">Keine Kommentare für diese Auswahl vorhanden.</p>
+        {% endfor %}
+        <div id="chat-end"></div>
+    </div>
+</div>

+ 117 - 312
templates/forderungen/details/details_uebersicht.html

@@ -1,317 +1,122 @@
 {% set row = forderungen_details[0] %}
-
-<div class="row mb-3">
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Grunddaten</th>
-      </tr>
-      <tr>
-        <td><strong>Hauptbetrieb:</strong></td>
-        <td>{{row.Hauptbetrieb_Name }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Standort:</strong></td>
-        <td>{{row.Standort_Name }}</td>
-      </tr>
-      <tr>
-        <td><strong>Benutzer:</strong></td>
-        <td>{{row.Benutzer_ID }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Verursacher:</strong></td>
-        <td>{{row.Verursacher_Text }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Abteilung:</strong></td>
-        <td>{{row.Abteilung }}</td>
-      </tr>
-
-    </table>
-  </div>
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Beleg</th>
-      </tr>
-      <tr>
-        <td><strong>Belegart:</strong></td>
-        <td>{{row.Rechnung_Gutschrift }}</td>
-      </tr>
-      <tr>
-        <td><strong>Beleg-Nr:</strong></td>
-        <td>{{row.Beleg_Nr }}</td>
-      </tr>
-      <tr>
-        <td><strong>Betrag:</strong></td>
-        <td>{{row.Beleg_offen|number_format }} &euro;</td>
-      </tr>
-      <tr>
-        <td><strong>Rechnungsdatum:</strong></td>
-        <td>{{row.Beleg_Datum|date_format }}</td>
-      </tr>            
-      <tr>
-        <td><strong>Lieferdatum:</strong></td>
-        <td>{{row.Beleg_Datum|date_format }}</td>
-      </tr>
-      <tr>
-        <td><strong>Fälligkeitsdatum:</strong></td>
-        <td>{{row.Beleg_Datum|date_format }}</td>
-      </tr>
-
-
-
-    </table>
-  </div>
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Forderung</th>
-      </tr>
-      <tr>
-        <td><strong>offen:</strong></td>
-        <td>{{row.Beleg_offen|number_format }} &euro;</td>
-      </tr>
-
-      <tr>
-        <td><strong>offen (Kunde gesamt):</strong></td>
-        <td>{{row.Kunde_offen_gesamt|number_format }} &euro;</td>
-      </tr>
-
-      <tr>
-        <td><strong>Tage:</strong></td>
-        <td>{{row.Beleg_Tage_offen }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Staffel:</strong></td>
-        <td>{{row.Staffel_Text }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Mahnstufe:</strong></td>
-        <td>{{row.Mahnstufe }}</td>
-      </tr>
-    </table>
-  </div>
-
-
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Kunde</th>
-      </tr>
-
-      <tr>
-        <td><strong>Kunden-Nr:</strong></td>
-        <td>{{row.Kunde_Nr }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Name:</strong></td>
-        <td>{{row.Kunde_Name }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Adresse:</strong></td>
-        <td>{{row.Kunde_Adresse }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>PLZ / Ort:</strong></td>
-        <td>{{row.Kunde_PLZ }} {{row.Kunde_Ort }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Land:</strong></td>
-        <td>{{row.Kunde_Land }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Telefon:</strong></td>
-        <td>{{row.Kunde_Telefon }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>E-Mail:</strong></td>
-        <td><a href="mailto:{{row.Kunde_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Kunde_Email }}</a></td>
-      </tr>
-
-      <tr>
-        <td><strong>Payment_Terms_Code:</strong></td>
-        <td>{{row.Payment_Terms_Code }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Kundengruppe:</strong></td>
-        <td>{{row.Customer_Group_Description }}</td>
-      </tr>
-
-    </table>
-  </div>
+<section class="gc-detail-card" aria-labelledby="data-title-0">
+  <h2 class="gc-section-title" id="data-title-0"><i class="icon cil-info" aria-hidden="true"></i> Grunddaten</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Hauptbetrieb</dt><dd>{{row.Hauptbetrieb_Name }}</dd></div>
+    <div class="gc-data-field"><dt>Standort</dt><dd>{{row.Standort_Name }}</dd></div>
+    <div class="gc-data-field"><dt>Abteilung</dt><dd>{{row.Abteilung }}</dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Grunddaten</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Benutzer</dt><dd>{{row.Benutzer_ID }}</dd></div>
+    <div class="gc-data-field"><dt>Verursacher</dt><dd>{{row.Verursacher_Text }}</dd></div>
+  </dl>
+  </details>
+</section>
+<section class="gc-detail-card" aria-labelledby="data-title-1">
+  <h2 class="gc-section-title" id="data-title-1"><i class="icon cil-print" aria-hidden="true"></i> Beleg</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Belegart</dt><dd>{{row.Rechnung_Gutschrift }}</dd></div>
+    <div class="gc-data-field"><dt>Beleg-Nr</dt><dd>{{row.Beleg_Nr }}</dd></div>
+    <div class="gc-data-field gc-field-money"><dt>Betrag</dt><dd>{{row.Beleg_Offen|number_format }} &euro;</dd></div>
+    <div class="gc-data-field"><dt>Rechnungsdatum</dt><dd>{{row.Beleg_Datum|date_format }}</dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Beleg</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Lieferdatum</dt><dd>{{row.Beleg_Datum|date_format }}</dd></div>
+    <div class="gc-data-field"><dt>Fälligkeitsdatum</dt><dd>{{row.Beleg_Datum|date_format }}</dd></div>
+  </dl>
+  </details>
+</section>
+<section class="gc-detail-card" aria-labelledby="data-title-2">
+  <h2 class="gc-section-title" id="data-title-2"><i class="icon cil-money" aria-hidden="true"></i> Forderung</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field gc-field-money"><dt>offen</dt><dd>{{row.Beleg_Offen|number_format }} &euro;</dd></div>
+    <div class="gc-data-field gc-field-money gc-field-total"><dt>offen (Kunde gesamt)</dt><dd>{{row.Kunde_offen_gesamt|number_format }} &euro;</dd></div>
+    <div class="gc-data-field gc-field-age"><dt>Tage</dt><dd>{{row.Beleg_Tage_offen }}</dd></div>
+    <div class="gc-data-field"><dt>Staffel</dt><dd>{{row.Staffel_Text }}</dd></div>
+    <div class="gc-data-field"><dt>Mahnstufe</dt><dd>{{row.Mahnstufe }}</dd></div>
+  </dl>
+</section>
+<section class="gc-detail-card" aria-labelledby="data-title-3">
+  <h2 class="gc-section-title" id="data-title-3"><i class="icon cil-user" aria-hidden="true"></i> Kunde</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Kunden-Nr</dt><dd>{{row.Kunde_Nr }}</dd></div>
+    <div class="gc-data-field"><dt>Name</dt><dd>{{row.Kunde_Name }}</dd></div>
+    <div class="gc-data-field"><dt>PLZ / Ort</dt><dd>{{row.Kunde_PLZ }} {{row.Kunde_Ort }}</dd></div>
+    <div class="gc-data-field"><dt>Telefon</dt><dd>{{row.Kunde_Telefon }}</dd></div>
+    <div class="gc-data-field"><dt>E-Mail</dt><dd><a href="mailto:{{row.Kunde_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Kunde_Email }}</a></dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Kunde</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Adresse</dt><dd>{{row.Kunde_Adresse }}</dd></div>
+    <div class="gc-data-field"><dt>Land</dt><dd>{{row.Kunde_Land }}</dd></div>
+    <div class="gc-data-field"><dt>Zahlungsbedingung</dt><dd>{{row.Payment_Terms_Code }}</dd></div>
+    <div class="gc-data-field"><dt>Kundengruppe</dt><dd>{{row.Customer_Group_Description }}</dd></div>
+  </dl>
+  </details>
+</section>
 {% if row.Fahrzeug_Leasing == 'J' %}
-<div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Leasing-Kunde</th>
-      </tr>
-
-      <tr>
-        <td><strong>Kunden-Nr:</strong></td>
-        <td>{{row.Leasing_Kunde_Nr }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Name:</strong></td>
-        <td>{{row.Leasing_Kunde_Name }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Adresse:</strong></td>
-        <td>{{row.Leasing_Kunde_Adresse }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>PLZ / Ort:</strong></td>
-        <td>{{row.Leasing_Kunde_PLZ }} {{row.Leasing_Kunde_Ort }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Land:</strong></td>
-        <td>{{row.Leasing_Kunde_Land }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Telefon:</strong></td>
-        <td>{{row.Leasing_Kunde_Telefon }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>E-Mail:</strong></td>
-        <td><a href="mailto:{{row.Leasing_Kunde_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Leasing_Kunde_Email }}</a></td>
-      </tr>
-    </table>
-  </div>
+<section class="gc-detail-card" aria-labelledby="data-title-4">
+  <h2 class="gc-section-title" id="data-title-4"><i class="icon cil-briefcase" aria-hidden="true"></i> Leasing-Kunde</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Name</dt><dd>{{row.Leasing_Kunde_Name }}</dd></div>
+    <div class="gc-data-field"><dt>Telefon</dt><dd>{{row.Leasing_Kunde_Telefon }}</dd></div>
+    <div class="gc-data-field"><dt>E-Mail</dt><dd><a href="mailto:{{row.Leasing_Kunde_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Leasing_Kunde_Email }}</a></dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Leasing-Kunde</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Kunden-Nr</dt><dd>{{row.Leasing_Kunde_Nr }}</dd></div>
+    <div class="gc-data-field"><dt>Adresse</dt><dd>{{row.Leasing_Kunde_Adresse }}</dd></div>
+    <div class="gc-data-field"><dt>PLZ / Ort</dt><dd>{{row.Leasing_Kunde_PLZ }} {{row.Leasing_Kunde_Ort }}</dd></div>
+    <div class="gc-data-field"><dt>Land</dt><dd>{{row.Leasing_Kunde_Land }}</dd></div>
+  </dl>
+  </details>
+</section>
 {% endif %}
-
-
 {% if row.Versicherung == 'J' and row.Vers_Adresse_ID != '' %}
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Versicherung</th>
-      </tr>
-      <tr>
-        <td><strong>Name:</strong></td>
-        <td>{{row.Vers_Name }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Adresse:</strong></td>
-        <td>{{row.Vers_Adresse }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>PLZ / Ort:</strong></td>
-        <td>{{row.Vers_PLZ }} {{row.Vers_Ort }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Telefon:</strong></td>
-        <td>{{row.Vers_Telefon }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Telefax:</strong></td>
-        <td>{{row.Vers_Telefax }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Webseite:</strong></td>
-        <td><a href="{{row.Vers_Web }}" hx-disable="true" target="_blank">{{row.Vers_Web }}</a></td>
-      </tr>
-
-      <tr>
-        <td><strong>Vers_Email:</strong></td>
-        <td><a href="mailto:{{row.Vers_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Vers_Email }}</a></td>
-      </tr>
-    </table>
-  </div>
+<section class="gc-detail-card" aria-labelledby="data-title-5">
+  <h2 class="gc-section-title" id="data-title-5"><i class="icon cil-shield-alt" aria-hidden="true"></i> Versicherung</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Name</dt><dd>{{row.Vers_Name }}</dd></div>
+    <div class="gc-data-field"><dt>Telefon</dt><dd>{{row.Vers_Telefon }}</dd></div>
+    <div class="gc-data-field"><dt>E-Mail</dt><dd><a href="mailto:{{row.Vers_Email }}?subject={{row.Beleg_Nr }}" hx-disable="true">{{row.Vers_Email }}</a></dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Versicherung</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Adresse</dt><dd>{{row.Vers_Adresse }}</dd></div>
+    <div class="gc-data-field"><dt>PLZ / Ort</dt><dd>{{row.Vers_PLZ }} {{row.Vers_Ort }}</dd></div>
+    <div class="gc-data-field"><dt>Telefax</dt><dd>{{row.Vers_Telefax }}</dd></div>
+    <div class="gc-data-field"><dt>Webseite</dt><dd><a href="{{row.Vers_Web }}" hx-disable="true" target="_blank">{{row.Vers_Web }}</a></dd></div>
+  </dl>
+  </details>
+</section>
 {% endif %}
-
-
-  <div>
-    <table class="table table-sm">
-      <tr>
-        <th colspan="2">Fahrzeug</th>
-      </tr>
-      <tr>
-        <td><strong>VIN:</strong></td>
-        <td>{{row.Fahrzeug_VIN }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Marke:</strong></td>
-        <td>{{row.Fahrzeug_Marke_Nr }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Modell:</strong></td>
-        <td>{{row.Fahrzeug_Modell_Nr }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Modell Name:</strong></td>
-        <td>{{row.Fahrzeug_Modell_Name }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Kategoriecode:</strong></td>
-        <td>{{row.Fahrzeug_Kategoriecode }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Halter:</strong></td>
-        <td>{{row.Fahrzeug_Kunde_Nr }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Kennzeichen:</strong></td>
-        <td>{{row.Fahrzeug_Kennzeichen }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>KM-Stand:</strong></td>
-        <td>{{row.Fahrzeug_Kmstand }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Antriebsart:</strong></td>
-        <td>{{row.Fahrzeug_Antriebsart }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Erstzulassung:</strong></td>
-        <td>{{row.Fahrzeug_Erstzulassung|date_format }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Kaufdatum:</strong></td>
-        <td>{{row.Fahrzeug_Kaufdatum|date_format }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Anzahl Vorbesitzer:</strong></td>
-        <td>{{row.Fahrzeug_Vorbesitzer_Anzahl }}</td>
-      </tr>
-
-      <tr>
-        <td><strong>Vorbesitzer:</strong></td>
-        <td>{{row.Fahrzeug_Vorbesitzer_Kunde_Nr }}</td>
-      </tr>
-    </table>
-  </div>
-</div>
+<section class="gc-detail-card" aria-labelledby="data-title-6">
+  <h2 class="gc-section-title" id="data-title-6"><i class="icon cil-car-alt" aria-hidden="true"></i> Fahrzeug</h2>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Kennzeichen</dt><dd>{{row.Fahrzeug_Kennzeichen }}</dd></div>
+    <div class="gc-data-field"><dt>VIN</dt><dd>{{row.Fahrzeug_VIN }}</dd></div>
+    <div class="gc-data-field"><dt>Modell</dt><dd>{{row.Fahrzeug_Modell_Name }}</dd></div>
+    <div class="gc-data-field"><dt>KM-Stand</dt><dd>{{row.Fahrzeug_Kmstand }}</dd></div>
+  </dl>
+  <details class="gc-data-more">
+    <summary>Weitere Infos<span class="visually-hidden"> – Fahrzeug</span></summary>
+  <dl class="gc-data-fields">
+    <div class="gc-data-field"><dt>Marke</dt><dd>{{row.Fahrzeug_Marke_Nr }}</dd></div>
+    <div class="gc-data-field"><dt>Modell</dt><dd>{{row.Fahrzeug_Modell_Nr }}</dd></div>
+    <div class="gc-data-field"><dt>Kategoriecode</dt><dd>{{row.Fahrzeug_Kategoriecode }}</dd></div>
+    <div class="gc-data-field"><dt>Halter</dt><dd>{{row.Fahrzeug_Kunde_Nr }}</dd></div>
+    <div class="gc-data-field"><dt>Antriebsart</dt><dd>{{row.Fahrzeug_Antriebsart }}</dd></div>
+    <div class="gc-data-field"><dt>Erstzulassung</dt><dd>{{row.Fahrzeug_Erstzulassung|date_format }}</dd></div>
+    <div class="gc-data-field"><dt>Kaufdatum</dt><dd>{{row.Fahrzeug_Kaufdatum|date_format }}</dd></div>
+    <div class="gc-data-field"><dt>Anzahl Vorbesitzer</dt><dd>{{row.Fahrzeug_Vorbesitzer_Anzahl }}</dd></div>
+    <div class="gc-data-field"><dt>Vorbesitzer</dt><dd>{{row.Fahrzeug_Vorbesitzer_Kunde_Nr }}</dd></div>
+  </dl>
+  </details>
+</section>

+ 7 - 0
templates/forderungen/details/files_panel.html

@@ -0,0 +1,7 @@
+<section class="gc-detail-card" id="case-files" aria-labelledby="files-title"{% if files_oob %} hx-swap-oob="outerHTML"{% endif %}>
+  <h2 class="gc-section-title" id="files-title"><i class="icon cil-folder-open" aria-hidden="true"></i> Dateien</h2>
+  {% if files_error %}<p class="gc-section-description" role="status">{{ files_error }}</p>{% endif %}
+  <div class="gc-table-scroll" tabindex="0" role="region" aria-label="Dateien">
+    {% include 'forderungen/details/details_dateien.html' %}
+  </div>
+</section>

+ 15 - 0
templates/forderungen/details/history_tabs.html

@@ -0,0 +1,15 @@
+{% macro history_tabs(section, scope, detail_url, vehicle_missing, target) %}
+<div class="tabs history-tabs" role="group" aria-label="{{ 'Kommentare' if section == 'kommentare' else 'Buchungsbelege' }} filtern">
+    {% for value, label in [('invoice', 'Diese Rechnung'), ('open', 'Alle offenen Rechnungen'),
+                             ('vehicle', 'Dieses Fahrzeug'), ('debtor', 'Debitor Historie')] %}
+    <button type="button" class="tab history-tab{% if scope == value %} active{% endif %}"
+        aria-pressed="{{ 'true' if scope == value else 'false' }}"
+        hx-get="{{ detail_url }}/{{ section }}?scope={{ value }}"
+        hx-target="#{{ target }}" hx-swap="outerHTML" hx-push-url="false"
+        hx-sync="#{{ target }}:replace"
+        {% if value == 'vehicle' and vehicle_missing %}disabled title="Kein Fahrzeug zur Rechnung hinterlegt"{% endif %}>
+        {{ label }}
+    </button>
+    {% endfor %}
+</div>
+{% endmacro %}

+ 22 - 0
templates/forderungen/details/notice.html

@@ -0,0 +1,22 @@
+{% extends "base/base.html" %}
+{% block content %}
+<section class="gc-card p-4 my-4" aria-labelledby="forderung-hinweis">
+  <h2 id="forderung-hinweis">Forderungsinformation</h2>
+  {% if kind == 'open' %}
+  <p>Forderung {{ forderung.Beleg_Nr }} vom {{ forderung.Beleg_Datum|date_format if forderung.Beleg_Datum is not none else 'nicht hinterlegt' }} ist noch offen.</p>
+  <dl class="row">
+    <dt class="col-sm-4">Kunde</dt>
+    <dd class="col-sm-8">{{ forderung.Kunde_Text or 'nicht hinterlegt' }}</dd>
+    <dt class="col-sm-4">Rechnungsbetrag</dt>
+    <dd class="col-sm-8">{% if forderung.Beleg_Betrag is not none %}{{ forderung.Beleg_Betrag|number_format }} €{% else %}nicht hinterlegt{% endif %}</dd>
+    <dt class="col-sm-4">Offener Betrag</dt>
+    <dd class="col-sm-8">{% if forderung.Beleg_Offen is not none %}{{ forderung.Beleg_Offen|number_format }} €{% else %}nicht hinterlegt{% endif %}</dd>
+  </dl>
+  {% elif kind == 'settled' %}
+  <p>Forderung {{ forderung.Beleg_Nr }} vom {{ forderung.Beleg_Datum|date_format if forderung.Beleg_Datum is not none else 'nicht hinterlegt' }} wurde am {{ forderung.Auszifferung_Datum|date_format if forderung.Auszifferung_Datum is not none else 'nicht hinterlegt' }} beglichen.</p>
+  {% else %}
+  <p>Eintrag nicht gefunden.</p>
+  {% endif %}
+  <a class="btn btn-primary" hx-boost="false" data-gc-return-url="{{ return_url }}" href="{{ return_url|default('/app/forderungen/liste') }}">Zurück zur Liste</a>
+</section>
+{% endblock %}

+ 3 - 3
templates/forderungen/details/queries/auftraege_positionen.sql

@@ -3,6 +3,6 @@ SELECT TOP 100 [Auftrag_Nr]
      , [Betrag]
 FROM [dbo].[Auftraege_Positionen]
 WHERE (
-	Client_DB = {{ appsmith.URL.queryParams.Client_DB }}
-AND [Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }}
-) OR 1 != 1
+	Client_DB = :client_db
+AND [Beleg_Nr] = :beleg_nr
+) OR 1 != 1

+ 18 - 25
templates/forderungen/details/queries/forderungen_buchungen.sql

@@ -1,25 +1,18 @@
-SELECT TOP 1000 [Client_DB]
-     , [Kunde_Nr]
-     , [Fahrzeug_Nr]
-     , [Beleg_Nr]
-     , [Bezug_Beleg_Nr]
-     , [Beleg_Datum]
-     , [Beleg_Beschreibung]
-     , [Betrag]
-     , [Benutzer_ID]
-     , [Bezahlt]
-     , [Beleg_Art]
-FROM [dbo].[Forderungen_Buchungen]
-WHERE (
-	[Client_DB] = {{ appsmith.URL.queryParams.Client_DB }}
-AND [Kunde_Nr] IN (SELECT [Kunde_Nr] FROM [dbo].[Forderungen_Mahnungen] WHERE [Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }} )
-AND (
-	('D' = '{{ BelegeFilter.selectedOptionValue }}')
-	OR
-	('F' = '{{ BelegeFilter.selectedOptionValue }}' AND [Fahrzeug_Nr] IN (SELECT [Fahrzeug_Nr] FROM [dbo].[Forderungen_Mahnungen] WHERE [Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }} )) 
-
-)
-	
-) OR 1 != 1
-
-ORDER BY [Beleg_Datum], [Beleg_Art], [Beleg_Nr]
+{% include 'forderungen/details/queries/history_scope.sql' %}
+SELECT TOP 1000 B.Client_DB, B.Kunde_Nr, B.Fahrzeug_Nr, B.Beleg_Nr, B.Bezug_Beleg_Nr,
+    B.Beleg_Datum, B.Beleg_Beschreibung, B.Betrag, B.Benutzer_ID, B.Bezahlt, B.Beleg_Art
+FROM dbo.Forderungen_Buchungen AS B
+WHERE B.Client_DB = :client_db
+  AND EXISTS (SELECT 1 FROM current_invoice AS C WHERE C.Kunde_Nr = B.Kunde_Nr)
+  AND (
+      :scope = 'debtor'
+      OR (:scope = 'vehicle' AND EXISTS (
+          SELECT 1 FROM current_invoice AS C
+          WHERE C.Fahrzeug_Nr IS NOT NULL AND C.Fahrzeug_Nr <> '' AND C.Fahrzeug_Nr = B.Fahrzeug_Nr
+      ))
+      OR EXISTS (
+          SELECT 1 FROM scoped_invoices AS I
+          WHERE I.Client_DB = B.Client_DB AND (I.Beleg_Nr = B.Beleg_Nr OR I.Beleg_Nr = B.Bezug_Beleg_Nr)
+      )
+  )
+ORDER BY B.Beleg_Datum, B.Beleg_Art, B.Beleg_Nr, B.Bezug_Beleg_Nr, B.Benutzer_ID

+ 16 - 10
templates/forderungen/details/queries/forderungen_details.sql

@@ -1,5 +1,8 @@
 SELECT [F].*
-     , round([Beleg_offen] * 0.19, 2) AS [Mwst_Betrag_berechnet]
+     , [F].[Kunde_Gesamt_Offen] AS [Kunde_offen_gesamt]
+     , coalesce([B].[Name], [FD].[Verursacher_Benutzer_ID], [F].[Verursacher_Text]) AS [Verursacher_Aktuell_Text]
+     , coalesce([FD].[Verursacher_Benutzer_ID], [F].[Verursacher_Benutzer_ID]) AS [Verursacher_Aktuell_Benutzer_ID]
+     , round([Beleg_Offen] * 0.19, 2) AS [Mwst_Betrag_berechnet]
      , [K].[Kunde_Name]
      , [K].[Kunde_Nachname]
      , [K].[Kunde_Vorname]
@@ -12,8 +15,8 @@ SELECT [F].*
      , [K].[Kunde_Email]
      , [K].[Payment_Terms_Code]
      , [K].[Gen_Bus_Posting_Group]
-     , [K].[Customer_Group_Code]
-     , [K].[Customer_Group_Description]
+     , [K].[Kunde_Kundengruppe_Code] AS [Customer_Group_Code]
+     , [K].[Kunde_Kundengruppe_Text] AS [Customer_Group_Description]
      , isnull([FD].[Bearbeitet], 'N') AS [Bearbeitet]
      , isnull([FD].[Versicherung], 'N') AS [Versicherung]
      , isnull([FD].[Rechtsanwalt], 'N') AS [Rechtsanwalt]
@@ -51,8 +54,8 @@ SELECT [F].*
      , [FZ].[Fahrzeug_Erstzulassung]
      , [FZ].[Fahrzeug_Kaufdatum]
      , [FZ].[Fahrzeug_Vorbesitzer_Anzahl]
-     , [FZ].[Fahrzeug_Vorbesitzer_Kunde_Nr]     
-     , iif(K.Kunde_Nr = K2.Kunde_Nr, 'N', 'J') as Fahrzeug_Leasing
+     , [FZ].[Fahrzeug_Vorbesitzer_Kunde_Nr]
+     , iif([K].[Kunde_Nr] = [K2].[Kunde_Nr], 'N', 'J') AS [Fahrzeug_Leasing]
      , [K2].[Kunde_Nr] AS [Leasing_Kunde_Nr]
      , [K2].[Kunde_Name] AS [Leasing_Kunde_Name]
      , [K2].[Kunde_Nachname] AS [Leasing_Kunde_Nachname]
@@ -63,12 +66,15 @@ SELECT [F].*
      , [K2].[Kunde_Ort] AS [Leasing_Kunde_Ort]
      , [K2].[Kunde_Land] AS [Leasing_Kunde_Land]
      , [K2].[Kunde_Telefon] AS [Leasing_Kunde_Telefon]
-     , [K2].[Kunde_Email] AS [Leasing_Kunde_Email]     
+     , [K2].[Kunde_Email] AS [Leasing_Kunde_Email]
 FROM [dbo].[Forderungen_Kopf] [F]
          LEFT JOIN [dbo].[Kunden] [K] ON [F].[Kunde_Nr] = [K].[Kunde_Nr] AND [F].[Client_DB] = [K].[Client_DB]
-         LEFT JOIN [dbo].[Fahrzeuge] FZ ON F.[Fahrzeug_Nr] = FZ.[Fahrzeug_Nr] AND [F].[Client_DB] = [FZ].[Client_DB]
+         LEFT JOIN [dbo].[Fahrzeuge] [FZ] ON [F].[Fahrzeug_Nr] = [FZ].[Fahrzeug_Nr] AND [F].[Client_DB] = [FZ].[Client_DB]
          LEFT JOIN [dbo].[Kunden] [K2] ON [FZ].[Fahrzeug_Kunde_Nr] = [K2].[Kunde_Nr] AND [FZ].[Client_DB] = [K2].[Client_DB]
-         LEFT JOIN [dbo].[Forderungen_Details] [FD] ON [F].[Beleg_Nr] = [FD].[Beleg_Nr] AND [F].[Client_DB] = [FD].[Client_DB] 
+         LEFT JOIN [dbo].[Forderungen_Details] [FD] ON [F].[Beleg_Nr] = [FD].[Beleg_Nr] AND [F].[Client_DB] = [FD].[Client_DB]
+         LEFT JOIN (SELECT [Benutzer_ID], max(nullif([Name], '')) AS [Name]
+                    FROM [dbo].[Benutzer_Rolle]
+                    GROUP BY [Benutzer_ID]) [B] ON [FD].[Verursacher_Benutzer_ID] = [B].[Benutzer_ID]
          LEFT JOIN [dbo].[Versicherungen] [V] ON [FD].[Vers_Adresse_ID] = [V].[Vers_Adresse_ID]
-WHERE [F].[Client_DB] = {{ appsmith.URL.queryParams.Client_DB }}
-AND [F].[Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }}
+WHERE [F].[Client_DB] = :client_db
+  AND [F].[Beleg_Nr] = :beleg_nr

+ 13 - 9
templates/forderungen/details/queries/forderungen_kommentare.sql

@@ -1,9 +1,13 @@
-SELECT [Timestamp],
- [Benutzer_ID],
- [Name],
- [Rolle],
- [Kommentar]
- 
-FROM [dbo].[Forderungen_Kommentar_Benutzer]
-WHERE [Client_DB] = {{ appsmith.URL.queryParams.Client_DB }}
-AND [Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }}
+{% if scope != 'invoice' %}{% include 'forderungen/details/queries/history_scope.sql' %}{% endif %}
+SELECT K.[Timestamp], K.Benutzer_ID, K.Name, K.Rolle_ID, K.Rolle_Name, K.Kommentar, K.Beleg_Nr
+FROM dbo.Forderungen_Kommentar_Benutzer AS K
+WHERE K.Client_DB = :client_db
+  {% if scope == 'invoice' %}
+  AND K.Beleg_Nr = :beleg_nr
+  {% else %}
+  AND EXISTS (
+      SELECT 1 FROM scoped_invoices AS I
+      WHERE I.Client_DB = K.Client_DB AND I.Beleg_Nr = K.Beleg_Nr
+  )
+  {% endif %}
+ORDER BY K.[Timestamp], K.Beleg_Nr, K.Benutzer_ID

+ 3 - 3
templates/forderungen/details/queries/forderungen_mahnungen.sql

@@ -9,7 +9,7 @@ SELECT TOP 100 [Client_DB]
      , 'N' as [Bezahlt]
 FROM [dbo].[Forderungen_Mahnungen]
 WHERE (
-	[Client_DB] = {{ appsmith.URL.queryParams.Client_DB }}
-AND [Kunde_Nr] IN (SELECT [Kunde_Nr] FROM [dbo].[Forderungen_Mahnungen] WHERE [Beleg_Nr] = {{ appsmith.URL.queryParams.Beleg_Nr }} )
+	[Client_DB] = :client_db
+AND [Kunde_Nr] IN (SELECT [Kunde_Nr] FROM [dbo].[Forderungen_Mahnungen] WHERE [Client_DB] = :client_db AND [Beleg_Nr] = :beleg_nr)
 ) OR 1 != 1
-ORDER BY [Mahnung_Datum], [Beleg_Nr]
+ORDER BY [Mahnung_Datum], [Beleg_Nr]

+ 31 - 0
templates/forderungen/details/queries/history_scope.sql

@@ -0,0 +1,31 @@
+WITH current_invoice AS (
+    SELECT Client_DB, Beleg_Nr, Kunde_Nr, Fahrzeug_Nr
+    FROM dbo.Forderungen_Kopf
+    WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+), scoped_invoices AS (
+    {% if scope == 'invoice' %}
+    SELECT Client_DB, Beleg_Nr FROM current_invoice
+    {% elif scope == 'open' %}
+    SELECT F.Client_DB, F.Beleg_Nr FROM dbo.Forderungen_Kopf AS F
+    WHERE F.Client_DB = :client_db AND F.Beleg_Offen <> 0
+      AND EXISTS (SELECT 1 FROM current_invoice AS C WHERE C.Kunde_Nr = F.Kunde_Nr)
+    {% else %}
+    SELECT F.Client_DB, F.Beleg_Nr FROM dbo.Forderungen_Kopf AS F
+    WHERE F.Client_DB = :client_db
+      AND EXISTS (
+          SELECT 1 FROM current_invoice AS C WHERE C.Kunde_Nr = F.Kunde_Nr
+          {% if scope == 'vehicle' %}
+            AND C.Fahrzeug_Nr IS NOT NULL AND C.Fahrzeug_Nr <> '' AND C.Fahrzeug_Nr = F.Fahrzeug_Nr
+          {% endif %}
+      )
+    UNION
+    SELECT H.Client_DB, H.Beleg_Nr FROM dbo.Forderungen_Historie AS H
+    WHERE H.Client_DB = :client_db
+      AND EXISTS (
+          SELECT 1 FROM current_invoice AS C WHERE C.Kunde_Nr = H.Kunde_Nr
+          {% if scope == 'vehicle' %}
+            AND C.Fahrzeug_Nr IS NOT NULL AND C.Fahrzeug_Nr <> '' AND C.Fahrzeug_Nr = H.Fahrzeug_Nr
+          {% endif %}
+      )
+    {% endif %}
+)

+ 1 - 1
templates/forderungen/details/queries/post/post_comments.sql

@@ -1,2 +1,2 @@
 INSERT INTO [dbo].[Forderungen_Kommentar] ([Client_DB], [Beleg_Nr], [Timestamp], [Benutzer_ID], [Kommentar])
-VALUES ('{{data.Client_DB}}', '{{data.Beleg_Nr}}', '{{data.Timestamp}}', '{{data.Benutzer_ID}}', '{{data.Kommentar}}')
+VALUES (:Client_DB, :Beleg_Nr, :Timestamp, :Benutzer_ID, :Kommentar)

+ 21 - 21
templates/forderungen/details/queries/post/post_details.sql

@@ -1,30 +1,30 @@
 IF NOT exists (SELECT 1
                FROM [dbo].[Forderungen_Details]
-               WHERE [Client_DB] = '{{data.Client_DB}}'
-                 AND [Beleg_Nr] = '{{data.Beleg_Nr}}')
+               WHERE [Client_DB] = :Client_DB
+                 AND [Beleg_Nr] = :Beleg_Nr)
     BEGIN
         INSERT INTO [dbo].[Forderungen_Details] ( [Client_DB], [Beleg_Nr])
-        VALUES ('{{data.Client_DB}}', '{{data.Beleg_Nr}}')
+        VALUES (:Client_DB, :Beleg_Nr)
     END;
 
 
 UPDATE [dbo].[Forderungen_Details]
 SET [Bearbeitet] = 'J'
-  , [Versicherung] = '{{data.Versicherung}}'
-  , [Rechtsanwalt] = '{{data.Rechtsanwalt}}'
-  , [Reklamation] = '{{data.Reklamation}}'
-  , [Mahnen_aussetzen] = '{{data.Mahnen_aussetzen}}'
-  , [Selbstbeteiligung] = '{{data.Selbstbeteiligung}}'
-  , [Selbstbeteiligung_Betrag] = '{{data.Selbstbeteiligung_Betrag}}'
-  , [Mwst] = '{{data.Mwst}}'
-  , [Mwst_Betrag] = '{{data.Mwst_Betrag}}'
-  , [Wiedervorlage] = '{{data.Wiedervorlage}}'
-  , [Vers_Adresse_ID] = '{{data.Vers_Adresse_ID}}'
-  , [Versicherung_Typ] = '{{data.Versicherung_Typ}}'
-  , [Reklamation_Begruendung] = '{{data.Reklamation_Begruendung}}'
-  , [Rechtsanwalt_Begruendung] = '{{data.Rechtsanwalt_Begruendung}}'
-  , [Rechtsanwalt_Aktenzeichen] = '{{data.Rechtsanwalt_Aktenzeichen}}'
-  , [Rechtsanwalt_Stand] = '{{data.Rechtsanwalt_Stand}}'
-  , [Mahnen_Begruendung] = '{{data.Mahnen_Begruendung}}'
-WHERE [Client_DB] = '{{data.Client_DB}}'
-  AND [Beleg_Nr] = '{{data.Beleg_Nr}}'
+  , [Versicherung] = :Versicherung
+  , [Rechtsanwalt] = :Rechtsanwalt
+  , [Reklamation] = :Reklamation
+  , [Mahnen_aussetzen] = :Mahnen_aussetzen
+  , [Selbstbeteiligung] = :Selbstbeteiligung
+  , [Selbstbeteiligung_Betrag] = :Selbstbeteiligung_Betrag
+  , [Mwst] = :Mwst
+  , [Mwst_Betrag] = :Mwst_Betrag
+  , [Wiedervorlage] = NULLIF(:Wiedervorlage, '')
+  , [Vers_Adresse_ID] = :Vers_Adresse_ID
+  , [Versicherung_Typ] = :Versicherung_Typ
+  , [Reklamation_Begruendung] = :Reklamation_Begruendung
+  , [Rechtsanwalt_Begruendung] = :Rechtsanwalt_Begruendung
+  , [Rechtsanwalt_Aktenzeichen] = :Rechtsanwalt_Aktenzeichen
+  , [Rechtsanwalt_Stand] = :Rechtsanwalt_Stand
+  , [Mahnen_Begruendung] = :Mahnen_Begruendung
+WHERE [Client_DB] = :Client_DB
+  AND [Beleg_Nr] = :Beleg_Nr

+ 0 - 2
templates/forderungen/liste/config/liste_filter.csv

@@ -17,5 +17,3 @@ Bearbeitet;select;2;;;;;
 Abwarten;select;2;;;;;
 WiedervorlageVon;date;2;Wiedervorlage von;Wiedervorlage;;;
 WiedervorlageBis;date;2;Wiedervorlage bis;Wiedervorlage;;;
-
-BenutzerSelect;hidden;2;Benutzer;;;;winter

+ 13 - 14
templates/forderungen/liste/liste_kopfzeile.html

@@ -1,14 +1,13 @@
-    <tr>
-        <th>Filiale / Abteilung</th>
-        <th>Verursacher</th>
-        <th>RG-Betrag<br>/ RG-Nr.</th>
-        <th>RG-Datum<br>/ Fällig</th>
-        <th>Kunde</th>
-        <th>offen /<br>Kunde ges.</th>
-        <th>Mahnstufe<br>/ Tage offen</th>
-        <th>Abw.</th>
-        <th>Kommentar<br>Fibu</th>
-        <th>Kommentar<br>Abteilung</th>
-        <th>Wieder-<br>vorlage</th>
-        <th></th>
-    </tr>
+<tr>
+  <th scope="col">Filiale / Abteilung</th>
+  <th scope="col">Verursacher</th>
+  <th scope="col">Rechnungs<wbr>betrag / Belegnummer</th>
+  <th scope="col">Rechnungs<wbr>datum / Fälligkeit</th>
+  <th scope="col">Kunde</th>
+  <th scope="col">Offen / Kunde gesamt</th>
+  <th scope="col">Tage offen / Mahnstufe</th>
+  <th scope="col">Abwarten</th>
+  <th scope="col">Kommentare</th>
+  <th scope="col">Wiedervorlage</th>
+  <th scope="col"><span class="visually-hidden">Details öffnen</span></th>
+</tr>

+ 64 - 30
templates/forderungen/liste/liste_zeile.html

@@ -1,87 +1,121 @@
-<tr>
+{% set comments_id = 'row-comments-' ~ (row.Client_DB|string|urlencode) ~ '-' ~ (row.Beleg_Nr|string|urlencode) %}
+{% set has_comments = row.Kommentar_Fibu or row.Kommentar_Abteilung or row.Antrag_Nr %}
+{% set primary_key = row.Client_DB|string ~ '_' ~ row.Beleg_Nr|string %}
+{% set origin = list_url|default('/app/forderungen/liste') %}
+{% from 'forderungen/verursacher/button.html' import edit_button %}
+{% set row_return_url = origin ~ ('&' if '?' in origin else '?') ~ 'focus=' ~ (primary_key|urlencode) %}
+<tr class="gc-invoice-row" data-primary-key="{{ primary_key }}" tabindex="-1">
   <td>
     <div class="gc-title">{{ row.Standort_Name }}</div>
     <div class="gc-subtitle">{{ row.Abteilung }}</div>
   </td>
 
   <td>
+    <div class="gc-assignee-value">
     <a href="/app/forderungen/liste?Verursacher={{ row.Verursacher_Text|urlencode }}"
       class="fw-semibold gc-link">
       {{ row.Verursacher_Text }}
     </a>
+    {{ edit_button('/app/forderungen/liste/' ~ (primary_key|urlencode) ~ '/verursacher?return_to=' ~ (origin|urlencode), primary_key) }}
+    </div>
     {% if row.Verursacher_Text == '--N.N.' %}
-    <span class="gc-badge gc-badge-warning ms-1">offen</span>
+    <span class="gc-list-badge gc-list-badge-warning ms-1">offen</span>
     {% endif %}
   </td>
 
   <td class="text-end align-top">
     <div class="gc-money">{{ row.Beleg_Betrag|number_format }} €</div>
-    <a href="#" data-coreui-toggle="modal" data-coreui-target="#exampleModal" onclick='javascript:document.getElementById("invoiceIframe").src="/app/forderungen/files/{{ row.Client_DB }}_{{ row.Beleg_Nr }}";'>
-      <span class="gc-badge gc-badge-info">{{ row.Beleg_Nr }}</span>
+    <a href="#" hx-boost="false" aria-label="Rechnung {{ row.Beleg_Nr }} als PDF öffnen" data-coreui-toggle="modal" data-coreui-target="#exampleModal" onclick='javascript:document.getElementById("invoiceIframe").src="/app/forderungen/files/{{ row.Client_DB }}_{{ row.Beleg_Nr }}";'>
+      <span class="gc-list-badge gc-list-badge-info">{{ row.Beleg_Nr }}</span>
     </a>
   </td>
 
   <td>
     <div>{{ row.Beleg_Datum|date_format }}</div>
-    <div class="gc-subtitle">fällig {{ row.Fällig_Datum|date_format }}</div>
+    <div class="gc-subtitle">fällig {{ row.Beleg_Faellig_Datum|date_format }}</div>
   </td>
 
   <td class="gc-main-cell">
     <a class="gc-title" href="/app/forderungen/liste?Kunde={{ row.Kunde_Text|urlencode }}">
       {{ row.Kunde_Text }}
     </a>
-    <div class="gc-subtitle">
-      {{ row.Besitzer_Kunde_Text or '' }}
       {% if row.Kunde_Email %}
-      · <a href="mailto:{{ row.Kunde_Email }}?subject={{ row.Beleg_Nr }}" hx-disable="true">E-Mail</a>
+      &nbsp;
+      <a href="mailto:{{ row.Kunde_Email }}?subject={{ row.Beleg_Nr }}" hx-disable="true" class="btn btn-outline-secondary gc-email-btn"
+        aria-label="E-Mail an {{ row.Kunde_Text }} senden" title="E-Mail senden">
+        <i class="icon cil-envelope-closed" aria-hidden="true"></i>
+      </a>
       {% endif %}
+
+    <div class="gc-subtitle">
+      {{ row.Besitzer_Kunde_Text or '' }}
     </div>
   </td>
 
   <td class="text-end">
-    <div class="gc-money">{{ row.Beleg_offen|number_format }} €</div>
+    <div class="gc-money">{{ row.Beleg_Offen|number_format }} €</div>
     <div class="gc-subtitle">{{ row.Kunde_gesamt_Bezug }} {{ row.Kunde_offen_gesamt|number_format }} €</div>
   </td>
 
   <td class="text-end">
+    <div>{{ row.Beleg_Tage_offen }} Tage</div>
     {% set mahnstufe = row.Mahnstufe or '0' %}
 
     {% if mahnstufe and mahnstufe|string != '0' %}
-    <span class="gc-badge gc-badge-danger gc-mahnstufe-{{ mahnstufe }}">
-      M{{ mahnstufe }}
-    </span>
+    <div class="gc-subtitle">
+      <span class="gc-document-badge gc-document-badge--M{{ mahnstufe }}">M{{ mahnstufe }}</span>
+    </div>
     {% endif %}
-    <div class="gc-subtitle">{{ row.Beleg_Tage_offen }} Tage</div>
   </td>
 
   <td class="text-end">
     {% if row.Abwarten %}
-    <span class="gc-badge gc-badge-warning">{{ row.Abwarten }}</span>
+    <span class="gc-list-badge gc-list-badge-warning">{{ row.Abwarten }}</span>
     {% endif %}
   </td>
 
   <td>
-    <div class="gc-subtitle">{{ row.Kommentar_Fibu or '' }}</div>
-  </td>
-
-  <td>
-    {% if row.Antrag_Nr %}
-    <div class="gc-subtitle">{{ row.Antrag_Art }} {{ row.Antrag_Nr }} vom {{ row.Antrag_Datum|date_format }}<br>{{ row.Antrag_Benutzer_ID }}, Status: {{ row.Antrag_Status }}</div>
-    {% else %}
-    <div class="gc-subtitle">{{ row.Kommentar_Abteilung or '' }}</div>
-    {% endif %}
+    {% if has_comments %}
+    <button type="button" class="btn gc-comment-toggle" data-gc-comments aria-expanded="false" aria-controls="{{ comments_id }}">
+      <i class="icon cil-chat-bubble" aria-hidden="true"></i> <span>Anzeigen</span><span class="visually-hidden"> – {{ row.Beleg_Nr }}</span>
+    </button>
+    {% else %}<span class="gc-subtitle">Keine</span>{% endif %}
   </td>
 
   <td class="text-end">
-    {% if row.Wiedervorlage %}
-    <span class="gc-badge gc-badge-{{ row.Wiedervorlage_Stufe }}">{{ row.Wiedervorlage|date_format }}</span>
-    {% endif %}
+    <button type="button" class="gc-list-badge gc-list-badge-{{ row.Wiedervorlage_Stufe }} gc-wiedervorlage-edit"
+      hx-get="/app/forderungen/liste/{{ primary_key|urlencode }}/wiedervorlage?return_to={{ origin|urlencode }}"
+      hx-target="#wiedervorlage-modal-content" hx-swap="innerHTML" hx-push-url="false"
+      hx-sync="#wiedervorlage-modal:replace" aria-haspopup="dialog" aria-controls="wiedervorlage-modal"
+      aria-label="Wiedervorlage für Beleg {{ row.Beleg_Nr }} ändern" title="Wiedervorlage ändern">
+      <i class="icon cil-calendar" aria-hidden="true"></i>
+      {{ row.Wiedervorlage|date_format if row.Wiedervorlage else 'Festlegen' }}
+    </button>
   </td>
 
   <td>
-    <a href="/app/forderungen/details/{{ row.Client_DB }}_{{ row.Beleg_Nr }}"
-      class="btn btn-sm btn-primary gc-action-btn">
-      <i class="icon cil-pencil"></i>
+    <a href="/app/forderungen/details/{{ primary_key|urlencode }}?return_to={{ row_return_url|urlencode }}" data-gc-detail-link data-return-url="{{ row_return_url }}"
+      class="btn gc-action-btn" aria-label="Details zu Beleg {{ row.Beleg_Nr }} öffnen" title="Details öffnen">
+      <i class="icon cil-magnifying-glass" aria-hidden="true"></i>
     </a>
   </td>
-</tr>
+</tr>{% if has_comments %}
+<tr class="gc-comment-row" id="{{ comments_id }}" hidden>
+  <td colspan="11">
+    <div class="gc-row-comments">
+      <section aria-label="Finanzbuchhaltung - {{ row.Beleg_Nr }}">
+        <h3>Finanzbuchhaltung</h3>
+        <p>{{ row.Kommentar_Fibu or 'Kein Kommentar vorhanden.' }}</p>
+      </section>
+      <section aria-label="Abteilung - {{ row.Beleg_Nr }}">
+        <h3>Abteilung</h3>
+        {% if row.Antrag_Nr %}
+        <p>{{ row.Antrag_Art }} {{ row.Antrag_Nr }} vom {{ row.Antrag_Datum|date_format }}<br>{{ row.Antrag_Benutzer_ID }}, Status: {{ row.Antrag_Status }}</p>
+        {% else %}
+        <p>{{ row.Kommentar_Abteilung or 'Kein Kommentar vorhanden.' }}</p>
+        {% endif %}
+      </section>
+    </div>
+  </td>
+</tr>
+{% endif %}

+ 31 - 28
templates/forderungen/liste/queries/forderungen_liste.sql

@@ -7,40 +7,38 @@ SELECT [F].[Client_DB]
      , [F].[Standort_Name]
      , [F].[Beleg_Nr]
      , [F].[Rechnung_Gutschrift]
-     , [F].[Benutzer_ID]
+     , '' AS [Benutzer_ID]
      , [F].[Fahrzeug_Nr]
      , [F].[Beleg_Kommentar]
-     , [F].[Beleg_offen]
-     , [F].[Kunde_offen_gesamt]
+     , [F].[Beleg_Offen]
+     , [F].[Kunde_Gesamt_Offen] AS [Kunde_offen_gesamt]
      , [F].[Beleg_Datum]
-     , [F].[Verursacher_Text]
+     , isnull([FD].[Verursacher_Benutzer_ID], [F].[Verursacher_Benutzer_ID]) AS Verursacher_Benutzer_ID
+     , COALESCE([B].[Name], [FD].[Verursacher_Benutzer_ID], [F].[Verursacher_Text]) AS Verursacher_Text
      , [F].[Kunde_Text]
      , [F].[Beleg_Text]
      , [F].[Abteilung]
      , [F].[Beleg_Tage_offen]
-     , CASE
-           WHEN [F].[Beleg_Tage_offen] > 90 THEN 3
-           WHEN [F].[Beleg_Tage_offen] > 60 THEN 2
-           WHEN [F].[Beleg_Tage_offen] > 30 THEN 1
-           ELSE 0
-       END AS [Stufe]
-     , replace([F].[Staffel_Text], 'Wochen', 'W.') AS [Staffel_Text]
+     , F.[Staffel_Text]
      , [F].[Mahnstufe]
      , [F].[Forderungsart]
      --, [F].[Abwarten]
-     , [F].[Verursacher_Benutzer_ID]
      , F.[Besitzer_Kunde_Text]
      , F.[Beleg_Betrag]
      , F.[Kunde_gesamt_Bezug]
+     , [F].[Kunde_Email]
+     , F.[Beleg_Faellig_Datum]
 
      , left(isnull([FK].[Kommentar_Fibu], ''), 50) AS [Kommentar_Fibu]
      , left(isnull([FK].[Kommentar_Abteilung], ''), 50) AS [Kommentar_Abteilung]
-     , [K].[Kunde_Email] AS [Kunde_Email]
-     , coalesce([FD].[Wiedervorlage], dateadd(DAY, 14, [F].[Beleg_Datum])) AS [Wiedervorlage]
-     , case 
-        when coalesce([FD].[Wiedervorlage], dateadd(DAY, 14, [F].[Beleg_Datum])) < getdate() then '2'
-        when coalesce([FD].[Wiedervorlage], dateadd(DAY, 14, [F].[Beleg_Datum])) < dateadd(day, 4, getdate()) then '1'
-      else '0' end AS [Wiedervorlage_Stufe]
+     , isnull([FK].[Begründung], '') AS [Begründung]
+
+     , coalesce([FD].[Wiedervorlage], convert(date, [F].[Beleg_Faellig_Datum])) AS [Wiedervorlage]
+     , CASE
+          WHEN coalesce([FD].[Wiedervorlage], convert(date, [F].[Beleg_Faellig_Datum])) < getdate() THEN '2'
+          WHEN coalesce([FD].[Wiedervorlage], convert(date, [F].[Beleg_Faellig_Datum])) < dateadd(DAY, 4, getdate()) THEN '1'
+          ELSE '0'
+       END AS [Wiedervorlage_Stufe]
      , CASE
            WHEN [FD].[Reklamation] = 'J' THEN 'Rekl.'
            WHEN [FD].[Versicherung] = 'J' THEN 'Vers.'
@@ -48,9 +46,8 @@ SELECT [F].[Client_DB]
            WHEN [FD].[Mahnen_aussetzen] = 'J' THEN 'N'
            ELSE ''
        END AS [Abwarten]
-     , isnull([FK].[Begründung], '') AS [Begründung]
      , isnull([FD].[Bearbeitet], 'N') AS [Bearbeitet]
-     , dateadd(DAY, 14, [F].[Beleg_Datum]) AS [Fällig_Datum]
+
 
      , [G].[Antrag_Art]
      , [G].[Antrag_Nr]
@@ -59,15 +56,21 @@ SELECT [F].[Client_DB]
      , [G].[Antrag_Status]
      , [G].[Letzte_Beantragung]
 FROM [dbo].[Forderungen_Kopf] [F]
-         LEFT JOIN [dbo].[Kunden] [K] ON [F].[Kunde_Nr] = [K].[Kunde_Nr] AND [F].[Client_DB] = [K].[Client_DB]
          LEFT JOIN [dbo].[Forderungen_Details] [FD] ON [F].[Client_DB] = [FD].[Client_DB] AND [F].[Beleg_Nr] = [FD].[Beleg_Nr]
+         LEFT JOIN (
+             SELECT [Benutzer_ID], MAX(NULLIF([Name], '')) AS [Name]
+             FROM [dbo].[Benutzer_Rolle] GROUP BY [Benutzer_ID]
+         ) [B] ON [FD].[Verursacher_Benutzer_ID] = [B].[Benutzer_ID]
          LEFT JOIN [dbo].[Forderungen_Kommentar_letzte] [FK] ON [F].[Client_DB] = [FK].[Client_DB] AND [F].[Beleg_Nr] = [FK].[Beleg_Nr]
          LEFT JOIN [Garantie2] [G] ON [F].[Client_DB] = [G].[Client_DB] AND [F].[Beleg_Nr] = [G].[Beleg_Nr]
 ) AS F
-INNER JOIN [dbo].[Benutzer_Rechte] [BR] ON ([BR].[Benutzer_ID] = {{ BenutzerSelect.selectedOptionValue }} OR BR.Benutzer_ID = '')
-AND [F].[Hauptbetrieb_ID] = [BR].[Hauptbetrieb_ID] 
-AND [F].[Standort_ID] = [BR].[Standort_ID] 
-AND ([BR].[Rolle] = 'Buchhaltung' OR [BR].[Benutzer_ID] = [F].[Verursacher_Benutzer_ID])
-
-WHERE 1 = 1
-ORDER BY F.[Wiedervorlage] ASC, F.[Beleg_Tage_offen] DESC
+WHERE EXISTS (
+    SELECT 1
+    FROM [dbo].[Benutzer_Rechte] AS [BR]
+    WHERE [BR].[Benutzer_ID] = :auth_username
+      AND [F].[Hauptbetrieb_ID] = [BR].[Hauptbetrieb_ID]
+      AND [F].[Standort_ID] = [BR].[Standort_ID]
+      AND [F].[Abteilung] = [BR].[Abteilung]
+)
+AND 1 = 1
+ORDER BY F.[Wiedervorlage] ASC, F.[Beleg_Tage_offen] DESC

+ 29 - 0
templates/forderungen/liste/summary.html

@@ -0,0 +1,29 @@
+{% set active = namespace(filters=[]) %}
+{% for f in filter_config %}
+  {% if f.filter_type != 'hidden' and f.current_value and f.current_value != f.default_value %}
+    {% set active.filters = active.filters + [f] %}
+  {% endif %}
+{% endfor %}
+<footer class="gc-list-summary" aria-label="Zusammenfassung der gefilterten Forderungen">
+  <div class="gc-summary-inner">
+    <div><span>Treffer</span> <strong id="list-count">{{ summary.Anzahl }}</strong></div>
+    <details class="gc-active-filters">
+      <summary>Aktive Filter ({{ active.filters|length + (1 if dashboard_segment else 0) }})</summary>
+      <div class="gc-active-filter-panel">
+        {% if dashboard_segment %}<div><strong>Dashboard</strong><span>{{ dashboard_segment_label }}</span></div>
+        <a href="{{ without_dashboard_segment }}">Dashboardfilter entfernen</a>{% endif %}
+        {% for f in active.filters %}
+        {% set display = namespace(value=f.current_value) %}
+        {% for key, value in f.options.items() %}
+          {% if key|string == f.current_value|string %}{% set display.value = value %}{% endif %}
+        {% endfor %}
+        <div><strong>{{ f.text }}</strong><span>{{ display.value }}</span></div>
+        {% else %}
+        {% if not dashboard_segment %}<p>Keine zusätzlichen Filter aktiv.</p>{% endif %}
+        {% endfor %}
+        <a href="#liste-filter" hx-boost="false">Zu den Filtern ↑</a>
+      </div>
+    </details>
+    <div class="gc-summary-total"><span>Offener Gesamtbetrag</span> <strong>{{ summary.Beleg_Offen|number_format }} €</strong></div>
+  </div>
+</footer>

+ 8 - 0
templates/forderungen/verursacher/button.html

@@ -0,0 +1,8 @@
+{% macro edit_button(modal_url, primary_key) %}
+<button type="button" class="btn btn-outline-secondary gc-verursacher-edit"
+  hx-get="{{ modal_url }}" hx-target="#verursacher-modal-content" hx-swap="innerHTML" hx-push-url="false"
+  hx-sync="#verursacher-modal:replace" aria-haspopup="dialog" aria-controls="verursacher-modal"
+  aria-label="Verursacher für Beleg {{ primary_key }} ändern" title="Verursacher ändern">
+  <i class="icon cil-pencil" aria-hidden="true"></i>
+</button>
+{% endmacro %}

+ 8 - 0
templates/forderungen/verursacher/detail_field.html

@@ -0,0 +1,8 @@
+{% from 'forderungen/verursacher/button.html' import edit_button %}
+<div class="col-12 gc-assignee-field" id="workflow-verursacher"{% if oob %} hx-swap-oob="outerHTML"{% endif %}>
+  <span class="gc-assignee-label" id="workflow-verursacher-label">Verursacher</span>
+  <div class="gc-assignee-value" role="group" aria-labelledby="workflow-verursacher-label">
+    <span>{{ effective_name or 'Nicht zugeordnet' }}</span>
+    {{ edit_button(modal_url, primary_key) }}
+  </div>
+</div>

+ 34 - 0
templates/forderungen/verursacher/modal.html

@@ -0,0 +1,34 @@
+<div class="modal-header">
+  <h2 class="modal-title fs-5" id="verursacher-modal-title">Verursacher ändern</h2>
+  <button type="button" class="btn-close" data-coreui-dismiss="modal" aria-label="Schließen"></button>
+</div>
+<form id="verursacher-form" method="post" action="{{ modal_url }}" hx-post="{{ modal_url }}"
+  hx-target="#verursacher-modal-content" hx-swap="innerHTML" hx-push-url="false"
+  hx-sync="this:drop" hx-disabled-elt="find button" data-gc-verursacher-form>
+  <input type="hidden" name="_csrf" value="{{ request.state.principal.csrf }}">
+  <div class="modal-body">
+    <p>Beleg <strong>{{ state.Beleg_Nr }}</strong></p>
+    <p>Aktueller Verursacher: <strong>{{ state.Verursacher_Text or 'Nicht zugeordnet' }}</strong></p>
+    <p class="gc-assignee-original">Ursprünglich: {{ state.Original_Verursacher_Text or 'Nicht zugeordnet' }}</p>
+    {% if error %}<p class="gc-assignee-error" role="alert">{{ error }}</p>{% endif %}
+    <label class="form-label" for="verursacher-role">Rolle</label>
+    <select class="form-select mb-3" id="verursacher-role" name="rolle">
+      <option value="">Alle Rollen</option>
+      {% for role in roles %}<option value="{{ role }}"{% if role == role_filter %} selected{% endif %}>{{ role }}</option>{% endfor %}
+    </select>
+    <label class="form-label" for="verursacher-user">Benutzer</label>
+    <select class="form-select" name="benutzer_id" id="verursacher-user" required>
+      <option value="">Bitte auswählen</option>
+      {% for user in users %}
+      <option value="{{ user.id }}" data-roles="{{ user.roles|tojson|forceescape }}"{% if user.id == selected %} selected{% endif %}>{{ user.name }} ({{ user.id }})</option>
+      {% endfor %}
+    </select>
+    {% if not users %}<p role="status">Keine Benutzer verfügbar.</p>{% endif %}
+    <p class="gc-assignee-status" role="status" aria-live="polite"></p>
+  </div>
+  <div class="modal-footer">
+    <button type="submit" class="btn btn-outline-secondary" name="action" value="reset" formnovalidate>Auf ursprünglichen Verursacher zurücksetzen</button>
+    <button type="button" class="btn btn-link" data-coreui-dismiss="modal">Abbrechen</button>
+    <button type="submit" class="btn btn-primary" name="action" value="assign" data-gc-assign>Speichern</button>
+  </div>
+</form>

+ 24 - 0
templates/forderungen/wiedervorlage/modal.html

@@ -0,0 +1,24 @@
+<div class="modal-header">
+  <h2 class="modal-title fs-5" id="wiedervorlage-modal-title">Wiedervorlage ändern</h2>
+  <button type="button" class="btn-close" data-coreui-dismiss="modal" aria-label="Schließen"></button>
+</div>
+<form id="wiedervorlage-form" method="post" action="{{ modal_url }}" hx-post="{{ modal_url }}"
+  hx-target="#wiedervorlage-modal-content" hx-swap="innerHTML" hx-push-url="false"
+  hx-sync="this:drop" hx-disabled-elt="find button" data-gc-wiedervorlage-form>
+  <input type="hidden" name="_csrf" value="{{ request.state.principal.csrf }}">
+  <div class="modal-body">
+    <p>Beleg <strong>{{ state.Beleg_Nr }}</strong></p>
+    {% if error %}<p class="gc-assignee-error" role="alert">{{ error }}</p>{% endif %}
+    <label class="form-label" for="wiedervorlage-date">Wiedervorlage</label>
+    <input type="date" class="form-control" id="wiedervorlage-date" name="wiedervorlage" value="{{ selected }}" required>
+    <div class="gc-date-suggestions">
+      <button type="button" class="btn btn-outline-secondary" data-gc-date="{{ today }}">Heute</button>
+      <button type="button" class="btn btn-outline-secondary" data-gc-date="{{ next_week }}">Heute + 7 Tage</button>
+    </div>
+    <p class="gc-date-status" role="status" aria-live="polite"></p>
+  </div>
+  <div class="modal-footer">
+    <button type="button" class="btn btn-link" data-coreui-dismiss="modal">Abbrechen</button>
+    <button type="submit" class="btn btn-primary">Speichern</button>
+  </div>
+</form>

+ 24 - 0
tests/__init__.py

@@ -0,0 +1,24 @@
+"""Keep application logging used by all test entrypoints in temporary storage."""
+import atexit
+import logging
+import os
+import sys
+import tempfile
+
+_logs = tempfile.TemporaryDirectory(prefix='gcepic-test-logs-')
+os.environ['LOG_DIR'] = _logs.name
+os.environ['LOG_TO_CONSOLE'] = 'false'
+if 'app.config' in sys.modules:
+    sys.modules['app.config'].settings.LOG_DIR = _logs.name
+    sys.modules['app.config'].settings.LOG_TO_CONSOLE = False
+
+
+def _cleanup_logs():
+    for handler in list(logging.getLogger().handlers):
+        if getattr(handler, '_gc_handler', False):
+            logging.getLogger().removeHandler(handler)
+            handler.close()
+    _logs.cleanup()
+
+
+atexit.register(_cleanup_logs)

+ 193 - 0
tests/test_auth.py

@@ -0,0 +1,193 @@
+import tests  # Initialize temporary logging before importing the application.
+import unittest
+from datetime import timedelta
+from unittest.mock import patch
+
+from fastapi.testclient import TestClient
+
+from app.config import settings
+from app.ldap import DirectoryUser, normalize_username
+from app.main import app
+from app.oauth_token import InvalidSessionToken, create_access_token, decode_access_token, token_needs_renewal, utcnow
+from app.permissions import Entitlement, highest_role
+
+
+def rights(role: str = "Mitarbeiter", priority: int = 100):
+    return (
+        Entitlement("1", "10", None, role, priority),
+        Entitlement("1", "20", "Service", "Mitarbeiter", 100),
+    )
+
+
+class UsernameTests(unittest.TestCase):
+    def test_supported_ad_name_formats_are_normalized(self):
+        self.assertEqual(normalize_username(r"DOMAIN\Max.Mustermann"), "max.mustermann")
+        self.assertEqual(normalize_username("Max.Mustermann@example.local"), "max.mustermann")
+        self.assertEqual(normalize_username("Max.Mustermann"), "max.mustermann")
+
+    def test_invalid_username_is_rejected(self):
+        with self.assertRaises(ValueError):
+            normalize_username("../../admin")
+
+
+class TokenTests(unittest.TestCase):
+    def test_token_contains_required_identity_and_session_claims(self):
+        token = create_access_token(
+            username="max.mustermann",
+            name="Max Mustermann",
+            email="max@example.local",
+            role="Mitarbeiter",
+            auth_source="ldap",
+        )
+        payload = decode_access_token(token)
+        self.assertEqual(payload["sub"], "max.mustermann")
+        self.assertEqual(payload["role"], "Mitarbeiter")
+        self.assertEqual(payload["auth_source"], "ldap")
+        self.assertLessEqual(payload["exp"], payload["session_exp"])
+        self.assertTrue(payload["csrf"])
+
+    def test_role_change_requires_immediate_renewal(self):
+        token = create_access_token(
+            username="max.mustermann",
+            name="Max Mustermann",
+            email="",
+            role="Mitarbeiter",
+            auth_source="iis",
+        )
+        self.assertTrue(token_needs_renewal(decode_access_token(token), "Buchhaltung"))
+
+    def test_active_token_is_not_renewed_too_early(self):
+        now = utcnow()
+        token = create_access_token(
+            username="max.mustermann",
+            name="Max Mustermann",
+            email="",
+            role="Mitarbeiter",
+            auth_source="iis",
+            now=now,
+        )
+        self.assertFalse(token_needs_renewal(decode_access_token(token), "Mitarbeiter", now + timedelta(minutes=1)))
+
+    def test_absolute_session_expiry_is_enforced(self):
+        token = create_access_token(
+            username="max.mustermann",
+            name="Max Mustermann",
+            email="",
+            role="Mitarbeiter",
+            auth_source="iis",
+            now=utcnow() - timedelta(hours=9),
+        )
+        with self.assertRaises(InvalidSessionToken):
+            decode_access_token(token)
+
+
+class PermissionTests(unittest.TestCase):
+    def test_highest_role_uses_configured_priority(self):
+        entitlements = (
+            Entitlement("1", "10", None, "Mitarbeiter", 100),
+            Entitlement("1", "20", None, "Buchhaltung", 400),
+            Entitlement("1", "30", None, "Standortleitung", 300),
+        )
+        self.assertEqual(highest_role(entitlements), "Buchhaltung")
+
+    def test_no_explicit_rights_are_rejected(self):
+        with self.assertRaises(Exception) as context:
+            highest_role(())
+        self.assertEqual(context.exception.status_code, 403)
+
+
+class AuthenticationFlowTests(unittest.TestCase):
+    def setUp(self):
+        debug_config = patch.object(settings, "DEBUG_AUTH", False)
+        debug_config.start()
+        self.addCleanup(debug_config.stop)
+        self.old_proxies = list(settings.TRUSTED_PROXY_IPS)
+        self.old_secure = settings.COOKIE_SECURE
+        settings.TRUSTED_PROXY_IPS = ["testclient"]
+        settings.COOKIE_SECURE = True
+        self.directory_user = DirectoryUser(
+            username="max.mustermann",
+            distinguished_name="CN=Max Mustermann,DC=example,DC=local",
+            name="Max Mustermann",
+            email="max@example.local",
+        )
+
+    def tearDown(self):
+        settings.TRUSTED_PROXY_IPS = self.old_proxies
+        settings.COOKIE_SECURE = self.old_secure
+
+    def test_missing_identity_redirects_to_login(self):
+        with TestClient(app, base_url="https://testserver") as client:
+            response = client.get("/select?from=test", follow_redirects=False)
+        self.assertEqual(response.status_code, 303)
+        self.assertIn("/login?next=", response.headers["location"])
+
+    def test_htmx_request_receives_full_page_redirect_header(self):
+        with TestClient(app, base_url="https://testserver") as client:
+            response = client.get("/select", headers={"HX-Request": "true"}, follow_redirects=False)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("/login?next=", response.headers["HX-Redirect"])
+
+    def test_untrusted_identity_header_is_ignored(self):
+        settings.TRUSTED_PROXY_IPS = ["127.0.0.1"]
+        with TestClient(app, base_url="https://testserver") as client:
+            response = client.get(
+                "/select", headers={"X-Remote-User": r"DOMAIN\Max.Mustermann"}, follow_redirects=False
+            )
+        self.assertEqual(response.status_code, 303)
+
+    @patch("app.auth.load_entitlements", return_value=rights())
+    @patch("app.auth.lookup_directory_user")
+    def test_trusted_iis_identity_creates_secure_session(self, lookup, _load):
+        lookup.return_value = self.directory_user
+        with TestClient(app, base_url="https://testserver") as client:
+            response = client.get("/select", headers={"X-Remote-User": r"DOMAIN\Max.Mustermann"})
+        self.assertEqual(response.status_code, 200)
+        cookie = response.headers.get("set-cookie", "")
+        self.assertIn("gcepic_session=", cookie)
+        self.assertIn("HttpOnly", cookie)
+        self.assertIn("Secure", cookie)
+        self.assertIn("SameSite=lax", cookie)
+
+    @patch("app.auth.load_entitlements", return_value=())
+    @patch("app.auth.lookup_directory_user")
+    def test_iis_user_without_explicit_rights_is_forbidden(self, lookup, _load):
+        lookup.return_value = self.directory_user
+        with TestClient(app, base_url="https://testserver") as client:
+            response = client.get("/select", headers={"X-Remote-User": r"DOMAIN\Max.Mustermann"})
+        self.assertEqual(response.status_code, 403)
+
+    @patch("app.routes.load_entitlements", return_value=rights())
+    @patch("app.routes.ldap_authenticate")
+    def test_ldap_fallback_creates_session(self, authenticate, _load):
+        authenticate.return_value = self.directory_user
+        with TestClient(app, base_url="https://testserver") as client:
+            login_page = client.get("/login")
+            csrf = client.cookies[settings.LOGIN_CSRF_COOKIE_NAME]
+            response = client.post(
+                "/login",
+                data={"username": "max.mustermann", "password": "secret", "_csrf": csrf, "next": "/select"},
+                follow_redirects=False,
+            )
+        self.assertEqual(login_page.status_code, 200)
+        self.assertEqual(response.status_code, 303)
+        self.assertEqual(response.headers["location"], "/select")
+        self.assertIn("gcepic_session=", response.headers.get("set-cookie", ""))
+
+    @patch("app.auth.load_entitlements", return_value=rights())
+    @patch("app.auth.lookup_directory_user")
+    def test_logout_requires_csrf_and_deletes_session(self, lookup, _load):
+        lookup.return_value = self.directory_user
+        with TestClient(app, base_url="https://testserver") as client:
+            login = client.get("/select", headers={"X-Remote-User": r"DOMAIN\Max.Mustermann"})
+            token = login.cookies[settings.SESSION_COOKIE_NAME]
+            csrf = decode_access_token(token)["csrf"]
+            rejected = client.post("/logout")
+            accepted = client.post("/logout", data={"_csrf": csrf})
+        self.assertEqual(rejected.status_code, 403)
+        self.assertEqual(accepted.status_code, 200)
+        self.assertIn("Max-Age=0", accepted.headers.get("set-cookie", ""))
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 366 - 0
tests/test_dashboard.py

@@ -0,0 +1,366 @@
+"""Dashboard and exact drill-down contracts on the shared production SQL projection."""
+
+import json
+import re
+import unittest
+from collections import namedtuple
+from datetime import datetime
+from decimal import Decimal
+from unittest.mock import patch
+from urllib.parse import parse_qs, urlencode, urlsplit
+
+from app.dashboard_segment import pack_segment, parse_segment, segment_sql
+from app.forderung_dashboard import BERLIN, build_dashboard, color
+from app.navigation import list_return_url, normalize_page_url
+from tests import test_verursacher as fixture
+
+
+class DashboardTests(unittest.TestCase):
+    def setUp(self):
+        self.fixture = fixture.VerursacherTests()
+        self.fixture.setUp()
+        self.addCleanup(self.fixture.doCleanups)
+        self.client, self.db = self.fixture.client, self.fixture.db
+        from app.jinja_templates import templates
+
+        sql = templates.env.get_template("forderungen/liste/queries/forderungen_liste.sql").render()
+        needed = set(re.findall(r"(?:\[F\]|F)\.\[([^]]+)\]", sql))
+        existing = {row[1] for row in self.db.connection.execute("PRAGMA dbo.table_info(Forderungen_Kopf)")}
+        for name in needed - existing:
+            kind = (
+                "INTEGER"
+                if name == "Beleg_Tage_offen"
+                else "REAL" if name in {"Beleg_Betrag", "Kunde_offen_gesamt"} else "TEXT"
+            )
+            self.db.connection.execute(f"ALTER TABLE dbo.Forderungen_Kopf ADD [{name}] {kind}")
+        self.db.connection.executescript("""
+            ALTER TABLE dbo.Forderungen_Details ADD Rechtsanwalt TEXT;
+            ALTER TABLE dbo.Forderungen_Details ADD Reklamation TEXT;
+            ALTER TABLE dbo.Forderungen_Details ADD Mahnen_aussetzen TEXT;
+            CREATE TABLE dbo.Forderungen_Kommentar_letzte (Client_DB TEXT, Beleg_Nr TEXT, Kommentar_Fibu TEXT, Kommentar_Abteilung TEXT, Begründung TEXT);
+            CREATE TABLE Garantie2 (Client_DB TEXT, Beleg_Nr TEXT, Antrag_Art TEXT, Antrag_Nr TEXT, Antrag_Datum TEXT, Antrag_Benutzer_ID TEXT, Antrag_Status TEXT, Letzte_Beantragung TEXT);
+            UPDATE dbo.Forderungen_Kopf SET Standort_Name='ULM', Hauptbetrieb_Name='AHR',
+                Staffel_Text='> 12 Wochen', Beleg_Tage_offen=100, Rechnung_Gutschrift='Rechnung',
+                Beleg_Faellig_Datum='2026-11-02', Beleg_Betrag=Beleg_Offen, Kunde_offen_gesamt=100;
+            UPDATE dbo.Forderungen_Kopf SET Hauptbetrieb_ID='2', Hauptbetrieb_Name='AAM' WHERE Client_DB='2';
+            UPDATE dbo.Forderungen_Kopf SET Staffel_Text='< 4 Wochen', Beleg_Tage_offen=10 WHERE Beleg_Nr='R1';
+            INSERT INTO dbo.Forderungen_Details (Client_DB,Beleg_Nr,Verursacher_Benutzer_ID,Wiedervorlage) VALUES
+                ('1','R1','alice','2026-11-01'), ('1','R3',NULL,'2026-11-02 13:30:00'),
+                ('1','X1','bob','2026-11-09 13:30:00'), ('1','NV',NULL,'2026-11-10');
+            UPDATE dbo.Benutzer_Rolle SET Name='Alice' WHERE Benutzer_ID='bob';
+            INSERT INTO Garantie2 (Client_DB,Beleg_Nr,Antrag_Nr) VALUES ('1','R1','A'),('1','R1','B');
+            INSERT INTO dbo.Benutzer_Rechte VALUES ('tester','1','10','Service');
+            INSERT INTO dbo.Benutzer_Rechte VALUES ('tester','1','10','');
+        """)
+        columns = [row[1] for row in self.db.connection.execute("PRAGMA dbo.table_info(Forderungen_Kopf)")]
+        select = ",".join(
+            "'CR'" if name == "Beleg_Nr" else "-40" if name == "Beleg_Offen" else "[" + name + "]" for name in columns
+        )
+        self.db.connection.execute(
+            "INSERT INTO dbo.Forderungen_Kopf SELECT "
+            + select
+            + " FROM dbo.Forderungen_Kopf WHERE Client_DB='1' AND Beleg_Nr='NV'"
+        )
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Rechnung_Gutschrift='Gutschrift', Abteilung='', Staffel_Text=NULL, Verursacher_Benutzer_ID=NULL, Verursacher_Text=NULL, Beleg_Faellig_Datum=NULL WHERE Beleg_Nr='CR'"
+        )
+        self.db.connection.commit()
+        execute = self.db.execute
+
+        def dialect(query, values=None):
+            query = str(query)
+            for column in ["Kommentar_Fibu", "Kommentar_Abteilung"]:
+                query = query.replace(
+                    f"left(isnull([FK].[{column}], ''), 50)", f"substr(ifnull([FK].[{column}], ''), 1, 50)"
+                )
+            query = (
+                query.replace("isnull(", "ifnull(")
+                .replace("dateadd(day, 4, getdate())", "'2026-11-06'")
+                .replace("getdate()", "'2026-11-02'")
+            )
+            if query.strip().startswith("SELECT F.* FROM"):
+                self.db.calls.append((query, values))
+                cursor = self.db.connection.execute(query, values or {})
+                columns = [item[0] for item in cursor.description]
+                record = namedtuple("DashboardInvoice", columns)
+                rows = []
+                for raw in cursor.fetchall():
+                    row = dict(zip(columns, raw))
+                    for name in ["Beleg_Datum", "Beleg_Faellig_Datum", "Wiedervorlage"]:
+                        if row.get(name):
+                            row[name] = datetime.fromisoformat(row[name])
+                    rows.append(record(**row))
+
+                class SQLRows:
+                    def keys(self):
+                        return columns
+
+                    def fetchall(self):
+                        return rows
+
+                return SQLRows()
+            return execute(query, values)
+
+        adapter = patch.object(self.db, "execute", side_effect=dialect)
+        adapter.start()
+        self.addCleanup(adapter.stop)
+        self.now = datetime(2026, 11, 2, 10, tzinfo=BERLIN)
+
+    def data(self):
+        return build_dashboard(self.db, "tester", self.now)
+
+    def test_totals_rights_duplicate_roles_and_duplicate_join_rows(self):
+        data = self.data()
+        self.assertEqual(data["count"], 5)
+        self.assertEqual(data["amount"], "200.00")
+        self.assertEqual(data["amount_display"], "200,00")
+        for groups in data["views"].values():
+            self.assertEqual(sum(group["count"] for group in groups), 5)
+            self.assertEqual(sum(Decimal(group["amount"]) for group in groups), Decimal(200))
+        sql, values = self.db.calls[-1]
+        self.assertIn("WHERE EXISTS", sql)
+        self.assertEqual(values["auth_username"], "tester")
+        self.assertTrue(all("AAM" not in group["label"] for group in data["views"]["Standort"]))
+
+    def test_only_invoices_filters_all_aggregates_and_drilldowns(self):
+        data = build_dashboard(self.db, "tester", self.now, only_invoices=True)
+        self.assertEqual(data["count"], 4)
+        self.assertEqual(data["amount"], "240.00")
+        self.assertEqual(self.data()["count"], 5)
+        for groups in data["views"].values():
+            self.assertEqual(sum(group["count"] for group in groups), 4)
+            for group in groups:
+                for item in [group, *group["segments"]]:
+                    raw = parse_qs(urlsplit(item["url"]).query)["dashboard_segment"][0]
+                    self.assertTrue(parse_segment(raw)["only_invoices"])
+                    response = self.client.get(item["url"])
+                    self.assertIn('id="list-count">' + str(item["count"]), response.text)
+                    self.assertIn("Nur Rechnungen", response.text)
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Rechnung_Gutschrift='Rechnungskorrektur' WHERE Beleg_Nr='CR'"
+        )
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Beleg_Offen=-100 WHERE Client_DB='1' AND Beleg_Nr='R1'"
+        )
+        negative = build_dashboard(self.db, "tester", self.now, only_invoices=True)
+        self.assertEqual(negative["count"], 4)
+        self.assertEqual(negative["amount"], "40.00")
+
+    def test_invoice_checkbox_url_state_and_strict_segment_flag(self):
+        response = self.client.get("/app/forderungen/dashboard?page=Verursacher&metric=anzahl&only_invoices=true")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('name="only_invoices" value="true" checked', response.text)
+        self.assertIn('name="page" value="Verursacher"', response.text)
+        self.assertIn('name="metric" value="anzahl"', response.text)
+        self.assertIn("240,00", response.text)
+        unchecked = self.client.get("/app/forderungen/dashboard")
+        self.assertNotIn('name="only_invoices" value="true" checked', unchecked.text)
+        self.assertIn("200,00", unchecked.text)
+        self.assertIn('data-dashboard-view="Standort" data-dashboard-metric=', unchecked.text)
+        for invalid in ["true", 1, None]:
+            with self.assertRaises(ValueError):
+                parse_segment(pack_segment({"view": "Altersstaffel", "key": None, "only_invoices": invalid}))
+
+    def test_all_segments_round_trip_to_exact_list_count_and_amount(self):
+        for view, groups in self.data()["views"].items():
+            for group in groups:
+                for segment in group["segments"]:
+                    with self.subTest(view=view, label=group["label"], department=segment["department"]):
+                        response = self.client.get(segment["url"])
+                        self.assertEqual(response.status_code, 200)
+                        count = int(re.search(r'id="list-count">(\d+)', response.text)[1])
+                        self.assertEqual(count, segment["count"])
+                        self.assertIn('name="dashboard_segment"', response.text)
+                        self.assertIn("Dashboardfilter entfernen", response.text)
+                        self.assertIn("Aktive Filter (1)", response.text)
+                        from app.jinja_templates import number_format
+
+                        self.assertIn(number_format(Decimal(segment["amount"])) + " €", response.text)
+
+    def test_follow_up_boundaries_and_null_group(self):
+        cases = [
+            ("2026-11-01", "overdue"),
+            ("2026-11-02", "soon"),
+            ("2026-11-05 23:30:00", "soon"),
+            ("2026-11-06", "not_due"),
+            ("2026-11-16 23:30:00", "not_due"),
+            ("2026-11-17", "deferred"),
+        ]
+        for value, expected in cases:
+            with self.subTest(date=value):
+                self.db.connection.execute(
+                    "UPDATE dbo.Forderungen_Details SET Wiedervorlage=? WHERE Beleg_Nr='R1'", (value,)
+                )
+                data = build_dashboard(self.db, "tester", self.now, stack="wiedervorlage")
+                group = next(group for group in data["views"]["Altersstaffel"] if group["label"] == "< 4 Wochen")
+                self.assertEqual(group["segments"][0]["id"], expected)
+                response = self.client.get(group["segments"][0]["url"])
+                self.assertIn('id="list-count">1', response.text)
+        ids = [item["id"] for item in data["stack_items"]]
+        self.assertEqual(ids, ["overdue", "soon", "not_due", "deferred", "undated"])
+        self.assertNotIn("Wiedervorlage", data["views"])
+
+    def test_follow_up_falls_back_to_document_due_date(self):
+        self.db.connection.execute("UPDATE dbo.Forderungen_Details SET Wiedervorlage=NULL WHERE Beleg_Nr='R1'")
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Beleg_Faellig_Datum='2026-11-17' WHERE Client_DB='1' AND Beleg_Nr='R1'"
+        )
+        data = build_dashboard(self.db, "tester", self.now, stack="wiedervorlage")
+        group = next(group for group in data["views"]["Altersstaffel"] if group["label"] == "< 4 Wochen")
+        self.assertEqual(group["segments"][0]["id"], "deferred")
+        self.assertIn('id="list-count">1', self.client.get(group["segments"][0]["url"]).text)
+
+    def test_follow_up_year_boundary_and_berlin_calendar_day(self):
+        self.db.connection.execute("UPDATE dbo.Forderungen_Details SET Wiedervorlage='2027-01-01' WHERE Beleg_Nr='R1'")
+        now = datetime.fromisoformat("2026-12-28T23:30:00+00:00")
+        groups = build_dashboard(self.db, "tester", now, stack="wiedervorlage")["views"]["Altersstaffel"]
+        group = next(group for group in groups if group["label"] == "< 4 Wochen")
+        selection = parse_segment(parse_qs(urlsplit(group["segments"][0]["url"]).query)["dashboard_segment"][0])
+        self.assertEqual(selection["follow_up"], {"from": "2026-12-29", "to": "2027-01-01"})
+        self.assertEqual(group["segments"][0]["id"], "soon")
+
+    def test_follow_up_stack_roundtrips_for_all_rubrics_and_invoice_scope(self):
+        for only in [False, True]:
+            data = build_dashboard(self.db, "tester", self.now, only_invoices=only, stack="wiedervorlage")
+            for groups in data["views"].values():
+                self.assertEqual(sum(group["count"] for group in groups), data["count"])
+                self.assertEqual(sum(Decimal(group["amount"]) for group in groups), Decimal(data["amount"]))
+                for group in groups:
+                    for segment in group["segments"]:
+                        selection = parse_segment(parse_qs(urlsplit(segment["url"]).query)["dashboard_segment"][0])
+                        self.assertIn("follow_up", selection)
+                        self.assertNotIn("department", selection)
+                        response = self.client.get(segment["url"])
+                        self.assertEqual(response.status_code, 200)
+                        self.assertIn('id="list-count">' + str(segment["count"]), response.text)
+
+    def test_stack_selection_and_legacy_follow_up_links(self):
+        response = self.client.get("/app/forderungen/dashboard?stack=wiedervorlage&metric=anzahl&only_invoices=true")
+        self.assertEqual(response.status_code, 200)
+        self.assertNotIn('data-dashboard-view="Wiedervorlage"', response.text)
+        self.assertIn('value="wiedervorlage" selected', response.text)
+        self.assertIn('name="stack" value="wiedervorlage"', response.text)
+        self.assertEqual(self.client.get("/app/forderungen/dashboard?stack=bad").status_code, 422)
+        old = self.client.get(
+            "/app/forderungen/dashboard?page=Wiedervorlage&metric=anzahl&only_invoices=true", follow_redirects=False
+        )
+        self.assertEqual(old.status_code, 303)
+        params = parse_qs(urlsplit(old.headers["location"]).query)
+        self.assertEqual(
+            params, {"page": ["Standort"], "metric": ["anzahl"], "stack": ["wiedervorlage"], "only_invoices": ["true"]}
+        )
+        legacy = pack_segment({"view": "Wiedervorlage", "key": {"from": "2026-11-02", "to": "2026-11-09"}})
+        response = self.client.get("/app/forderungen/liste", params={"dashboard_segment": legacy})
+        self.assertIn('id="list-count">2', response.text)
+        for bad in [True, "tomorrow", {"from": "2026-11-02", "to": "2026-11-01"}]:
+            with self.assertRaises(ValueError):
+                parse_segment(pack_segment({"view": "Altersstaffel", "key": None, "follow_up": bad}))
+
+    def test_same_names_different_user_ids_and_clients_remain_separate(self):
+        groups = [group for group in self.data()["views"]["Verursacher"] if group["label"].startswith("Alice (")]
+        self.assertEqual(len(groups), 2)
+        self.assertNotEqual(groups[0]["label"], groups[1]["label"])
+        self.assertNotEqual(groups[0]["url"], groups[1]["url"])
+        self.db.connection.execute("INSERT INTO dbo.Benutzer_Rechte VALUES ('tester','2','10','Service')")
+        groups = self.data()["views"]["Standort"]
+        self.assertEqual(len(groups), 2)
+        for group in groups:
+            self.assertEqual(self.client.get(group["url"]).status_code, 200)
+        self.assertEqual({group["label"] for group in groups}, {"ULM (AHR)", "ULM (AAM)"})
+
+    def test_decimal_sum_and_zero_amount_segments_still_have_links(self):
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Beleg_Offen=0.1 WHERE Client_DB='1' AND Beleg_Nr='R1'"
+        )
+        self.db.connection.execute(
+            "UPDATE dbo.Forderungen_Kopf SET Beleg_Offen=0.2 WHERE Client_DB='1' AND Beleg_Nr='X1'"
+        )
+        data = self.data()
+        self.assertEqual(data["amount"], "10.30")
+        zero = build_dashboard(self.db, "tester", self.now, stack="wiedervorlage")
+        self.assertTrue(
+            any(
+                segment["amount"] == "0.00" and segment["url"]
+                for group in zero["views"]["Verursacher"]
+                for segment in group["segments"]
+            )
+        )
+        self.assertEqual(color("Service"), color("Service"))
+
+    def test_exact_department_filter_does_not_match_prefixes(self):
+        self.db.connection.execute("UPDATE dbo.Forderungen_Kopf SET Abteilung='Service2' WHERE Beleg_Nr='CR'")
+        self.db.connection.execute("INSERT INTO dbo.Benutzer_Rechte VALUES ('tester','1','10','Service2')")
+        group = self.data()["views"]["Standort"][0]
+        segment = next(segment for segment in group["segments"] if segment["department"] == "Service")
+        exact = self.client.get(segment["url"])
+        partial = self.client.get("/app/forderungen/liste?Abteilung=Service")
+        self.assertIn('id="list-count">4', exact.text)
+        self.assertIn('id="list-count">5', partial.text)
+
+    def test_forged_segment_cannot_expand_invoice_access(self):
+        raw = pack_segment({"view": "Standort", "key": {"client": "2", "site": "10"}})
+        response = self.client.get("/app/forderungen/liste", params={"dashboard_segment": raw})
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('id="list-count">0', response.text)
+        self.assertIn("0,00 €", response.text)
+
+    def test_segment_preserved_through_detail_return_login_and_normal_filters(self):
+        url = self.data()["views"]["Standort"][0]["url"]
+        selection = parse_qs(urlsplit(url).query)["dashboard_segment"][0]
+        returned = list_return_url(url, "1_R1")
+        self.assertEqual(parse_qs(urlsplit(returned).query)["dashboard_segment"], [selection])
+        detail = "/app/forderungen/details/1_R1?" + urlencode({"return_to": returned})
+        recovered = normalize_page_url(
+            "/app/forderungen/details/1_R1/kommentare", current_url="https://proxy.test" + detail
+        )
+        self.assertEqual(recovered, detail)
+        response = self.client.get(url + "&Kunde=Test&page=1&limit=1")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('hx-include="#liste-filter"', response.text)
+        sql, values = self.db.calls[-1]
+        self.assertIn("F.[Client_DB] = :ds_client", sql)
+        self.assertEqual(values["filter_kunde"], "%Test%")
+        self.client.cookies.clear()
+        response = self.client.get(url, headers={"HX-Request": "true"})
+        target = parse_qs(urlsplit(response.headers["HX-Redirect"]).query)["next"][0]
+        self.assertEqual(target, url)
+
+    def test_bad_segments_are_rejected_before_data_query(self):
+        invalid = [
+            "not-json",
+            "{}",
+            '{"view":"Standort","key":{}}',
+            '{"view":"Wiedervorlage","key":{"from":"x","to":null}}',
+            '{"view":"Altersstaffel","key":null,"sql":"1=1"}',
+            '{"view":"Verursacher","key":{"id":null}}',
+            '{"view":"Standort","key":{"client":true,"site":"10"}}',
+        ]
+        for value in invalid:
+            with self.subTest(value=value):
+                self.db.calls.clear()
+                response = self.client.get("/app/forderungen/liste", params={"dashboard_segment": value})
+                self.assertEqual(response.status_code, 400)
+                self.assertFalse(self.db.calls)
+
+    def test_empty_error_and_invalid_dashboard_states(self):
+        response = self.client.get("/app/forderungen/dashboard?page=Standort&metric=anzahl")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("Forderungen | Dashboard", response.text)
+        self.assertIn('data-dashboard-metric="anzahl"', response.text)
+        self.assertEqual(self.client.get("/app/forderungen/dashboard?page=bad").status_code, 422)
+        self.db.connection.execute("DELETE FROM dbo.Benutzer_Rechte WHERE Benutzer_ID='tester'")
+        data = self.data()
+        self.assertEqual(data["count"], 0)
+        self.assertEqual(data["amount"], "0.00")
+        with (
+            patch("app.forderung_dashboard.read_invoices", side_effect=RuntimeError("offline")),
+            self.assertLogs("app.routes", level="ERROR"),
+        ):
+            response = self.client.get("/app/forderungen/dashboard")
+        self.assertEqual(response.status_code, 503)
+        self.assertIn("nicht geladen", response.text)
+        self.assertNotIn("Anzahl der Belege", response.text)
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 158 - 0
tests/test_debug_auth.py

@@ -0,0 +1,158 @@
+import tests  # Initialize temporary logging before importing the application.
+import unittest
+from html.parser import HTMLParser
+from unittest.mock import patch
+
+from fastapi.testclient import TestClient
+
+from app.config import Settings, settings
+from app.main import app
+from app.oauth_token import InvalidSessionToken, create_access_token, decode_access_token
+from app.permissions import Entitlement
+
+
+class LoginFormParser(HTMLParser):
+    def handle_starttag(self, tag, attrs):
+        attributes = dict(attrs)
+        if tag == "input" and attributes.get("name") == "_csrf":
+            self.csrf = attributes["value"]
+
+
+def form_csrf(response):
+    parser = LoginFormParser()
+    parser.feed(response.text)
+    return parser.csrf
+
+
+class DebugLoginTests(unittest.TestCase):
+    def setUp(self):
+        self.config = patch.multiple(settings, ENVIRONMENT="development", DEBUG_AUTH=True, COOKIE_SECURE=False)
+        self.config.start()
+        self.addCleanup(self.config.stop)
+        self.ldap = patch("app.routes.ldap_authenticate")
+        self.ldap_mock = self.ldap.start()
+        self.addCleanup(self.ldap.stop)
+        self.client = TestClient(app, base_url="http://testserver")
+        self.addCleanup(self.client.close)
+        self.entitlements = (
+            Entitlement("1", "10", None, "Buchhaltung", 400),
+            Entitlement("1", "20", "Service", "Mitarbeiter", 100),
+        )
+
+    def login(self, username="winter", password="winter", csrf=True):
+        self.client.get("/login")
+        return self.client.post(
+            "/login",
+            data={
+                "username": username,
+                "password": password,
+                "_csrf": self.client.cookies[settings.LOGIN_CSRF_COOKIE_NAME] if csrf else "incorrect",
+            },
+            follow_redirects=False,
+        )
+
+    @patch("app.routes.load_entitlements")
+    @patch("app.auth.load_entitlements")
+    def test_existing_user_gets_jwt_and_can_access_protected_page(self, request_rights, login_rights):
+        login_rights.return_value = request_rights.return_value = self.entitlements
+        response = self.login("Winter", "Winter")
+        self.assertEqual(response.status_code, 303)
+        payload = decode_access_token(response.cookies[settings.SESSION_COOKIE_NAME])
+        self.assertEqual(payload["sub"], "winter")
+        self.assertEqual(payload["role"], "Buchhaltung")
+        self.assertEqual(payload["auth_source"], "debug")
+        login_rights.assert_called_once()
+        self.assertEqual(login_rights.call_args.args[1], "winter")
+        self.assertEqual(self.client.get("/select").status_code, 200)
+        request_rights.assert_called_once()
+        self.ldap_mock.assert_not_called()
+
+    @patch("app.routes.load_entitlements")
+    def test_different_password_is_rejected_without_ldap_or_rights_lookup(self, login_rights):
+        response = self.login("winter", "Winter")
+        self.assertEqual(response.status_code, 401)
+        self.assertNotIn(settings.SESSION_COOKIE_NAME, response.cookies)
+        login_rights.assert_not_called()
+        self.ldap_mock.assert_not_called()
+
+    @patch("app.routes.load_entitlements", return_value=())
+    def test_user_without_rights_is_rejected(self, login_rights):
+        response = self.login("unknown", "unknown")
+        self.assertEqual(response.status_code, 403)
+        self.assertNotIn(settings.SESSION_COOKIE_NAME, response.cookies)
+        self.ldap_mock.assert_not_called()
+
+    def test_csrf_remains_required(self):
+        self.assertEqual(self.login(csrf=False).status_code, 403)
+
+    @patch("app.routes.load_entitlements")
+    def test_opening_another_login_page_keeps_first_form_valid(self, login_rights):
+        login_rights.return_value = self.entitlements
+        first_page = self.client.get("/login")
+        second_page = self.client.get("/login?next=/select")
+        self.assertEqual(form_csrf(first_page), form_csrf(second_page))
+        self.assertEqual(second_page.headers["cache-control"], "no-store")
+        response = self.client.post(
+            "/login",
+            data={"username": "winter", "password": "winter", "_csrf": form_csrf(first_page)},
+            follow_redirects=False,
+        )
+        self.assertEqual(response.status_code, 303)
+
+    @patch("app.routes.load_entitlements")
+    def test_missing_cookie_returns_fresh_form_and_allows_retry(self, login_rights):
+        login_rights.return_value = self.entitlements
+        page = self.client.get("/login")
+        self.client.cookies.clear()
+        rejected = self.client.post(
+            "/login",
+            data={"username": "winter", "password": "winter", "_csrf": form_csrf(page), "next": "/select"},
+        )
+        self.assertEqual(rejected.status_code, 403)
+        self.assertIn("text/html", rejected.headers["content-type"])
+        self.assertEqual(rejected.headers["cache-control"], "no-store")
+        self.assertNotEqual(form_csrf(rejected), form_csrf(page))
+        login_rights.assert_not_called()
+        self.ldap_mock.assert_not_called()
+        accepted = self.client.post(
+            "/login",
+            data={"username": "winter", "password": "winter", "_csrf": form_csrf(rejected), "next": "/select"},
+            follow_redirects=False,
+        )
+        self.assertEqual(accepted.status_code, 303)
+        self.assertEqual(accepted.headers["location"], "/select")
+
+    @patch("app.routes.load_entitlements")
+    def test_missing_form_token_is_rejected_before_authentication(self, login_rights):
+        self.client.get("/login")
+        response = self.client.post("/login", data={"username": "winter", "password": "winter"})
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(form_csrf(response), self.client.cookies[settings.LOGIN_CSRF_COOKIE_NAME])
+        login_rights.assert_not_called()
+        self.ldap_mock.assert_not_called()
+
+    @patch("app.auth.lookup_directory_user")
+    def test_proxy_header_does_not_bypass_debug_form(self, lookup):
+        with patch.object(settings, "TRUSTED_PROXY_IPS", ["testclient"]):
+            response = self.client.get("/login", headers={"X-Remote-User": r"DOMAIN\winter"})
+        self.assertEqual(response.status_code, 200)
+        lookup.assert_not_called()
+
+    def test_debug_token_is_rejected_after_disabling_debug_mode(self):
+        token = create_access_token(
+            username="winter", name="winter", email="", role="Mitarbeiter", auth_source="debug"
+        )
+        with patch.object(settings, "DEBUG_AUTH", False):
+            with self.assertRaises(InvalidSessionToken):
+                decode_access_token(token)
+
+    def test_production_configuration_rejects_debug_auth(self):
+        with self.assertRaises(ValueError):
+            Settings(_env_file=None, ENVIRONMENT="production", DEBUG_AUTH=True)
+
+    def test_debug_auth_is_disabled_by_default(self):
+        self.assertFalse(Settings(_env_file=None, DEBUG_AUTH=False).debug_auth_enabled)
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 346 - 0
tests/test_forderung_history.py

@@ -0,0 +1,346 @@
+"""Exercise production SQL predicates on SQLite, adapting only SQL Server TOP syntax.
+
+This does not replace verification against the deployed SQL Server schema.
+"""
+
+import re
+import sqlite3
+import unittest
+from datetime import date, datetime
+from html.parser import HTMLParser
+from unittest.mock import patch
+from urllib.parse import parse_qs, urlsplit
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.auth import AuthenticationMiddleware
+from app.config import settings
+from app.db import get_session
+from app.forderung_history import history_context
+from app.oauth_token import create_access_token
+from app.permissions import Entitlement
+from app.routes import router
+
+
+class Record(dict):
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+
+class Result:
+    def __init__(self, cursor):
+        self.rows = []
+        if cursor.description:
+            for values in cursor.fetchall():
+                row = Record(zip((c[0] for c in cursor.description), values))
+                if row.get("Timestamp"):
+                    row["Timestamp"] = datetime.fromisoformat(row["Timestamp"])
+                if row.get("Beleg_Datum"):
+                    row["Beleg_Datum"] = date.fromisoformat(row["Beleg_Datum"])
+                self.rows.append(row)
+
+    def fetchall(self):
+        return self.rows
+
+    def first(self):
+        return next(iter(self.rows), None)
+
+    def mappings(self):
+        return self
+
+
+class FixtureDB:
+    def __init__(self):
+        self.connection = sqlite3.connect(":memory:", check_same_thread=False)
+        self.connection.execute("ATTACH DATABASE ':memory:' AS dbo")
+        self.calls = []
+        self.commits = 0
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def execute(self, query, values=None):
+        sql = str(query)
+        self.calls.append((sql, dict(values or {})))
+        top = re.search(r"SELECT TOP (\d+)", sql, re.I)
+        if top:
+            sql = re.sub(r"SELECT TOP \d+", "SELECT", sql, count=1, flags=re.I).rstrip() + " LIMIT " + top[1]
+        return Result(self.connection.execute(sql, values or {}))
+
+    def commit(self):
+        self.commits += 1
+        self.connection.commit()
+
+
+def seed(db):
+    db.connection.executescript("""
+        CREATE TABLE dbo.Forderungen_Kopf (
+            Client_DB TEXT, Beleg_Nr TEXT, Kunde_Nr TEXT, Fahrzeug_Nr TEXT, Beleg_Offen REAL,
+            Hauptbetrieb_ID TEXT, Standort_ID TEXT, Abteilung TEXT, Kunde_Text TEXT, Beleg_Datum TEXT
+        );
+        CREATE TABLE dbo.Forderungen_Historie (Client_DB TEXT, Beleg_Nr TEXT, Kunde_Nr TEXT, Fahrzeug_Nr TEXT);
+        CREATE TABLE dbo.Forderungen_Buchungen (
+            Client_DB TEXT, Kunde_Nr TEXT, Fahrzeug_Nr TEXT, Beleg_Nr TEXT, Bezug_Beleg_Nr TEXT,
+            Beleg_Datum TEXT, Beleg_Beschreibung TEXT, Betrag REAL, Benutzer_ID TEXT, Bezahlt TEXT, Beleg_Art TEXT
+        );
+        CREATE TABLE dbo.Forderungen_Kommentar (
+            Client_DB TEXT, Beleg_Nr TEXT, Timestamp TEXT, Benutzer_ID TEXT, Kommentar TEXT
+        );
+        CREATE VIEW dbo.Forderungen_Kommentar_Benutzer AS
+            SELECT *, 'Test User' AS Name, 'MA' AS Rolle_ID, 'Mitarbeiter' AS Rolle_Name
+            FROM Forderungen_Kommentar;
+        CREATE TABLE dbo.Benutzer_Rechte (
+            Benutzer_ID TEXT, Hauptbetrieb_ID TEXT, Standort_ID TEXT, Abteilung TEXT
+        );
+        INSERT INTO dbo.Benutzer_Rechte VALUES ('tester', '1', '10', 'Service');
+    """)
+    for tenant, number, customer, vehicle, balance, branch in [
+        ("1", "R1", "D1", "V1", 100, "10"),
+        ("1", "R2", "D1", "V2", 20, "20"),
+        ("1", "R3", "D1", "V1", 0, "10"),
+        ("1", "X1", "D2", "V1", 90, "10"),
+        ("2", "R1", "D1", "V1", 100, "10"),
+        ("1", "NV", "D3", None, 50, "10"),
+    ]:
+        db.connection.execute(
+            "INSERT INTO dbo.Forderungen_Kopf VALUES (?, ?, ?, ?, ?, '1', ?, 'Service', 'Test debtor', '2026-01-01')",
+            (tenant, number, customer, vehicle, balance, branch),
+        )
+    for number, vehicle in [("H1", "V1"), ("H2", "V2"), ("R3", "V1")]:
+        db.connection.execute("INSERT INTO dbo.Forderungen_Historie VALUES ('1', ?, 'D1', ?)", (number, vehicle))
+    for tenant, customer, vehicle, number, reference in [
+        ("1", "D1", "V1", "R1", "R1"),
+        ("1", "D1", None, "P1", "R1"),
+        ("1", "D1", "V2", "R2", None),
+        ("1", "D1", "V1", "R3", None),
+        ("1", "D1", "V1", "H1", None),
+        ("1", "D1", "V2", "H2", None),
+        ("1", "D1", "V1", "LOOSE", None),
+        ("1", "D2", "V1", "X1", "R1"),
+        ("2", "D1", "V1", "R1", "R1"),
+    ]:
+        db.connection.execute(
+            "INSERT INTO dbo.Forderungen_Buchungen VALUES (?, ?, ?, ?, ?, '2026-01-02', ?, 10, 'tester', 'N', 'RE')",
+            (tenant, customer, vehicle, number, reference, "Booking " + number),
+        )
+    for tenant, number in [("1", "R1"), ("1", "R2"), ("1", "R3"), ("1", "H1"), ("1", "H2"), ("1", "X1"), ("2", "R1")]:
+        db.connection.execute(
+            "INSERT INTO dbo.Forderungen_Kommentar VALUES (?, ?, '2026-01-02T12:00:00', 'tester', ?)",
+            (tenant, number, f"Comment {tenant}/{number}"),
+        )
+    db.connection.commit()
+
+
+class Tags(HTMLParser):
+    def __init__(self, html):
+        super().__init__()
+        self.tags = []
+        self.feed(html)
+
+    def handle_starttag(self, tag, attrs):
+        self.tags.append((tag, dict(attrs)))
+
+
+class HistoryTests(unittest.TestCase):
+    def setUp(self):
+        self.db = FixtureDB()
+        seed(self.db)
+        self.addCleanup(self.db.connection.close)
+        self.application = FastAPI()
+        self.application.include_router(router)
+        self.application.dependency_overrides[get_session] = lambda: self.db
+        self.application.add_middleware(AuthenticationMiddleware)
+        self.entitlements = (Entitlement("1", "10", "Service", "Mitarbeiter", 100),)
+        for target, kwargs in [
+            ("app.auth.SessionLocal", {"return_value": self.db}),
+            ("app.auth.load_entitlements", {"return_value": self.entitlements}),
+        ]:
+            mocked = patch(target, **kwargs)
+            mocked.start()
+            self.addCleanup(mocked.stop)
+        config = patch.multiple(settings, COOKIE_SECURE=False, TRUSTED_PROXY_IPS=[])
+        config.start()
+        self.addCleanup(config.stop)
+        self.client = TestClient(self.application)
+        self.addCleanup(self.client.close)
+        self.token = create_access_token(
+            username="tester", name="Tester", email="", role="Mitarbeiter", auth_source="ldap", csrf="csrf"
+        )
+        self.client.cookies.set(settings.SESSION_COOKIE_NAME, self.token)
+        self.pkey = {"Client_DB": "1", "Beleg_Nr": "R1"}
+
+    def test_all_scopes_apply_to_real_sql_without_duplicate_bookings(self):
+        expected_comments = {
+            "invoice": {"R1"},
+            "open": {"R1", "R2"},
+            "vehicle": {"R1", "R3", "H1"},
+            "debtor": {"R1", "R2", "R3", "H1", "H2"},
+        }
+        expected_bookings = {
+            "invoice": {"R1", "P1"},
+            "open": {"R1", "P1", "R2"},
+            "vehicle": {"R1", "P1", "R3", "H1", "LOOSE"},
+            "debtor": {"R1", "P1", "R2", "R3", "H1", "H2", "LOOSE"},
+        }
+        for section, expectations in [("kommentare", expected_comments), ("buchungen", expected_bookings)]:
+            for scope, expected in expectations.items():
+                with self.subTest(section=section, scope=scope):
+                    rows = history_context(self.db, self.pkey, section, scope)["forderungen_" + section]
+                    self.assertEqual({r.Beleg_Nr for r in rows}, expected)
+                    self.assertEqual(len(rows), len(expected))
+                    if section == "kommentare":
+                        self.assertTrue(all(r.Kommentar.startswith("Comment 1/") for r in rows))
+                    else:
+                        self.assertTrue(all(r.Client_DB == "1" and r.Kunde_Nr == "D1" for r in rows))
+
+    def test_routes_render_isolated_fragments_and_default_to_invoice(self):
+        for section, target in [("kommentare", "comments-history"), ("buchungen", "bookings-history")]:
+            for scope in ["invoice", "open", "vehicle", "debtor"]:
+                with self.subTest(section=section, scope=scope):
+                    response = self.client.get(f"/app/forderungen/details/1_R1/{section}?scope={scope}")
+                    self.assertEqual(response.status_code, 200)
+                    tags = Tags(response.text).tags
+                    self.assertIn(("div", next(a for t, a in tags if a.get("id") == target)), tags)
+                    buttons = [a for t, a in tags if t == "button"]
+                    self.assertEqual(len(buttons), 4)
+                    self.assertEqual(sum(b["aria-pressed"] == "true" for b in buttons), 1)
+                    self.assertTrue(all(b["hx-target"] == "#" + target for b in buttons))
+                    selected = next(b for b in buttons if b["aria-pressed"] == "true")
+                    self.assertTrue(selected["hx-get"].endswith("scope=" + scope))
+                    self.assertNotIn("<html", response.text)
+                    self.assertNotIn('id="formular"', response.text)
+                    self.assertNotIn('name="Kommentar"', response.text)
+            response = self.client.get(f"/app/forderungen/details/1_R1/{section}")
+            self.assertIn('aria-pressed="true"', response.text)
+            self.assertNotIn("Booking R2" if section == "buchungen" else "Comment 1/R2", response.text)
+
+    def test_expansion_permits_other_branch_but_direct_access_remains_denied(self):
+        expanded = self.client.get("/app/forderungen/details/1_R1/kommentare?scope=debtor")
+        self.assertIn("Comment 1/R2", expanded.text)
+        for section in ["kommentare", "buchungen"]:
+            self.db.calls.clear()
+            response = self.client.get(f"/app/forderungen/details/1_R2/{section}?scope=debtor")
+            self.assertEqual(response.status_code, 404)
+            self.assertEqual(len(self.db.calls), 1)
+
+    def test_invalid_scope_does_not_query_history(self):
+        for section in ["kommentare", "buchungen"]:
+            self.db.calls.clear()
+            response = self.client.get(f"/app/forderungen/details/1_R1/{section}?scope=invalid")
+            self.assertEqual(response.status_code, 422)
+            self.assertFalse(self.db.calls)
+
+    def test_missing_vehicle_and_empty_results_leave_filters_available(self):
+        for section in ["kommentare", "buchungen"]:
+            for scope in ["invoice", "vehicle"]:
+                response = self.client.get(f"/app/forderungen/details/1_NV/{section}?scope={scope}")
+                self.assertEqual(response.status_code, 200)
+                buttons = [a for t, a in Tags(response.text).tags if t == "button"]
+                vehicle = next(b for b in buttons if b["hx-get"].endswith("scope=vehicle"))
+                self.assertIn("disabled", vehicle)
+                self.assertIn("Keine Kommentare" if section == "kommentare" else "Keine Buchungsbelege", response.text)
+                if scope == "vehicle":
+                    self.assertIn("kein Fahrzeug hinterlegt", response.text)
+
+    def test_comment_post_preserves_scope_and_immutable_invoice_identity(self):
+        for scope in ["invoice", "open", "vehicle", "debtor"]:
+            response = self.client.post(
+                "/app/forderungen/details/1_R1",
+                data={
+                    "source": "comments",
+                    "_csrf": "csrf",
+                    "comment_scope": scope,
+                    "Kommentar": "New comment " + scope,
+                    "Client_DB": "2",
+                    "Beleg_Nr": "X1",
+                    "Benutzer_ID": "intruder",
+                },
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertIn("New comment " + scope, response.text)
+            self.assertIn(f'name="comment_scope" value="{scope}"', response.text)
+            self.assertNotIn('id="bookings-history"', response.text)
+            self.assertNotIn('id="comment-form"', response.text)
+        rows = self.db.connection.execute(
+            "SELECT Client_DB, Beleg_Nr, Benutzer_ID FROM dbo.Forderungen_Kommentar WHERE Kommentar LIKE 'New comment%'"
+        ).fetchall()
+        self.assertEqual(rows, [("1", "R1", "tester")] * 4)
+        self.assertEqual(self.db.commits, 4)
+
+    def test_post_rejects_invalid_csrf_scope_and_unauthorized_invoice(self):
+        for suffix, extra, expected in [
+            ("1_R1", {"_csrf": "wrong"}, 403),
+            ("1_R1", {"comment_scope": "invalid"}, 422),
+            ("1_R2", {}, 404),
+        ]:
+            data = {"source": "comments", "_csrf": "csrf", "Kommentar": "Rejected"}
+            data.update(extra)
+            response = self.client.post("/app/forderungen/details/" + suffix, data=data)
+            self.assertEqual(response.status_code, expected)
+        self.assertEqual(self.db.commits, 0)
+
+    def test_booking_limit_is_enforced_and_disclosed(self):
+        self.db.connection.executemany(
+            "INSERT INTO dbo.Forderungen_Buchungen VALUES ('1', 'D1', 'V1', ?, 'R1', '2026-02-01', 'Bulk', 1, 'tester', 'N', 'RE')",
+            [(f"B{i:04}",) for i in range(1001)],
+        )
+        rows = history_context(self.db, self.pkey, "buchungen")["forderungen_buchungen"]
+        self.assertEqual(len(rows), 1000)
+        self.assertEqual(rows[0].Beleg_Nr, "P1")
+        response = self.client.get("/app/forderungen/details/1_R1/buchungen")
+        self.assertIn("ersten 1.000 Buchungsbelege", response.text)
+
+    def test_comment_order_and_escaping(self):
+        self.db.connection.execute(
+            "INSERT INTO dbo.Forderungen_Kommentar VALUES ('1', 'R1', '2025-01-01T12:00:00', 'tester', '<script>old</script>')"
+        )
+        response = self.client.get("/app/forderungen/details/1_R1/kommentare?scope=debtor")
+        self.assertIn("&lt;script&gt;old&lt;/script&gt;", response.text)
+        self.assertLess(response.text.index("&lt;script&gt;old"), response.text.index("Comment 1/R1"))
+        self.assertIn("Rechnung H1", response.text)
+
+    def test_full_detail_page_keeps_filters_and_comment_form_when_lists_are_empty(self):
+        context = history_context(self.db, self.pkey, "kommentare")
+        context.update(history_context(self.db, self.pkey, "buchungen"))
+        invoice = dict(context["forderungen_details"][0])
+        invoice.update(
+            Kunde_offen_gesamt=120,
+            Mwst_Betrag=0,
+            Mwst_Betrag_berechnet=19,
+            Fahrzeug_Erstzulassung=None,
+            Fahrzeug_Kaufdatum=None,
+            Wiedervorlage=date(2026, 11, 1),
+        )
+        context.update(
+            forderungen_details=[invoice],
+            forderungen_kommentare=[],
+            forderungen_buchungen=[],
+            files=[],
+            auftraege_positionen=[],
+            versicherungen=[],
+            summary=False,
+        )
+        with patch("app.routes.get_template_context", return_value=context):
+            response = self.client.get("/app/forderungen/details/1_R1")
+        self.assertEqual(response.status_code, 200)
+        tags = Tags(response.text).tags
+        selected = [a for t, a in tags if t == "button" and a.get("aria-pressed") == "true"]
+        self.assertEqual(len(selected), 2)
+        self.assertTrue(all(a["hx-get"].endswith("scope=invoice") for a in selected))
+        form = next(a for t, a in tags if a.get("id") == "comment-form")
+        self.assertEqual(urlsplit(form["hx-post"]).path, "/app/forderungen/details/1_R1")
+        self.assertEqual(parse_qs(urlsplit(form["hx-post"]).query)["return_to"], ["/app/forderungen/liste?focus=1_R1"])
+        self.assertEqual(form["hx-target"], "#comments-history")
+        self.assertIn("Keine Kommentare", response.text)
+        self.assertIn("Keine Buchungsbelege", response.text)
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 217 - 0
tests/test_forderung_list.py

@@ -0,0 +1,217 @@
+"""List response contracts with an isolated query result (no SQL Server needed)."""
+
+import unittest
+from collections import namedtuple
+from datetime import date
+from html.parser import HTMLParser
+from types import SimpleNamespace
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.db import get_session
+from app.routes import router
+
+
+def invoice(number=0, **changes):
+    data = dict(
+        Client_DB="1",
+        Hauptbetrieb_Name="AHR",
+        Standort_ID="10",
+        Standort_Name="ULM",
+        Abteilung="SC",
+        Verursacher_Text="dki",
+        Rechnung_Gutschrift="Rechnung",
+        Fahrzeug_Nr="V1",
+        Kunde_Text="Musterkunde",
+        Beleg_Nr=f"R{number}",
+        Beleg_Datum=date(2026, 10, 1),
+        Beleg_Faellig_Datum=date(2026, 10, 15),
+        Staffel_Text="> 12 Wochen",
+        Mahnstufe="1",
+        Bearbeitet="N",
+        Abwarten="",
+        Wiedervorlage=date(2026, 11, 1),
+        Wiedervorlage_Stufe="0",
+        Beleg_Betrag=20,
+        Beleg_Offen=10,
+        Kunde_offen_gesamt=50,
+        Kunde_gesamt_Bezug="",
+        Besitzer_Kunde_Text="",
+        Kunde_Email="kunde@example.com",
+        Beleg_Tage_offen=28,
+        Kommentar_Fibu="Fibu Kommentar",
+        Kommentar_Abteilung="Abteilung Kommentar",
+        Antrag_Nr="",
+        Antrag_Art="",
+        Antrag_Datum=None,
+        Antrag_Benutzer_ID="",
+        Antrag_Status="",
+    )
+    data.update(changes)
+    return namedtuple("Invoice", data)(**data)
+
+
+class QueryResult:
+    def __init__(self, rows):
+        self.rows = rows
+
+    def keys(self):
+        return invoice()._fields
+
+    def fetchall(self):
+        return self.rows
+
+
+class ListDB:
+    def __init__(self):
+        self.rows = []
+        self.calls = []
+
+    def execute(self, query, values):
+        self.calls.append((str(query), values))
+        return QueryResult(self.rows)
+
+
+class Tags(HTMLParser):
+    def __init__(self, html):
+        super().__init__()
+        self.tags = []
+        self.feed(html)
+
+    def handle_starttag(self, tag, attrs):
+        self.tags.append((tag, dict(attrs)))
+
+
+class ForderungListTests(unittest.TestCase):
+    def setUp(self):
+        self.db = ListDB()
+        self.application = FastAPI()
+        self.application.include_router(router)
+        self.application.dependency_overrides[get_session] = lambda: self.db
+
+        @self.application.middleware("http")
+        async def fixture_principal(request, call_next):
+            request.state.principal = SimpleNamespace(username="tester", name="Tester", role="Buchhaltung", csrf="csrf")
+            return await call_next(request)
+
+        self.client = TestClient(self.application)
+        self.addCleanup(self.client.close)
+
+    def test_empty_first_page_retains_all_filters_and_zero_summary(self):
+        response = self.client.get("/app/forderungen/liste")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("Keine Forderungen", response.text)
+        self.assertIn("0,00 €", response.text)
+        tags = Tags(response.text).tags
+        fields = [a for t, a in tags if t in ("input", "select") and a.get("id")]
+        self.assertEqual(len(fields), 16)
+        self.assertIn('id="list-count">0', response.text)
+
+    def test_empty_results_preserve_selected_filter_and_query_parameters(self):
+        response = self.client.get("/app/forderungen/liste?Filiale=10&Kunde=Nichtgefunden")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('<option value="10" selected>10</option>', response.text)
+        self.assertIn('value="Nichtgefunden"', response.text)
+        sql, params = self.db.calls[-1]
+        self.assertEqual(params["auth_username"], "tester")
+        self.assertEqual(params["filter_filiale"], "%10%")
+        self.assertEqual(params["filter_kunde"], "%Nichtgefunden%")
+        self.assertIn("F.[Standort_ID] LIKE :filter_filiale", sql)
+
+    def test_summary_uses_all_matches_and_paging_preserves_filter_form(self):
+        self.db.rows = [invoice(n) for n in range(103)]
+        response = self.client.get("/app/forderungen/liste?Filiale=10")
+        self.assertIn('id="list-count">103', response.text)
+        self.assertIn("1.030,00 €", response.text)
+        tags = Tags(response.text).tags
+        rows = [a for t, a in tags if t == "tr" and a.get("class") == "gc-invoice-row"]
+        self.assertEqual(len(rows), 100)
+        loader = next(a for t, a in tags if a.get("class") == "gc-list-load")
+        self.assertEqual(loader["hx-include"], "#liste-filter")
+        self.assertIn('"page": 1', loader["hx-vals"])
+
+    def test_last_page_is_a_fragment_and_exhausted_page_is_empty_html(self):
+        self.db.rows = [invoice(n) for n in range(103)]
+        response = self.client.get("/app/forderungen/liste?page=1&Filiale=10")
+        self.assertEqual(response.status_code, 200)
+        self.assertNotIn("<html", response.text)
+        self.assertNotIn("gc-list-load", response.text)
+        self.assertEqual(response.text.count('class="gc-invoice-row"'), 3)
+        self.assertIn("R100", response.text)
+        exhausted = self.client.get("/app/forderungen/liste?page=2&Filiale=10")
+        self.assertEqual(exhausted.status_code, 200)
+        self.assertEqual(exhausted.text, "")
+        self.assertTrue(exhausted.headers["content-type"].startswith("text/html"))
+
+    def test_comments_are_escaped_and_unique_across_tenants(self):
+        self.db.rows = [invoice(1, Kommentar_Fibu="<script>unsafe</script>"), invoice(1, Client_DB="2")]
+        response = self.client.get("/app/forderungen/liste")
+        self.assertIn("&lt;script&gt;unsafe&lt;/script&gt;", response.text)
+        tags = Tags(response.text).tags
+        controls = [a["aria-controls"] for t, a in tags if "data-gc-comments" in a]
+        self.assertEqual(len(set(controls)), 2)
+        for target in controls:
+            self.assertTrue(any(t == "tr" and a.get("id") == target and "hidden" in a for t, a in tags))
+
+    def test_application_information_precedes_department_comment(self):
+        self.db.rows = [
+            invoice(
+                1,
+                Antrag_Nr="A42",
+                Antrag_Art="Antrag",
+                Antrag_Datum=date(2026, 10, 1),
+                Antrag_Benutzer_ID="dki",
+                Antrag_Status="Offen",
+            ),
+            invoice(2, Kommentar_Fibu="", Kommentar_Abteilung=""),
+        ]
+        response = self.client.get("/app/forderungen/liste")
+        self.assertIn("Antrag A42", response.text)
+        self.assertNotIn("Abteilung Kommentar", response.text)
+        self.assertEqual(response.text.count("data-gc-comments"), 1)
+
+    def test_return_focus_loads_through_target_and_continues_at_next_block(self):
+        self.db.rows = [invoice(n) for n in range(305)]
+        response = self.client.get("/app/forderungen/liste?Filiale=10&focus=1_R220")
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text.count('class="gc-invoice-row"'), 300)
+        self.assertIn('data-primary-key="1_R220"', response.text)
+        self.assertIn('"page": 3', response.text)
+        self.assertIn('id="list-count">305', response.text)
+        self.assertEqual(response.headers["cache-control"], "no-store")
+        sql, parameters = self.db.calls[-1]
+        self.assertNotIn("focus", parameters)
+        self.assertNotIn("focus", sql.lower())
+
+    def test_focus_is_found_at_new_position_and_within_exact_tenant(self):
+        self.db.rows = [invoice(220, Client_DB="2")] + [invoice(n) for n in range(150)] + [invoice(220)]
+        response = self.client.get("/app/forderungen/liste?Filiale=10&focus=1_R220")
+        self.assertEqual(response.text.count('class="gc-invoice-row"'), 152)
+        self.assertNotIn("gc-return-status", response.text)
+        self.assertIn('data-focus="1_R220"', response.text)
+
+    def test_missing_focus_preserves_filters_and_explains_missing_row(self):
+        response = self.client.get("/app/forderungen/liste?Filiale=10&focus=1_R404")
+        self.assertIn("nicht mehr enthalten", response.text)
+        self.assertIn('<option value="10" selected>10</option>', response.text)
+        self.assertIn("Keine Forderungen", response.text)
+
+    def test_detail_links_keep_filters_including_on_loaded_fragments(self):
+        from urllib.parse import parse_qs, urlsplit
+
+        self.db.rows = [invoice(n) for n in range(103)]
+        for url, key in [
+            ("/app/forderungen/liste?Filiale=10&Kunde=Muster", "1_R0"),
+            ("/app/forderungen/liste?page=1&Filiale=10&Kunde=Muster", "1_R100"),
+        ]:
+            response = self.client.get(url)
+            link = next(a for t, a in Tags(response.text).tags if "data-gc-detail-link" in a)
+            return_to = parse_qs(urlsplit(link["href"]).query)["return_to"][0]
+            self.assertEqual(
+                parse_qs(urlsplit(return_to).query), {"Filiale": ["10"], "Kunde": ["Muster"], "focus": [key]}
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 129 - 0
tests/test_forderung_notice.py

@@ -0,0 +1,129 @@
+import unittest
+from datetime import date
+from decimal import Decimal
+from unittest.mock import MagicMock, patch
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.testclient import TestClient
+
+from app.db import get_session
+from app.permissions import Principal
+from app.routes import router
+
+
+class ForderungNoticeTests(unittest.TestCase):
+    def setUp(self):
+        self.db = MagicMock()
+        self.application = FastAPI()
+        self.application.include_router(router)
+        self.application.dependency_overrides[get_session] = lambda: self.db
+
+        @self.application.middleware("http")
+        async def authenticated(request: Request, call_next):
+            request.state.principal = Principal("tester", "Tester", "", "Mitarbeiter", "ldap", "csrf", ())
+            return await call_next(request)
+
+        self.client = TestClient(self.application)
+        self.addCleanup(self.client.close)
+        self.detail_context_patch = patch("app.routes.get_template_context")
+        self.detail_context = self.detail_context_patch.start()
+        self.addCleanup(self.detail_context_patch.stop)
+        self.current = {
+            "Beleg_Nr": "WGG24501320",
+            "Beleg_Datum": date(2024, 5, 13),
+            "Kunde_Text": "Beispielkunde <script>alert(1)</script>",
+            "Beleg_Betrag": Decimal("1234.50"),
+            "Beleg_Offen": Decimal("250.00"),
+        }
+
+    def result(self, row=None, access=False):
+        result = MagicMock()
+        result.first.return_value = (1,) if access else None
+        result.mappings.return_value.first.return_value = row
+        return result
+
+    def get_notice(self, htmx=False):
+        return self.client.get("/app/forderungen/details/1_WGG24501320", headers={"HX-Request": "true"} if htmx else {})
+
+    def assert_notice(self, response):
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('href="/app/forderungen/liste?focus=1_WGG24501320">Zurück zur Liste', response.text)
+        self.assertNotIn('id="formular"', response.text)
+        self.assertNotIn('name="Kommentar"', response.text)
+        self.detail_context.assert_not_called()
+
+    def test_open_forderung_displays_only_summary_and_skips_history(self):
+        self.db.execute.side_effect = [self.result(), self.result(self.current)]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertIn("Forderung WGG24501320 vom 13.05.2024 ist noch offen.", response.text)
+        self.assertIn("1.234,50 €", response.text)
+        self.assertIn("250,00 €", response.text)
+        self.assertIn("&lt;script&gt;", response.text)
+        self.assertNotIn("<script>alert(1)</script>", response.text)
+        self.assertEqual(self.db.execute.call_count, 2)
+
+    def test_history_displays_dates_and_queries_exact_tenant_key(self):
+        history = {"Beleg_Nr": "WGG24501320", "Beleg_Datum": date(2024, 5, 13), "Auszifferung_Datum": date(2024, 6, 2)}
+        self.db.execute.side_effect = [self.result(), self.result(), self.result(history)]
+        response = self.get_notice(htmx=True)
+        self.assert_notice(response)
+        self.assertIn("wurde am 02.06.2024 beglichen.", response.text)
+        query, params = self.db.execute.call_args.args
+        self.assertIn("dbo.Forderungen_Historie", str(query))
+        self.assertIn("ORDER BY Auszifferung_Datum DESC", str(query))
+        self.assertEqual(params, {"client_db": "1", "beleg_nr": "WGG24501320"})
+        self.assertNotIn("WGG24501320", str(query))
+
+    def test_missing_entry_displays_short_message(self):
+        self.db.execute.side_effect = [self.result(), self.result(), self.result()]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertIn("Eintrag nicht gefunden.", response.text)
+
+    def test_null_fields_and_zero_amount_render_correctly(self):
+        row = dict(self.current, Beleg_Datum=None, Kunde_Text=None, Beleg_Betrag=None, Beleg_Offen=Decimal("0"))
+        self.db.execute.side_effect = [self.result(), self.result(row)]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertEqual(response.text.count("nicht hinterlegt"), 3)
+        self.assertIn("0,00 €", response.text)
+
+    def test_authorized_user_retains_existing_detail_flow(self):
+        self.db.execute.return_value = self.result(access=True)
+        self.detail_context.return_value = {"existing": "context"}
+        with patch("app.routes.templates.TemplateResponse", return_value=HTMLResponse("Full details")) as render:
+            response = self.get_notice()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, "Full details")
+        self.detail_context.assert_called_once()
+        self.assertEqual(render.call_args.args[1], "forderungen/details/details.html")
+        self.db.execute.assert_called_once()
+
+    def test_database_failure_is_not_reported_as_missing(self):
+        self.db.execute.side_effect = [self.result(), RuntimeError("Database unavailable")]
+        with TestClient(self.application, raise_server_exceptions=False) as client:
+            response = client.get("/app/forderungen/details/1_WGG24501320")
+        self.assertEqual(response.status_code, 500)
+        self.assertNotIn("Eintrag nicht gefunden", response.text)
+
+    def test_write_file_and_export_routes_remain_denied(self):
+        self.db.execute.return_value = self.result()
+        cases = [
+            ("post", "/app/forderungen/details/1_WGG24501320", {"data": {"source": "comments", "Kommentar": "test"}}),
+            ("get", "/app/forderungen/files/1_WGG24501320", {}),
+            ("get", "/files/?name=1/WGG24501320/invoice.pdf", {}),
+            ("get", "/app/forderungen/export/1_WGG24501320/", {}),
+        ]
+        for method, url, kwargs in cases:
+            with self.subTest(url=url):
+                self.db.execute.reset_mock()
+                response = getattr(self.client, method)(url, **kwargs)
+                self.assertEqual(response.status_code, 404)
+                self.db.execute.assert_called_once()
+        self.db.commit.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

+ 482 - 0
tests/test_logging.py

@@ -0,0 +1,482 @@
+"""Logging is tested against isolated engines, ASGI apps and temporary files only."""
+import tests
+import ast
+import asyncio
+from datetime import datetime, timedelta, timezone
+import io
+import json
+import logging
+import multiprocessing
+import pyodbc
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import httpx
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.testclient import TestClient
+from sqlalchemy import Column, Integer, create_engine, text
+from sqlalchemy.exc import DBAPIError
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.pool import StaticPool
+
+from app.auth import AuthenticationMiddleware
+from app.config import settings, Settings
+from app.db import LoggingSession, install_engine_logging
+from app.http_logging import install_request_logging
+from app.logging_setup import (ApplicationFileHandler, configure_logging, request_context,
+                               run_cli, sanitize_sql)
+from app.oauth_token import create_access_token
+from app.permissions import Entitlement
+import app.logging_setup as setup
+
+SECRET = 'DO_NOT_LOG_SECRET_93'
+
+
+def config(directory, **kwargs):
+    values = dict(LOG_DIR=str(directory), LOG_LEVEL='INFO', LOG_TO_FILE=True, LOG_TO_CONSOLE=True,
+                  LOG_RETENTION_DAYS=30, LOG_SQL_STATEMENT=True)
+    values.update(kwargs)
+    return SimpleNamespace(**values)
+
+
+def process_writer(directory, worker):
+    configure_logging(config(directory, LOG_TO_CONSOLE=False))
+    for index in range(35):
+        logging.getLogger('app.worker').info('Worker event', extra={'event':'worker', 'count':worker*1000+index})
+    for handler in list(logging.getLogger().handlers):
+        if getattr(handler, '_gc_handler', False): handler.close()
+
+
+class LoggingTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory(prefix='gcepic-logging-')
+        self.root = Path(self.temp.name)
+        root = logging.getLogger()
+        self.old_handlers, self.old_level = root.handlers[:], root.level
+        root.handlers.clear()
+        self.old_config = setup._configuration
+        self.logger_states = {name:(logger.level, logger.disabled, logger.propagate, logger.handlers[:])
+                              for name,logger in root.manager.loggerDict.items() if isinstance(logger, logging.Logger)}
+        self.console = io.StringIO()
+        self.configuration = config(self.root)
+        configure_logging(self.configuration, console_stream=self.console)
+        self.patch = patch.object(settings, 'LOG_SQL_STATEMENT', True)
+        self.patch.start()
+
+    def tearDown(self):
+        self.patch.stop()
+        root = logging.getLogger()
+        for handler in list(root.handlers):
+            root.removeHandler(handler)
+            if getattr(handler, '_gc_handler', False): handler.close()
+        root.handlers[:] = self.old_handlers; root.setLevel(self.old_level)
+        for name, state in self.logger_states.items():
+            logger = logging.getLogger(name)
+            logger.setLevel(state[0]); logger.disabled=state[1]; logger.propagate=state[2]; logger.handlers[:]=state[3]
+        setup._configuration = self.old_config
+        self.temp.cleanup()
+
+    def records(self):
+        file = self.root/'application.log'
+        return [json.loads(line) for line in file.read_text(encoding='utf-8').splitlines()] if file.exists() else []
+
+    def engine(self, **kwargs):
+        engine = create_engine('sqlite://', poolclass=StaticPool, connect_args={'check_same_thread':False}, hide_parameters=True, **kwargs)
+        install_engine_logging(engine)
+        self.addCleanup(engine.dispose)
+        return engine
+
+    def test_literals_comments_and_identifiers_are_sanitized(self):
+        sql = "SELECT [col1], :bind2, N'O''Brien', 123, -1.23e+4, 0xAFF, .5, \"private\" /* private /* nested */ end */ -- private\nFROM [table2]"
+        safe = sanitize_sql(sql)
+        self.assertNotIn('private', safe); self.assertNotIn('Brien', safe)
+        for value in ['123','1.23','0xAFF','.5']: self.assertNotIn(value, safe)
+        for name in ['[col1]', ':bind2', '[table2]']: self.assertIn(name, safe)
+
+    def test_idempotent_initialization_and_configured_outputs(self):
+        root = logging.getLogger()
+        count = len(root.handlers)
+        configure_logging(self.configuration, console_stream=self.console)
+        self.assertEqual(len(root.handlers), count)
+        logging.getLogger('app.test').info('Started', extra={'event':'started'})
+        self.assertEqual(len(self.records()), 1)
+        self.assertEqual(self.console.getvalue().count('Started'), 1)
+        self.assertRegex(self.records()[0]['timestamp'], r'\.\d{3}[+-]\d{2}:\d{2}$')
+        self.assertEqual(Settings(_env_file=None, LOG_LEVEL='debug').LOG_LEVEL, 'DEBUG')
+
+    def test_sql_error_logged_once_even_when_caught_and_logged_again(self):
+        engine = self.engine()
+        with LoggingSession(engine) as db:
+            for value in ['first-secret', 'second-secret']:
+                try:
+                    db.execute(text("SELECT :value FROM missing_table WHERE 91827=1 AND 'private-value'='private-value'").execution_options(query_name='test.missing'), {'value':value})
+                except Exception:
+                    logging.getLogger('app.service').exception('Operation failed')
+        records = self.records()
+        self.assertEqual(len(records), 2)
+        self.assertTrue(all(row['event']=='database_error' for row in records))
+        self.assertEqual(records[0]['query_fingerprint'], records[1]['query_fingerprint'])
+        self.assertEqual(records[0]['query_name'], 'test.missing')
+        self.assertIn('missing_table', records[0]['sql'])
+        self.assertTrue(records[0]['exceptions'][0]['frames'])
+        combined=json.dumps(records)+self.console.getvalue()
+        for value in ['first-secret','second-secret','private-value','91827','[parameters:']:
+            self.assertNotIn(value, combined)
+
+    def test_connect_and_fetch_errors_are_logged_without_driver_messages(self):
+        def unavailable(): raise sqlite3.OperationalError(SECRET)
+        engine = self.engine(creator=unavailable)
+        with LoggingSession(engine) as db, self.assertRaises(Exception):
+            db.execute(text('SELECT 1').execution_options(query_name='connect.test'))
+        self.assertEqual(len(self.records()), 1)
+        self.assertEqual(self.records()[0]['query_name'], 'connect.test')
+        class Cursor(sqlite3.Cursor):
+            def execute(self, sql, params=()):
+                self.bad_fetch = 'fetch_marker' in sql
+                return super().execute(sql, params)
+            def fetchall(self):
+                if getattr(self,'bad_fetch',False): raise sqlite3.OperationalError(SECRET)
+                return super().fetchall()
+        class Connection(sqlite3.Connection):
+            def cursor(self,*args,**kwargs): return super().cursor(factory=Cursor)
+        engine = self.engine(creator=lambda: sqlite3.connect(':memory:',factory=Connection))
+        with LoggingSession(engine) as db, self.assertRaises(Exception):
+            db.execute(text('SELECT 1 AS fetch_marker')).fetchall()
+        self.assertEqual(len(self.records()), 2)
+        self.assertEqual(self.records()[-1]['operation'], 'fetch')
+        self.assertNotIn(SECRET, json.dumps(self.records())+self.console.getvalue())
+
+    def test_sql_server_diagnostics_include_codes_and_redacted_descriptions(self):
+        driver=pyodbc.ProgrammingError('42S22', "[42S22] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Invalid column name 'PrivateColumn'. (207) (SQLExecDirectW); [42000] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Statement(s) could not be prepared. (8180)")
+        error=DBAPIError("SELECT :value, 'inline-private' FROM sample", {'value':SECRET}, driver)
+        setup.log_query_error(error,error.statement,'test.sql_server')
+        logging.getLogger('app.service').error('Handled',exc_info=(type(error),error,None))
+        rows=self.records()
+        self.assertEqual(len(rows),1)
+        self.assertEqual(rows[0]['db_code'],207)
+        self.assertEqual(rows[0]['sqlstate'],'42S22')
+        self.assertIn('Invalid column name',rows[0]['db_message'])
+        self.assertIn("'PrivateColumn'",rows[0]['db_message'])
+        self.assertIn("'PrivateColumn'",self.console.getvalue())
+        self.assertEqual([item['code'] for item in rows[0]['db_diagnostics']],[207,8180])
+        self.assertEqual(rows[0]['db_diagnostics'][1]['sqlstate'],'42000')
+        self.assertIn('could not be prepared',self.console.getvalue())
+        for secret in [SECRET,'inline-private','[parameters:']:
+            self.assertNotIn(secret,json.dumps(rows)+self.console.getvalue())
+
+    def test_invalid_column_names_are_visible_only_in_canonical_error_207(self):
+        with patch.object(settings,'LOG_SQL_STATEMENT',False):
+            for description in ["Ungültiger Spaltenname 'Kunde_Größe_2'.", "Invalid column name 'Customer''s (2026)'.", 'Ungültiger Spaltenname "Kunde_Gesamt_Offen".', 'Ungültiger Spaltenname „Kunde_Gesamt_Offen“.']:
+                driver=pyodbc.ProgrammingError('42S22','[Microsoft][ODBC Driver 18 for SQL Server][SQL Server]'+description+' (207) (SQLExecDirectW)')
+                setup.log_query_error(driver,parameters={'value':SECRET})
+                row=self.records()[-1]
+                self.assertEqual(row['db_message'],description)
+                self.assertEqual(row['db_diagnostics'][0]['message'],description)
+                self.assertNotIn('sql',row)
+        for code in [207,245]:
+            description=f"Invalid column name 'PrivateColumn'. Extra value '{SECRET}'. ({code}) (SQLExecDirectW)"
+            setup.log_query_error(pyodbc.ProgrammingError('42S22',description))
+            self.assertNotIn('PrivateColumn',self.records()[-1]['db_message'])
+        self.assertNotIn(SECRET,json.dumps(self.records())+self.console.getvalue())
+
+    def test_german_binding_errors_keep_each_invalid_column_name(self):
+        raw=('\r\n[42S22] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Ungültiger Spaltenname "Spalte_A". (207) (SQLExecDirectW);\r\n'
+             '[42S22] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Ungültiger Spaltenname "Spalte_B". (207); '
+             '[42S22] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Die Sicht oder Funktion "dbo.PrivateView" konnte aufgrund von Bindungsfehlern nicht verwendet werden. (4413); '
+             '[42S22] [Microsoft][ODBC Driver 18 for SQL Server][SQL Server]Anweisung(en) konnte(n) nicht vorbereitet werden. (8180)')
+        setup.log_query_error(pyodbc.ProgrammingError('42S22',raw),parameters={'token':SECRET})
+        row=self.records()[-1]
+        self.assertIn('"Spalte_A"',row['db_message'])
+        self.assertIn('"Spalte_B"',row['db_diagnostics'][1]['message'])
+        self.assertEqual([item['code'] for item in row['db_diagnostics']],[207,207,4413,8180])
+        self.assertIn('Spalte_A',self.console.getvalue())
+        self.assertIn('Spalte_B',self.console.getvalue())
+        self.assertNotIn('PrivateView',json.dumps(row)+self.console.getvalue())
+        self.assertNotIn(SECRET,json.dumps(row)+self.console.getvalue())
+
+    def test_sql_server_diagnostics_redact_echoed_values_and_work_without_sql_logging(self):
+        descriptions=[
+            ('23000',f"Violation of UNIQUE KEY constraint 'key'. The duplicate key value is ({SECRET}, 12345). (2627) (SQLExecDirectW)",2627),
+            ('22018',f"Conversion failed when converting the nvarchar value '{SECRET}' to data type int. (245) (SQLExecDirectW)",245),
+            ('42000',f"Custom validation failed: {SECRET}; inline-private; password=credential-private (50001) (SQLExecDirectW)",50001),
+            ('HYT00',"Login timeout expired (0) (SQLDriverConnect)",0),
+        ]
+        with patch.object(settings,'LOG_SQL_STATEMENT',False):
+            for state,description,code in descriptions:
+                driver=pyodbc.Error(state,'[Microsoft][ODBC Driver 18 for SQL Server][SQL Server]'+description)
+                error=DBAPIError("SELECT 'inline-private'",{'value':SECRET},driver)
+                setup.log_query_error(error,error.statement,'test.redaction')
+                self.assertEqual(self.records()[-1]['db_code'],code)
+                self.assertNotIn('sql',self.records()[-1])
+        combined=json.dumps(self.records())+self.console.getvalue()
+        for secret in [SECRET,'12345','inline-private','credential-private']:
+            self.assertNotIn(secret,combined)
+        self.assertIn('UNIQUE KEY',combined)
+        self.assertIn('Conversion failed',combined)
+        self.assertIn('Login timeout expired',combined)
+
+    def test_commit_rollback_and_flush_errors_are_captured(self):
+        class Connection(sqlite3.Connection):
+            fail_commit=False; fail_rollback=False
+            def commit(self):
+                if self.fail_commit:
+                    self.fail_commit=False; raise sqlite3.OperationalError(SECRET)
+                return super().commit()
+            def rollback(self):
+                if self.fail_rollback:
+                    self.fail_rollback=False; raise sqlite3.OperationalError(SECRET)
+                return super().rollback()
+        engine=self.engine(creator=lambda:sqlite3.connect(':memory:',factory=Connection))
+        with LoggingSession(engine) as db:
+            db.execute(text('CREATE TABLE sample (id INTEGER PRIMARY KEY)')); db.commit()
+            db.execute(text('INSERT INTO sample VALUES (1)'))
+            db.connection().connection.driver_connection.fail_commit=True
+            with self.assertRaises(Exception): db.commit()
+            db.rollback()
+            db.execute(text('SELECT 1'))
+            db.connection().connection.driver_connection.fail_rollback=True
+            with self.assertRaises(Exception): db.rollback()
+        Base=declarative_base()
+        class Model(Base):
+            __tablename__='unique_sample'
+            id=Column(Integer, primary_key=True)
+        Base.metadata.create_all(engine)
+        with LoggingSession(engine) as db:
+            db.add_all([Model(id=1),Model(id=1)])
+            with self.assertRaises(Exception): db.flush()
+            db.rollback()
+        operations=[row['operation'] for row in self.records() if row.get('event')=='database_error']
+        self.assertIn('commit',operations); self.assertIn('rollback',operations); self.assertIn('flush',operations)
+        self.assertEqual(len(operations),3)
+        self.assertNotIn(SECRET, json.dumps(self.records())+self.console.getvalue())
+
+    def app(self):
+        app=FastAPI()
+        @app.get('/status/{code}')
+        async def response(code:int): return HTMLResponse(SECRET,status_code=code)
+        @app.get('/http-error')
+        async def http_error(): raise HTTPException(400, SECRET)
+        @app.get('/number')
+        async def number(value:int): return value
+        @app.get('/ok')
+        async def ok(request:Request):
+            request.state.principal=SimpleNamespace(username=request.headers.get('x-test-user','tester'))
+            logging.getLogger('app.service').info('Service event')
+            from starlette.concurrency import run_in_threadpool
+            await run_in_threadpool(lambda:logging.getLogger('app.service').info('Thread event'))
+            await asyncio.sleep(.01)
+            return {'ok':True}
+        @app.get('/health')
+        async def health(): return {'ok':True}
+        failure=RuntimeError(SECRET)
+        @app.get('/crash')
+        async def crash(): raise failure
+        @app.get('/stream')
+        async def stream():
+            async def chunks():
+                yield b'first'
+                raise RuntimeError(SECRET)
+            return StreamingResponse(chunks())
+        app.mount('/static',StaticFiles(directory=self.root),name='static')
+        install_request_logging(app)
+        return app, failure
+
+    def test_http_codes_validation_static_and_exception_deduplication(self):
+        app,failure=self.app()
+        with TestClient(app,raise_server_exceptions=False) as client:
+            for code in [400,401,403,404,405,422,500,503]:
+                response=client.get('/status/'+str(code)+'?token='+SECRET,headers={'Authorization':SECRET,'Cookie':'token='+SECRET})
+                self.assertEqual(response.status_code,code)
+                row=self.records()[-1]
+                self.assertEqual(row['level'],'ERROR' if code>=500 else 'WARNING')
+                self.assertEqual(row['request_id'],response.headers['X-Request-ID'])
+                self.assertNotIn('?',row['path'])
+            self.assertEqual(client.get('/number?value='+SECRET).status_code,422)
+            self.assertEqual(client.post('/ok',json={'password':SECRET}).status_code,405)
+            self.assertEqual(client.get('/static/missing.txt').status_code,404)
+            self.assertEqual(client.get('/http-error').status_code,400)
+            crash=client.get('/crash')
+            self.assertEqual(crash.status_code,500)
+            self.assertTrue(crash.headers['X-Request-ID'])
+            repeated=client.get('/crash')
+            self.assertNotEqual(crash.headers['X-Request-ID'],repeated.headers['X-Request-ID'])
+        logging.getLogger('uvicorn.error').error('Exception in ASGI application',exc_info=(RuntimeError,failure,failure.__traceback__))
+        technical=[row for row in self.records() if row.get('event')=='unhandled_exception']
+        self.assertEqual(len(technical),2)
+        self.assertNotIn(SECRET,json.dumps(self.records())+self.console.getvalue())
+
+    def test_caught_query_error_in_http_200_keeps_request_context(self):
+        app=FastAPI()
+        engine=self.engine()
+        @app.get('/caught-query')
+        def caught(request:Request):
+            request.state.principal=SimpleNamespace(username='tester')
+            with LoggingSession(engine) as db:
+                try:
+                    db.execute(text('SELECT :secret FROM missing_http_table').execution_options(query_name='http.caught'), {'secret':SECRET})
+                except Exception:
+                    logging.getLogger('app.service').exception('Query handled')
+            return HTMLResponse('Formularfehler',status_code=200)
+        install_request_logging(app)
+        with TestClient(app) as client:
+            response=client.get('/caught-query')
+        rows=self.records()
+        self.assertEqual([row['event'] for row in rows], ['database_error','http_completed'])
+        self.assertTrue(all(row['request_id']==response.headers['x-request-id'] for row in rows))
+        self.assertTrue(all(row['user']=='tester' for row in rows))
+        self.assertEqual(rows[-1]['status'],200)
+        self.assertNotIn(SECRET,json.dumps(rows)+self.console.getvalue())
+
+    def test_stream_error_keeps_sent_status_and_health_success_is_debug(self):
+        app,_=self.app()
+        with TestClient(app,raise_server_exceptions=False) as client:
+            client.get('/health'); self.assertEqual(self.records(),[])
+            response=client.get('/stream')
+        self.assertEqual(response.status_code,200)
+        summary=next(row for row in self.records() if row.get('event')=='http_completed')
+        self.assertEqual(summary['status'],200); self.assertEqual(summary['outcome'],'stream_failed')
+        self.assertEqual(summary['level'],'ERROR')
+        self.assertNotIn(SECRET,json.dumps(self.records()))
+
+    def test_parallel_request_and_thread_contexts_are_isolated(self):
+        app,_=self.app()
+        async def requests():
+            async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app),base_url='http://test') as client:
+                return await asyncio.gather(*[client.get('/ok?secret='+SECRET,headers={'x-test-user':user,'X-Request-ID':SECRET}) for user in ['alpha','beta']])
+        responses=asyncio.run(requests())
+        ids={response.headers['x-request-id'] for response in responses}
+        self.assertEqual(len(ids),2); self.assertNotIn(SECRET,ids)
+        users={row['request_id']:row['user'] for row in self.records() if row.get('event')=='http_completed'}
+        self.assertEqual(set(users.values()),{'alpha','beta'})
+        for row in self.records(): self.assertEqual(row['user'],users[row['request_id']])
+        self.assertIsNone(request_context.get())
+
+    def test_early_auth_errors_and_htmx_login_are_observed(self):
+        app=FastAPI()
+        @app.post('/write')
+        def write(): return {'ok':True}
+        app.add_middleware(AuthenticationMiddleware)
+        install_request_logging(app)
+        entitlement=(Entitlement('1','10','SC','Mitarbeiter',100),)
+        with patch.multiple(settings,TRUSTED_PROXY_IPS=['testclient'],DEBUG_AUTH=False,COOKIE_SECURE=False), \
+             patch('app.auth.SessionLocal',return_value=MagicMock()), \
+             patch('app.auth.load_entitlements',return_value=entitlement), \
+             patch('app.auth.lookup_directory_user',return_value=None), TestClient(app) as client:
+            denied=client.post('/write',headers={'X-Remote-User':'invalid'})
+            self.assertEqual(denied.status_code,401)
+            login=client.post('/write',headers={'HX-Request':'true'})
+            self.assertEqual(login.status_code,200); self.assertIn('HX-Redirect',login.headers)
+            token=create_access_token(username='tester',name='Tester',email='',role='Mitarbeiter',auth_source='ldap',csrf='csrf')
+            client.cookies.set(settings.SESSION_COOKIE_NAME,token)
+            self.assertEqual(client.post('/write').status_code,403)
+        statuses=[row['status'] for row in self.records() if row.get('event')=='http_completed']
+        self.assertEqual(statuses,[401,200,403])
+        self.assertTrue(any(row.get('event')=='auth_login_required' for row in self.records()))
+
+    def test_retention_rotation_parallel_processes_and_fallback(self):
+        old=self.root/'application.log.2001-01-01'; old.write_text('expired',encoding='utf-8')
+        preserved=self.root/'webservice.log'; preserved.write_text('keep',encoding='utf-8')
+        handler=next(handler for handler in logging.getLogger().handlers if isinstance(handler,ApplicationFileHandler))
+        handler.cleanup_archives(); self.assertFalse(old.exists()); self.assertTrue(preserved.exists())
+        logging.getLogger('app.test').info('before rotation')
+        handler.clh._do_lock()
+        try: handler.doRollover()
+        finally: handler.clh._do_unlock()
+        logging.getLogger('app.test').info('after rotation')
+        self.assertEqual(self.records()[-1]['message'],'after rotation')
+        with patch.object(handler.clh,'do_write',side_effect=PermissionError(SECRET)), patch('sys.stderr',new=io.StringIO()) as fallback:
+            logging.getLogger('app.test').error('safe failure')
+        self.assertIn('Konsolenfallback',fallback.getvalue()); self.assertNotIn(SECRET,fallback.getvalue())
+        directory=self.root/'workers'; directory.mkdir()
+        seed=ApplicationFileHandler(str(directory/'application.log'))
+        seed.setFormatter(setup.JsonFormatter()); seed.addFilter(setup.ContextFilter())
+        seed.handle(logging.LogRecord('app.worker',logging.INFO,__file__,0,'Before shared rotation',(),None))
+        seed.clh._do_lock()
+        try:
+            seed.rolloverAt=int(datetime.now(timezone.utc).timestamp())-10
+            seed.write_rollover_time()
+        finally:
+            seed.clh._do_unlock()
+            seed.close()
+        processes=[multiprocessing.get_context('spawn').Process(target=process_writer,args=(str(directory),n)) for n in range(3)]
+        for process in processes: process.start()
+        for process in processes:
+            process.join(20)
+            if process.is_alive(): process.terminate(); self.fail('Logging worker timed out')
+            self.assertEqual(process.exitcode,0)
+        rows=[json.loads(line) for line in (directory/'application.log').read_text(encoding='utf-8').splitlines()]
+        self.assertEqual(len(rows),105); self.assertEqual(len({row['count'] for row in rows}),105)
+        archived=[json.loads(line) for archive in directory.glob('application.log.*') for line in archive.read_text(encoding='utf-8').splitlines()]
+        self.assertEqual([row['message'] for row in archived],['Before shared rotation'])
+
+    def test_cli_failure_and_disabled_sql_text(self):
+        with patch('app.logging_setup.configure_logging'), self.assertRaises(SystemExit):
+            run_cli(lambda: (_ for _ in ()).throw(RuntimeError(SECRET)))
+        self.assertEqual(self.records()[-1]['event'],'cli_failed')
+        with patch.object(settings,'LOG_SQL_STATEMENT',False), LoggingSession(self.engine()) as db:
+            with self.assertRaises(Exception): db.execute(text('SELECT * FROM missing'))
+        self.assertNotIn('sql',self.records()[-1]); self.assertNotIn(SECRET,self.console.getvalue())
+
+    def test_project_python_has_no_print_calls(self):
+        root=Path(__file__).resolve().parent.parent
+        paths=list((root/'app').rglob('*.py'))+list(root.glob('*.py'))+list((root/'tests').glob('*.py'))
+        for path in paths:
+            tree=ast.parse(path.read_text(encoding='utf-8-sig'))
+            for node in ast.walk(tree):
+                self.assertFalse(isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id=='print',str(path))
+
+    def test_file_configuration_failure_falls_back_without_exposing_exception(self):
+        output=io.StringIO()
+        with patch('app.logging_setup.ApplicationFileHandler',side_effect=PermissionError(SECRET)):
+            configure_logging(config(self.root/'denied',LOG_TO_CONSOLE=False),console_stream=output)
+        logging.getLogger('app.service').error('Still available')
+        self.assertIn('Konsolenfallback',output.getvalue())
+        self.assertIn('Still available',output.getvalue())
+        self.assertNotIn(SECRET,output.getvalue())
+
+    def test_cleanup_queries_are_parameterized_and_cli_imports_work(self):
+        import app.cleanup_comments as cleanup
+        import filter_export
+        rows=[SimpleNamespace(Client_DB='1',Beleg_Nr='R1',Timestamp=datetime(2026,1,1),
+                              Benutzer_ID='tester',Kommentar='AZ: 123/45 Schaden '+SECRET+' bei '+SECRET+' eingereicht')]
+        db=MagicMock()
+        db.execute.return_value.fetchall.return_value=rows
+        with patch('app.cleanup_comments.SessionLocal',return_value=db):
+            db.__enter__.return_value=db
+            cleanup.main()
+            cleanup.get_details_from_comments()
+        writes=[call for call in db.execute.call_args_list if 'INSERT' in str(call.args[0]) or 'UPDATE' in str(call.args[0])]
+        self.assertEqual(len(writes),2)
+        for call in writes:
+            self.assertNotIn(SECRET,str(call.args[0]))
+            self.assertIn(SECRET,str(call.args[1]))
+        filter_export.import_filter_config2()
+        self.assertNotIn(SECRET,self.console.getvalue())
+
+    def test_mail_and_docuware_metadata_never_dump_payloads(self):
+        import app.imap as imap
+        import app.docuware_search as docuware_search
+        payload=SECRET.encode()
+        message=SimpleNamespace(subject='WRG123456 '+SECRET,
+                                attachments=[SimpleNamespace(filename=SECRET+'.pdf',payload=payload,size=len(payload))])
+        db=MagicMock(); db.__enter__.return_value=db
+        db.execute.return_value.fetchall.return_value=[('1','WRG123456')]
+        mailbox=MagicMock(); mailbox.login.return_value.__enter__.return_value=mailbox
+        mailbox.fetch.return_value=[message]
+        with patch.dict('os.environ',{'LOCAL_STORAGE':str(self.root/'files')}), \
+             patch('app.imap.SessionLocal',return_value=db),patch('app.imap.MailBox',return_value=mailbox):
+            imap.main()
+        connection=SimpleNamespace(organizations=[SimpleNamespace(file_cabinets=[SECRET],baskets=[SECRET])])
+        with patch('app.docuware_search.docuware.connect',return_value=connection):
+            docuware_search.main()
+        self.assertTrue(any(row.get('event')=='mail_attachment_saved' and row['size_bytes']==len(payload) for row in self.records()))
+        self.assertNotIn(SECRET,json.dumps(self.records())+self.console.getvalue())
+
+
+if __name__=='__main__': unittest.main()

+ 263 - 0
tests/test_navigation.py

@@ -0,0 +1,263 @@
+import unittest
+from datetime import date
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+from urllib.parse import parse_qs, urlencode, urlsplit
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+import tests  # Initialize temporary logging before importing the application.
+from app.config import settings
+from app.db import get_session
+from app.ldap import DirectoryUser
+from app.main import app
+from app.navigation import LIST_PATH, list_return_url, normalize_page_url
+from app.permissions import Entitlement
+from app.routes import router
+
+
+class NavigationUrlTests(unittest.TestCase):
+    def test_return_url_preserves_filters_and_replaces_transport_and_focus(self):
+        value = LIST_PATH + "?Filiale=10&Kunde=A%26B&page=3&limit=100&scope=debtor&focus=2_OTHER"
+        result = list_return_url(value, "1_R1")
+        self.assertEqual(parse_qs(urlsplit(result).query), {"Filiale": ["10"], "Kunde": ["A&B"], "focus": ["1_R1"]})
+
+    def test_invalid_return_destinations_fall_back_to_filtered_page_type(self):
+        for value in [
+            "https://evil.test/",
+            "//evil.test",
+            "/\\evil",
+            "/%2f%2fevil",
+            "/select",
+            "/app/forderungen/liste\n",
+        ]:
+            with self.subTest(value=value):
+                self.assertEqual(list_return_url(value, "1_R1"), LIST_PATH + "?focus=1_R1")
+
+    def test_fragment_recovery_uses_only_matching_invoice_context(self):
+        return_to = LIST_PATH + "?Filiale=10&focus=1_R1"
+        current = "https://external-proxy.test/app/forderungen/details/1_R1?" + urlencode({"return_to": return_to})
+        for fragment in ["kommentare", "buchungen"]:
+            result = normalize_page_url(
+                "/app/forderungen/details/1_R1/" + fragment + "?scope=debtor", current_url=current
+            )
+            self.assertEqual(result, "/app/forderungen/details/1_R1?" + urlencode({"return_to": return_to}))
+        self.assertEqual(
+            normalize_page_url("/app/forderungen/details/2_R1/kommentare", current_url=current),
+            "/app/forderungen/details/2_R1",
+        )
+
+    def test_external_current_url_never_becomes_redirect_origin(self):
+        result = normalize_page_url(
+            "/app/forderungen/details/1_R1/buchungen",
+            current_url="https://evil.test/app/forderungen/details/1_R1?return_to=https://evil.test",
+        )
+        self.assertTrue(result.startswith("/app/forderungen/details/1_R1?"))
+        self.assertNotIn("evil", result)
+
+
+class LoginRecoveryTests(unittest.TestCase):
+    def setUp(self):
+        config = patch.multiple(settings, DEBUG_AUTH=False, TRUSTED_PROXY_IPS=[], COOKIE_SECURE=False)
+        config.start()
+        self.addCleanup(config.stop)
+        session = patch("app.auth.SessionLocal", return_value=MagicMock())
+        session.start()
+        self.addCleanup(session.stop)
+        self.client = TestClient(app)
+        self.addCleanup(self.client.close)
+
+    def login_target(self, response):
+        self.assertEqual(response.status_code, 200)
+        login = response.headers["HX-Redirect"]
+        self.assertTrue(login.startswith("/login?next="))
+        return parse_qs(urlsplit(login).query)["next"][0]
+
+    def test_expired_list_paging_resumes_full_filtered_page(self):
+        response = self.client.get(
+            LIST_PATH + "?page=3&limit=100&Filiale=10",
+            headers={
+                "HX-Request": "true",
+                "HX-Current-URL": "http://testserver" + LIST_PATH + "?Filiale=10&focus=1_R120",
+            },
+            follow_redirects=False,
+        )
+        self.assertEqual(self.login_target(response), LIST_PATH + "?Filiale=10&focus=1_R120")
+
+    def test_fragment_and_save_expiry_resume_detail_without_replaying_post(self):
+        return_to = LIST_PATH + "?Filiale=10&Kunde=Muster&focus=1_R1"
+        current = "http://testserver/app/forderungen/details/1_R1?" + urlencode({"return_to": return_to})
+        headers = {"HX-Request": "true", "HX-Current-URL": current}
+        for suffix in ["/kommentare?scope=debtor", "/buchungen?scope=open", ""]:
+            with self.subTest(suffix=suffix):
+                if suffix:
+                    response = self.client.get("/app/forderungen/details/1_R1" + suffix, headers=headers)
+                else:
+                    response = self.client.post(
+                        "/app/forderungen/details/1_R1",
+                        headers=headers,
+                        data={"source": "details", "return_to": return_to},
+                    )
+                self.assertEqual(self.login_target(response), current.removeprefix("http://testserver"))
+
+    def test_login_post_normalizes_fragment_next_to_full_get(self):
+        self.client.get("/login")
+        csrf = self.client.cookies[settings.LOGIN_CSRF_COOKIE_NAME]
+        user = DirectoryUser("tester", "CN=tester", "Tester", "")
+        rights = (Entitlement("1", "10", "SC", "Mitarbeiter", 100),)
+        with (
+            patch("app.routes.ldap_authenticate", return_value=user),
+            patch("app.routes.load_entitlements", return_value=rights),
+        ):
+            response = self.client.post(
+                "/login",
+                data={
+                    "username": "tester",
+                    "password": "test",
+                    "_csrf": csrf,
+                    "next": "/app/forderungen/details/1_R1/kommentare?scope=debtor",
+                },
+                follow_redirects=False,
+            )
+        self.assertEqual(response.status_code, 303)
+        self.assertEqual(response.headers["location"], "/app/forderungen/details/1_R1")
+
+    def test_native_page_request_uses_full_page_redirect(self):
+        response = self.client.get(LIST_PATH + "?Filiale=10", follow_redirects=False)
+        self.assertEqual(response.status_code, 303)
+        self.assertEqual(parse_qs(urlsplit(response.headers["location"]).query)["next"], [LIST_PATH + "?Filiale=10"])
+
+
+class DetailReturnTests(unittest.TestCase):
+    def setUp(self):
+        self.db = MagicMock()
+        self.db.execute.return_value.first.return_value = (1,)
+        application = FastAPI()
+        application.include_router(router)
+        application.dependency_overrides[get_session] = lambda: self.db
+
+        @application.middleware("http")
+        async def identity(request, call_next):
+            request.state.principal = SimpleNamespace(username="tester", name="Tester", role="Mitarbeiter", csrf="csrf")
+            return await call_next(request)
+
+        self.client = TestClient(application, raise_server_exceptions=False)
+        self.addCleanup(self.client.close)
+        self.row = dict(
+            Client_DB="1",
+            Beleg_Nr="R1",
+            Beleg_Text="Rechnung R1",
+            Beleg_Offen=10,
+            Kunde_offen_gesamt=20,
+            Beleg_Datum=date(2026, 10, 1),
+            Fahrzeug_Erstzulassung=None,
+            Fahrzeug_Kaufdatum=None,
+            Wiedervorlage=date(2026, 11, 1),
+            Mwst_Betrag=0,
+            Mwst_Betrag_berechnet=1.9,
+        )
+        context = dict(
+            forderungen_details=[self.row],
+            forderungen_kommentare=[],
+            forderungen_buchungen=[],
+            auftraege_positionen=[],
+            versicherungen=[],
+            files=[],
+            detail_url="/app/forderungen/details/1_R1",
+            kommentare_scope="invoice",
+            buchungen_scope="invoice",
+            vehicle_missing=False,
+            summary=False,
+        )
+        fixture = patch("app.routes.get_template_context", side_effect=lambda *args: dict(context))
+        fixture.start()
+        self.addCleanup(fixture.stop)
+        self.return_url = LIST_PATH + "?Filiale=10&Kunde=Muster&focus=1_R1"
+
+    def test_detail_customer_total_uses_database_column_alias(self):
+        from contextlib import closing
+        import sqlite3
+        from app.jinja_templates import templates
+        sql=templates.env.get_template('forderungen/details/queries/forderungen_details.sql').render()
+        projection=next(line.strip().removeprefix(',').strip() for line in sql.splitlines() if 'AS [Kunde_offen_gesamt]' in line)
+        with closing(sqlite3.connect(':memory:')) as connection:
+            result=connection.execute('SELECT '+projection+' FROM (SELECT 12345.67 AS [Kunde_Gesamt_Offen]) AS [F]')
+            self.row.pop('Kunde_offen_gesamt')
+            self.row.update(dict(zip([column[0] for column in result.description],result.fetchone())))
+        response=self.client.get('/app/forderungen/details/1_R1')
+        self.assertEqual(response.status_code,200)
+        self.assertIn('12.345,67',response.text)
+
+    def test_detail_displays_missing_amounts_without_claiming_zero(self):
+        self.row.update(Beleg_Offen=None,Kunde_offen_gesamt=None,Mwst_Betrag=None,Mwst_Betrag_berechnet=None)
+        response=self.client.get('/app/forderungen/details/1_R1')
+        self.assertEqual(response.status_code,200)
+        self.assertIn('—',response.text)
+
+    def test_detail_and_saved_form_keep_explicit_return_context(self):
+        response = self.client.get("/app/forderungen/details/1_R1?" + urlencode({"return_to": self.return_url}))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("Filiale=10&amp;Kunde=Muster&amp;focus=1_R1", response.text)
+        response = self.client.post(
+            "/app/forderungen/details/1_R1",
+            data={
+                "source": "details",
+                "return_to": self.return_url,
+            },
+            headers={"HX-Request": "true", "Referer": "http://testserver/app/forderungen/details/1_R1"},
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(
+            'name="return_to" value="/app/forderungen/liste?Filiale=10&amp;Kunde=Muster&amp;focus=1_R1"', response.text
+        )
+        self.assertEqual(self.db.commit.call_count, 1)
+
+    def test_save_and_back_redirects_after_commit_to_full_list(self):
+        response = self.client.post(
+            "/app/forderungen/details/1_R1",
+            data={
+                "source": "details",
+                "return_to": self.return_url,
+                "redirect": "list",
+            },
+            headers={"HX-Request": "true"},
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.headers["HX-Redirect"], self.return_url)
+        self.db.commit.assert_called_once()
+        native = self.client.post(
+            "/app/forderungen/details/1_R1",
+            data={
+                "source": "details",
+                "return_to": self.return_url,
+                "redirect": "list",
+            },
+            follow_redirects=False,
+        )
+        self.assertEqual(native.status_code, 303)
+        self.assertEqual(native.headers["location"], self.return_url)
+
+    def test_failed_save_does_not_return_and_external_target_is_ignored(self):
+        self.db.commit.side_effect = RuntimeError("test database unavailable")
+        response = self.client.post(
+            "/app/forderungen/details/1_R1",
+            data={
+                "source": "details",
+                "return_to": self.return_url,
+                "redirect": "list",
+            },
+            headers={"HX-Request": "true"},
+        )
+        self.assertEqual(response.status_code, 500)
+        self.assertNotIn("HX-Redirect", response.headers)
+        self.db.commit.side_effect = None
+        response = self.client.post(
+            "/app/forderungen/details/1_R1",
+            data={
+                "source": "details",
+                "redirect": "https://evil.test",
+            },
+            headers={"HX-Request": "true"},
+        )
+        self.assertEqual(response.headers["HX-Redirect"], LIST_PATH + "?focus=1_R1")

Certains fichiers n'ont pas été affichés car il y a eu trop de fichiers modifiés dans ce diff