3
0

4 کامیت‌ها e105fa69e3 ... 13ab43a0a3

نویسنده SHA1 پیام تاریخ
  gc-server3 13ab43a0a3 Dokumentenerstellung 1 هفته پیش
  gc-server3 67de410fbf E-Mail-Adressenlogik 1 هفته پیش
  gc-server3 d06e9934f3 Filterübergabe WV-Staffelung im Dashboard 1 هفته پیش
  gc-server3 916ce069c6 Filterverhalten für Datumsfelder, CSS-Stile für Listenbadges 1 هفته پیش

+ 32 - 10
README.md

@@ -179,13 +179,15 @@ Die Rubriken Altersstaffel, Standort und Verursacher zeigen horizontale Balken m
 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 Wiedervorlagestaffelung beeinflusst derzeit nur die Darstellung im Dashboard;
-beim Öffnen der Liste wird diese Stapelung nicht als Datumsfilter übernommen.
+berücksichtigt. Die Wiedervorlagestapelung übernimmt Schlüssel, Reihenfolge und
+Bezeichnung direkt aus `Forderungen_Liste.Wiedervorlage_Staffel_Nr` und
+`Wiedervorlage_Staffel_Text`. Die Einstufung wird von der Datenquelle geliefert:
+„Überfällig“, heute bis in 3 Tagen, in 4 bis 20 Tagen und ab 21 Tagen „zurückgestellt“.
+Das Dashboard berechnet diese Einstufung nicht zusätzlich aus Datumsfeldern.
+Fehlt die Staffelnummer, erscheint der Beleg unter „Ohne WV-Staffel“.
+Segmentlinks übernehmen die Staffelnummer in den bestehenden Listenfilter `WVStaffel`;
+Gruppenlinks öffnen alle Staffeln der Gruppe. Dadurch stimmen Anzahl und Betrag im
+angeklickten Segment mit der gefilterten Liste überein.
 Alte Dashboardadressen mit `page=Wiedervorlage` wechseln zum Standort mit
 Wiedervorlagestapelung; bestehende Listenlinks bleiben gültig.
 
@@ -312,6 +314,24 @@ zurückgerollt. Eine SQL-Server-Sperre auf dem Forderungskopf serialisiert beide
 Speicherwege. Reine Datei-Uploads verändern die Flags nicht. Die beiden Flagspalten
 und `Benutzer_Rolle.Rolle_ID` müssen bereits im Datenbankschema vorhanden sein.
 
+## Dokumente aus Vorlagen erstellen
+
+Im Versicherungsbereich stehen „Rechnung erstellen“ und „Mahnung erstellen“
+nebeneinander; im Rechtsanwaltsbereich wird der „Beitreibungsauftrag“ angeboten.
+Die zugehörigen Vorlagen `Rechnung.docx`, `Mahnung.docx` und
+`Beitreibungsauftrag.docx` liegen unter `templates/forderungen/details/docs`.
+Gerendert wird mit den gespeicherten Detaildaten einschließlich Versicherung,
+Selbstbeteiligung, MwSt. und aktuellem Verursacher.
+
+Vor dem Rendern wird nach `<Dokumenttyp>_<Mandant>_<Belegnummer>.docx` im
+Belegordner von `LOCAL_STORAGE` gesucht. Vorhandene Dateien werden unverändert
+ausgegeben, auch aus der älteren Ordnerstruktur `<Mandant>/<Belegnummer>`.
+Neue Dokumente werden unter `<Mandant>_<Belegnummer>` gespeichert und sind damit
+auch in der lokalen Dateiliste verfügbar. Parallelaufrufe erzeugen dieselbe Datei
+nur einmal; fehlgeschlagenes Rendern hinterlässt kein unvollständiges Dokument.
+Ein erneuter Klick aktualisiert ein bereits gespeichertes Dokument nicht automatisch.
+Der bestehende Exportlink ohne Dokumenttyp verwendet weiterhin die Mahnung.
+
 ## Dokumente im Kommentarbereich
 
 Über die Büroklammer oder durch Ablegen auf dem Kommentarfeld können mehrere Dateien
@@ -484,9 +504,11 @@ Produktivexporte unter `data/docuware-exports/` sind von Git ausgeschlossen.
 
 „Weiterleiten“ erzeugt eine `.eml`-Datei mit genau einem Anhang und `X-Unsent: 1`.
 Empfänger stammen aus der geöffneten Forderung; fehlende Adressen deaktivieren das
-jeweilige Ziel. Der Verursacher berücksichtigt die manuelle Zuordnung und wird
-über AD aufgelöst. Im Debuglogin ist die eigene Adresse leer. Die Anwendung
-versendet keine E-Mails. Die Bearbeitbarkeit des Entwurfs muss im eingesetzten
+jeweilige Ziel. „An mich“ verwendet `Benutzer_Rolle.Benutzer_Email` für den angemeldeten
+Benutzer, ersatzweise dessen E-Mail-Adresse aus den Anmeldedaten. „Verursacher“ verwendet
+`Forderungen_Liste.Verursacher_Email` für Mandant und Belegnummer der geöffneten Forderung;
+fehlt eine gültige Adresse, bleibt die AD-Abfrage des aktuellen Verursachers als Rückfall.
+Die Anwendung versendet keine E-Mails. Die Bearbeitbarkeit des Entwurfs muss im eingesetzten
 Mailprogramm geprüft werden; sie hängt vom Client und dessen Dateizuordnung ab.
 Vor Produktivfreigabe sind außerdem Suchfelder und PDF-Ausgabe am echten Archiv
 zu prüfen. `DW_TIMEOUT` begrenzt die einzelnen DocuWare-Anfragen.

+ 52 - 0
app/document_generation.py

@@ -0,0 +1,52 @@
+"""Render the selected case template once and reuse stored documents."""
+
+from datetime import date, datetime
+from pathlib import Path
+from typing import Literal
+from zoneinfo import ZoneInfo
+
+from docxtpl import DocxTemplate
+from fastapi import HTTPException
+from sqlalchemy import text
+
+from .file_storage import get_or_create_file
+from .jinja_templates import number_format, templates
+
+
+DocumentType = Literal["Mahnung", "Rechnung", "Beitreibungsauftrag"]
+TEMPLATE_DIR = Path(__file__).resolve().parents[1] / "templates/forderungen/details/docs"
+DOCX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+
+
+def generated_document(db, client_db: str, document_no: str, document_type: DocumentType) -> Path:
+    key = {"Client_DB": client_db, "Beleg_Nr": document_no}
+    filename = f"{document_type}_{client_db}_{document_no}.docx"
+
+    def create(destination):
+        query = templates.env.get_template("forderungen/details/queries/forderungen_details.sql").render()
+        row = db.execute(text(query), {"client_db": client_db, "beleg_nr": document_no}).mappings().first()
+        if not row:
+            raise HTTPException(404, "Forderung nicht gefunden")
+        context = {
+            name: value.strftime("%d.%m.%Y") if isinstance(value, (date, datetime)) else value if value is not None else ""
+            for name, value in row.items()
+        }
+        for name in ("Beleg_Betrag", "Beleg_Offen", "Selbstbeteiligung_Betrag", "Mwst_Betrag"):
+            if row.get(name) is not None:
+                context[name] = number_format(row[name])
+        context.update(
+            Datum_heute=datetime.now(ZoneInfo("Europe/Berlin")).strftime("%d.%m.%Y"),
+            Betrag_SB=context.get("Selbstbeteiligung_Betrag", ""),
+            Betrag_USt=context.get("Mwst_Betrag", ""),
+            Rechnung_Nr=document_no,
+            Beleg_offen=context.get("Beleg_Offen", ""),
+            Verursacher_Text=context.get("Verursacher_Aktuell_Text") or context.get("Verursacher_Text", ""),
+        )
+        template_path = TEMPLATE_DIR / f"{document_type}.docx"
+        if not template_path.is_file():
+            raise HTTPException(503, f"Die Vorlage {document_type}.docx ist nicht verfügbar.")
+        document = DocxTemplate(template_path)
+        document.render(context, autoescape=True)
+        document.save(destination)
+
+    return get_or_create_file(key, filename, create)

+ 15 - 3
app/documents.py

@@ -194,8 +194,20 @@ def recipients(request, primary_key, db):
     tenant, number = primary_key.split("_", 1)
     query = templates.env.get_template("forderungen/details/queries/forderungen_details.sql").render()
     row = db.execute(text(query), {"client_db": tenant, "beleg_nr": number}).mappings().first()
-    colleague = ""
-    if row and row.get("Verursacher_Aktuell_Benutzer_ID"):
+    principal = current_principal(request)
+    user_rows = db.execute(text("""
+        SELECT DISTINCT Benutzer_Email FROM dbo.Benutzer_Rolle
+        WHERE Benutzer_ID = :username
+        ORDER BY Benutzer_Email
+    """), {"username": principal.username}).mappings().fetchall()
+    own_address = next((address for item in user_rows
+                        if valid_address(address := (item["Benutzer_Email"] or "").strip())), principal.email)
+    list_row = db.execute(text("""
+        SELECT TOP 1 Verursacher_Email FROM dbo.Forderungen_Liste
+        WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+    """), {"client_db": tenant, "beleg_nr": number}).mappings().first()
+    colleague = (list_row.get("Verursacher_Email") or "").strip() if list_row else ""
+    if not valid_address(colleague) and row and row.get("Verursacher_Aktuell_Benutzer_ID"):
         try:
             user = lookup_directory_user(row["Verursacher_Aktuell_Benutzer_ID"])
             if user and not user.disabled:
@@ -203,7 +215,7 @@ def recipients(request, primary_key, db):
         except (DirectoryUnavailable, ValueError):
             pass
     values = [
-        ("self", "An mich", current_principal(request).email),
+        ("self", "An mich", own_address),
         ("colleague", "Verursacher", colleague),
         ("customer", "Kunde", row.get("Kunde_Email") if row else ""),
         ("insurance", "Versicherung", row.get("Vers_Email") if row else ""),

+ 32 - 0
app/file_storage.py

@@ -134,6 +134,38 @@ def get_file(name: str) -> Path:
         raise FileNotFoundError(name) from error
 
 
+def get_or_create_file(primary_key: dict[str, str], name: str, create) -> Path:
+    """Reuse a canonical or legacy document; publish new files atomically."""
+    root = _root()
+    folders = _folders(root, primary_key)
+    targets = [_checked(root, *folder.relative_to(root).parts, name) for folder in folders]
+
+    def existing():
+        for target in targets:
+            if target.is_file():
+                return target
+            if target.exists():
+                raise UploadError("Unter diesem Dateinamen besteht bereits ein Ordner.")
+        return None
+
+    if cached := existing():
+        return cached
+    with _beleg_lock(root, folders[0]):
+        if cached := existing():
+            return cached
+        staging = _checked(root, ".upload-staging")
+        staging.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(dir=staging, suffix=Path(name).suffix, delete=False) as output:
+            temporary = Path(output.name)
+        try:
+            create(temporary)
+            folders[0].mkdir(parents=True, exist_ok=True)
+            os.replace(temporary, targets[0])
+        finally:
+            temporary.unlink(missing_ok=True)
+    return targets[0]
+
+
 @contextmanager
 def _beleg_lock(root: Path, folder: Path):
     lock_dir = _checked(root, ".upload-locks")

+ 21 - 53
app/forderung_dashboard.py

@@ -2,7 +2,7 @@
 
 import hashlib
 from collections import Counter
-from datetime import date, datetime, timedelta
+from datetime import datetime
 from decimal import Decimal
 from zoneinfo import ZoneInfo
 
@@ -20,47 +20,17 @@ 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),
-    ]
+FOLLOW_UP_COLORS = {
+    "überfällig": "#d4aaaa",
+    "in 3 tagen fällig": "#e0cd9c",
+    "noch nicht fällig": "#b4c5b5",
+    "zurückgestellt": "#b2bccd",
+}
 
 
 def _url(view, key, segment=..., only_invoices=False, stack="abteilung"):
@@ -78,6 +48,8 @@ def _url(view, key, segment=..., only_invoices=False, stack="abteilung"):
         select("Verursacher", key["text"])
     if segment is not ... and stack == "abteilung":
         select("Abteilung", segment)
+    if segment is not ... and stack == "wiedervorlage":
+        select("WVStaffel", segment)
     if only_invoices:
         select("RechnungGutschrift", "Rechnung")
     return list_url(filters)
@@ -87,7 +59,6 @@ def build_dashboard(db, username, now=None, only_invoices=False, stack="abteilun
     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"}
@@ -95,8 +66,7 @@ def build_dashboard(db, username, now=None, only_invoices=False, stack="abteilun
     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)
+    total, departments, stages = Decimal(0), set(), {}
     for values in source:
         row = dict(zip(columns, values))
         department = _key(row.get("Abteilung"))
@@ -104,18 +74,16 @@ def build_dashboard(db, username, now=None, only_invoices=False, stack="abteilun
         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)
+            # The shared list projection owns the classification, including the
+            # 21-day deferred boundary. Use its key for an exact WVStaffel link.
+            segment_id = _key(row["Wiedervorlage_Staffel_Nr"])
+            label = _key(row["Wiedervorlage_Staffel_Text"])
+            stages.setdefault(segment_id, dict(
+                id=segment_id,
+                label=label or (f"WV-Staffel {segment_id}" if segment_id is not None else "Ohne WV-Staffel"),
+                color=FOLLOW_UP_COLORS.get((label or "").casefold(), color(segment_id)) if segment_id is not None else "#c5c5c5",
+                key=segment_id,
+            ))
         amount = Decimal(str(row["Beleg_Offen"] or 0))
         total += amount
         age = _key(row.get("Staffel_Text"))
@@ -154,7 +122,7 @@ def build_dashboard(db, username, now=None, only_invoices=False, stack="abteilun
             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]
+        else sorted(stages.values(), key=lambda item: (item["key"] is None, Decimal(item["key"] or "0")))
     )
 
     def serialized(amount):

+ 17 - 42
app/routes.py

@@ -4,13 +4,10 @@ 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 urlencode
 from zoneinfo import ZoneInfo
-from zoneinfo import ZoneInfo
 
-from docxtpl import DocxTemplate
 from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
 from fastapi.responses import (
     FileResponse,
@@ -22,7 +19,7 @@ from fastapi.responses import (
 from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from app.file_storage import file_primary_key, get_file, get_files
+from app.file_storage import UploadError, file_primary_key, get_file, get_files
 from app.query_filter import filter_clauses, import_filter_config, parse_filter_date
 
 from .auth import clear_session_cookie, safe_next_url, set_session_cookie
@@ -34,6 +31,7 @@ from .dashboard_segment import (
     segment_filters,
 )
 from .db import get_session
+from .document_generation import DOCX_MEDIA_TYPE, DocumentType, generated_document
 from .documents import router as documents_router
 from .docuware_search import get_invoice_pdf_by_document_no
 from .forderung_dashboard import STACKS, build_dashboard
@@ -525,48 +523,25 @@ def forderungen_dashboard(
     )
 
 
-# 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)):
+def export_docx2(
+    request: Request, client_db: str, document_no: str,
+    document_type: DocumentType = "Mahnung", db: Session = Depends(get_session),
+):
     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 settings.LOCAL_STORAGE:
+        raise HTTPException(503, "Dokumentablage ist nicht konfiguriert")
+    try:
+        filename = generated_document(db, client_db, document_no, document_type)
+    except UploadError as error:
+        raise HTTPException(400, str(error)) from error
+    except OSError as error:
+        logger.exception("Dokument konnte nicht erstellt oder aus der Ablage geladen werden")
+        raise HTTPException(503, "Dokument konnte nicht bereitgestellt werden. Bitte erneut versuchen.") from error
+    return FileResponse(
+        filename, media_type=DOCX_MEDIA_TYPE, filename=filename.name, headers={"Cache-Control": "no-store"}
     )
-    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_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_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)
-
-    return FileResponse(filename, media_type="application/octet-stream", filename=filename.name)
 
 
 @router.get("/files/")

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

@@ -107,6 +107,7 @@ body:has(.gc-detail-page) { max-width: 1840px; }
 .gc-workflow-form .gc-insurance-amount-row > div { width: auto; }
 .gc-workflow-form .gc-insurance-amount-row > .gc-amount-suggestion { grid-column: 2; }
 .gc-workflow-form #Schaden_Details { resize: vertical; }
+.gc-workflow-form .gc-document-actions { display: flex; flex-wrap: wrap; gap: .5rem; }
 .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,

+ 4 - 3
static/assets/css/list.css

@@ -68,9 +68,10 @@ body:has(.gc-list-page) { max-width: 1840px; }
 .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-list-badge-warning, .gc-list-badge-2 { background: #fff3bd; border-color: #c8af45; }
+.gc-list-badge-1 { background: #f5dddd; border-color: #b30808; }
+.gc-list-badge-3 { background: #e6eedc; border-color: #92aa78; }
+.gc-list-badge-4 { background: #b1bcc7; border-color: #354f63; }
 .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; }

+ 1 - 1
templates/base/base.html

@@ -23,7 +23,7 @@
   <link href="/static/assets/css/main.css" rel="stylesheet">
   <link href="/static/assets/css/app.css" rel="stylesheet">
 
-  <link href="/static/assets/css/details.css?v=5" rel="stylesheet">
+  <link href="/static/assets/css/details.css?v=6" rel="stylesheet">
   <link href="/static/assets/css/list.css?v=2" rel="stylesheet">
   <link href="/static/assets/css/dashboard.css" rel="stylesheet">
   <script src="/static/assets/js/dashboard.js" defer></script>

+ 1 - 1
templates/base/liste_filter.html

@@ -33,7 +33,7 @@
 {% 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"
+      hx-params="*" hx-trigger="change[event.target.type !== 'date'], input[event.target.type === 'date'] delay:1200ms" hx-push-url="true" hx-swap="innerHTML" hx-target="body"
       hx-indicator="#liste-filter" hx-disabled-elt="#liste-filter fieldset" hx-sync="this:drop">
   <div class="gc-filter-loading" role="status" aria-live="polite" aria-atomic="true">
     <span class="gc-filter-loading-message"><span class="gc-filter-spinner" aria-hidden="true"></span>Filter werden angewendet …</span>

+ 1 - 1
templates/forderungen/dashboard/dashboard.html

@@ -44,7 +44,7 @@
     </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. Die Listenlinks öffnen die gesamte Gruppe; die Wiedervorlagestaffel wird dabei nicht als Filter übernommen.{% 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>
+  <p class="gc-dashboard-description">{% if dashboard_stack == 'wiedervorlage' %}Die Farben zeigen die Wiedervorlagestaffeln aus der Forderungsliste: überfällig, heute bis in 3 Tagen, in 4 bis 20 Tagen und ab 21 Tagen zurückgestellt. Die Listenlinks der Segmente übernehmen die jeweilige WV-Staffel als Filter; der Gruppenlink öffnet die gesamte Gruppe.{% 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>

+ 7 - 6
templates/forderungen/details/details_formular.html

@@ -94,10 +94,11 @@
             {{ row.Mwst_Betrag_berechnet|number_format }}</button>
         </div>
       </div>
-      <div class="col-3">
-        <a class="btn btn-outline-secondary" hx-disable="true"
-          href="/app/forderungen/export/{{row.Client_DB}}_{{row.Beleg_Nr}}">Mahnung
-          erstellen</a>
+      <div class="gc-document-actions">
+        <a class="btn btn-outline-secondary" hx-boost="false"
+          href="/app/forderungen/export/{{ (row.Client_DB|string ~ '_' ~ row.Beleg_Nr|string)|urlencode }}/?document_type=Rechnung">Rechnung erstellen</a>
+        <a class="btn btn-outline-secondary" hx-boost="false"
+          href="/app/forderungen/export/{{ (row.Client_DB|string ~ '_' ~ row.Beleg_Nr|string)|urlencode }}/?document_type=Mahnung">Mahnung erstellen</a>
       </div>
 
     </div>
@@ -161,8 +162,8 @@
         </div>
       </div>
       <div class="col-3">
-        <a class="btn btn-outline-secondary" hx-disable="true"
-          href="/app/forderungen/export/{{row.Client_DB}}_{{row.Beleg_Nr}}">Beitreibungsauftrag</a>
+        <a class="btn btn-outline-secondary" hx-boost="false"
+          href="/app/forderungen/export/{{ (row.Client_DB|string ~ '_' ~ row.Beleg_Nr|string)|urlencode }}/?document_type=Beitreibungsauftrag">Beitreibungsauftrag</a>
       </div>
     </div>
   </div>

BIN
templates/forderungen/details/docs/Beitreibungsauftrag.docx


BIN
templates/forderungen/details/docs/Mahnung.docx


BIN
templates/forderungen/details/docs/Mahnung_AHR.docx


BIN
templates/forderungen/details/docs/Rechnung.docx


+ 45 - 21
tests/test_dashboard.py

@@ -31,7 +31,7 @@ class DashboardTests(unittest.TestCase):
         for name in needed - existing:
             kind = (
                 "INTEGER"
-                if name == "Beleg_Tage_offen"
+                if name in {"Beleg_Tage_offen", "Wiedervorlage_Staffel_Nr"}
                 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}")
@@ -66,6 +66,13 @@ class DashboardTests(unittest.TestCase):
         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'"
         )
+        # Model source-owned classifications independently of the dashboard clock.
+        self.db.connection.executescript("""
+            UPDATE dbo.Forderungen_Kopf SET Wiedervorlage_Staffel_Nr=2, Wiedervorlage_Staffel_Text='In 3 Tagen fällig';
+            UPDATE dbo.Forderungen_Kopf SET Wiedervorlage_Staffel_Nr=1, Wiedervorlage_Staffel_Text='Überfällig' WHERE Beleg_Nr='R1';
+            UPDATE dbo.Forderungen_Kopf SET Wiedervorlage_Staffel_Nr=3, Wiedervorlage_Staffel_Text='Noch nicht fällig' WHERE Beleg_Nr IN ('X1','NV');
+            UPDATE dbo.Forderungen_Kopf SET Wiedervorlage_Staffel_Nr=NULL, Wiedervorlage_Staffel_Text=NULL WHERE Beleg_Nr='CR';
+        """)
         # The production query now reads a DWH view. Model that view in SQLite;
         # keep the detail overlays live so update/authorization tests still run real SQL.
         overlays = {
@@ -201,50 +208,64 @@ class DashboardTests(unittest.TestCase):
 
                         self.assertIn(number_format(Decimal(segment["amount"])) + " €", response.text)
 
-    def test_follow_up_boundaries_and_null_group(self):
+    def test_follow_up_source_staffels_and_21_day_boundary(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"),
+            ("2026-11-01", "1", "Überfällig"),
+            ("2026-11-02", "2", "In 3 Tagen fällig"),
+            ("2026-11-05 23:30:00", "2", "In 3 Tagen fällig"),
+            ("2026-11-06", "3", "Noch nicht fällig"),
+            ("2026-11-17", "3", "Noch nicht fällig"),
+            ("2026-11-22 23:30:00", "3", "Noch nicht fällig"),
+            ("2026-11-23", "4", "zurückgestellt"),
         ]
-        for value, expected in cases:
+        for value, expected, label in cases:
             with self.subTest(date=value):
                 self.db.connection.execute(
                     "UPDATE dbo.Forderungen_Details SET Wiedervorlage=? WHERE Beleg_Nr='R1'", (value,)
                 )
+                self.db.connection.execute(
+                    "UPDATE dbo.Forderungen_Kopf SET Wiedervorlage_Staffel_Nr=?, Wiedervorlage_Staffel_Text=? WHERE Beleg_Nr='R1'",
+                    (expected, label),
+                )
                 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"])
+                segment = group['segments'][0]
+                self.assertEqual(segment["id"], expected)
+                self.assertEqual(segment["label"], label)
+                self.assertEqual(parse_qs(urlsplit(segment['url']).query)['WVStaffel'], [expected])
+                response = self.client.get(segment["url"])
                 self.assertIn('id="list-count">1', response.text)
+                self.assertIn(f'aria-label="{label} entfernen"', response.text)
         ids = [item["id"] for item in data["stack_items"]]
-        self.assertEqual(ids, ["overdue", "soon", "not_due", "deferred", "undated"])
+        self.assertEqual(ids, ["2", "3", "4", None])
         self.assertNotIn("Wiedervorlage", data["views"])
 
-    def test_follow_up_falls_back_to_document_due_date(self):
+    def test_follow_up_uses_source_staffel_even_when_dates_disagree(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'"
+            "UPDATE dbo.Forderungen_Kopf SET Beleg_Faellig_Datum='2099-01-01', "
+            "Wiedervorlage_Staffel_Nr=10, Wiedervorlage_Staffel_Text='Bezeichnung aus Datenquelle' "
+            "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.assertEqual(group["segments"][0]["id"], "10")
+        self.assertEqual(group["segments"][0]["label"], "Bezeichnung aus Datenquelle")
+        self.assertEqual([item['id'] for item in data['stack_items']], ['2', '3', '10', None])
         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):
+    def test_follow_up_source_staffels_are_independent_of_dashboard_clock(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")
-        self.assertEqual(group['segments'][0]['url'], group['url'])
-        params = parse_qs(urlsplit(group['url']).query)
+        params = parse_qs(urlsplit(group['segments'][0]['url']).query)
         self.assertEqual(decode_filter_values(params['Staffel'][0]), ['< 4 Wochen'])
+        self.assertEqual(params['WVStaffel'], ['1'])
+        self.assertNotIn('WVStaffel', parse_qs(urlsplit(group['url']).query))
         self.assertNotIn('WiedervorlageVon', params)
         self.assertNotIn('WiedervorlageBis', params)
-        self.assertEqual(group["segments"][0]["id"], "soon")
+        self.assertEqual(group["segments"][0]["id"], "1")
 
     def test_follow_up_stack_roundtrips_for_all_rubrics_and_invoice_scope(self):
         for only in [False, True]:
@@ -259,10 +280,13 @@ class DashboardTests(unittest.TestCase):
                         self.assertNotIn('WiedervorlageVon', params)
                         self.assertNotIn('WiedervorlageBis', params)
                         self.assertNotIn('Abteilung', params)
-                        self.assertEqual(segment['url'], group['url'])
+                        self.assertEqual(params['WVStaffel'], [segment['id'] or '__empty__'])
+                        self.assertNotIn('WVStaffel', parse_qs(urlsplit(group['url']).query))
                         response = self.client.get(segment["url"])
                         self.assertEqual(response.status_code, 200)
-                        self.assertIn('id="list-count">' + str(group["count"]), response.text)
+                        self.assertIn('id="list-count">' + str(segment["count"]), response.text)
+                        from app.jinja_templates import number_format
+                        self.assertIn(number_format(Decimal(segment['amount'])) + ' €', 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")

+ 185 - 0
tests/test_document_generation.py

@@ -0,0 +1,185 @@
+"""Render the supplied templates and reuse stored case documents through HTTP."""
+
+import io
+import tempfile
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from types import MappingProxyType, SimpleNamespace
+from unittest.mock import MagicMock, patch
+from zipfile import ZipFile
+from xml.etree import ElementTree
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.config import settings
+from app.db import get_session
+from app.document_generation import DOCX_MEDIA_TYPE, TEMPLATE_DIR
+from app.file_storage import get_or_create_file
+from app.routes import router
+
+
+class DocumentGenerationTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        config = patch.object(settings, 'LOCAL_STORAGE', self.temp.name)
+        config.start()
+        self.addCleanup(config.stop)
+        self.db = MagicMock()
+        self.db.execute.return_value.first.return_value = (1,)
+        self.row = dict(
+            Client_DB='1', Beleg_Nr='R1', Kunde_Nr='K1', Kunde_Name='Müller & <Partner>',
+            Kunde_Adresse='Musterstraße 1', Kunde_PLZ='89073', Kunde_Ort='Ulm',
+            Kunde_Email='kunde@example.com', Kunde_Telefon='012345',
+            Beleg_Datum=date(2026, 11, 18), Beleg_Betrag=Decimal('550.48'), Beleg_Offen=Decimal('300.00'),
+            Selbstbeteiligung_Betrag=Decimal('150.00'), Mwst_Betrag=Decimal('0'), Mwst_Betrag_berechnet=Decimal('104.59'),
+            Versicherung_Typ='Vollkasko', Fahrzeug_Kennzeichen='UL-AB 123',
+            Standort_Name='Ulm', Abteilung='SC', Mahnstufe=1,
+            Verursacher_Text='Original', Verursacher_Aktuell_Text='Aktueller Verursacher',
+        )
+        self.db.execute.return_value.mappings.return_value.first.return_value = MappingProxyType(self.row)
+        app = FastAPI()
+        app.include_router(router)
+        app.dependency_overrides[get_session] = lambda: self.db
+
+        @app.middleware('http')
+        async def authenticated(request, call_next):
+            request.state.principal = SimpleNamespace(username='tester', name='Tester', csrf='csrf', role='Mitarbeiter')
+            return await call_next(request)
+
+        self.client = TestClient(app)
+        self.addCleanup(self.client.close)
+        self.url = '/app/forderungen/export/1_R1/'
+
+    def test_each_supplied_template_renders_to_its_own_local_document(self):
+        from app.document_generation import DocxTemplate
+
+        for kind in ('Rechnung', 'Mahnung', 'Beitreibungsauftrag'):
+            with self.subTest(kind=kind), patch('app.document_generation.DocxTemplate', wraps=DocxTemplate) as template:
+                response = self.client.get(self.url, params={'document_type': kind})
+                self.assertEqual(response.status_code, 200)
+                self.assertEqual(response.headers['content-type'], DOCX_MEDIA_TYPE)
+                template.assert_called_once_with(TEMPLATE_DIR / f'{kind}.docx')
+                stored = self.root / '1_R1' / f'{kind}_1_R1.docx'
+                self.assertEqual(stored.read_bytes(), response.content)
+                with ZipFile(io.BytesIO(response.content)) as archive:
+                    document = ElementTree.fromstring(archive.read('word/document.xml'))
+                text = ''.join(document.itertext())
+                self.assertIn('Müller & <Partner>', text)
+                self.assertIn('R1', text)
+                self.assertNotIn('{{', text)
+                if kind != 'Beitreibungsauftrag':
+                    self.assertIn('150,00', text)
+                    self.assertIn('0,00', text)
+                else:
+                    self.assertIn('300,00', text)
+                    self.assertIn('Aktueller Verursacher', text)
+        self.assertEqual(self.row['Beleg_Datum'], date(2026, 11, 18))
+
+    def test_cached_documents_are_returned_unchanged_in_both_storage_layouts(self):
+        for kind in ('Rechnung', 'Mahnung', 'Beitreibungsauftrag'):
+            for legacy in (False, True):
+                with self.subTest(kind=kind, legacy=legacy):
+                    tenant = '2' if legacy else '1'
+                    folder = self.root / tenant / 'R1' if legacy else self.root / f'{tenant}_R1'
+                    folder.mkdir(parents=True, exist_ok=True)
+                    stored = folder / f'{kind}_{tenant}_R1.docx'
+                    original = f'Already edited {kind}'.encode()
+                    stored.write_bytes(original)
+                    modified = stored.stat().st_mtime_ns
+                    self.db.reset_mock()
+                    with patch('app.document_generation.DocxTemplate') as template:
+                        response = self.client.get(f'/app/forderungen/export/{tenant}_R1/', params={'document_type': kind})
+                    self.assertEqual(response.content, original)
+                    self.assertEqual(stored.stat().st_mtime_ns, modified)
+                    template.assert_not_called()
+                    # Reuse still checks access but does not fetch/render new case data.
+                    self.db.execute.assert_called_once()
+
+    def test_old_export_url_defaults_to_mahnung(self):
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue((self.root / '1_R1/Mahnung_1_R1.docx').is_file())
+
+    def test_unsupported_templates_and_unauthorized_cases_are_not_exported(self):
+        response = self.client.get(self.url, params={'document_type': '../Rechnung'})
+        self.assertEqual(response.status_code, 422)
+        stored = self.root / '1_R1/Rechnung_1_R1.docx'
+        stored.parent.mkdir()
+        stored.write_bytes(b'cached')
+        self.db.execute.return_value.first.return_value = None
+        response = self.client.get(self.url, params={'document_type': 'Rechnung'})
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(stored.read_bytes(), b'cached')
+
+    def test_missing_storage_or_template_has_a_useful_error(self):
+        with patch.object(settings, 'LOCAL_STORAGE', None):
+            self.assertEqual(self.client.get(self.url).status_code, 503)
+        with patch('app.document_generation.TEMPLATE_DIR', self.root / 'missing-templates'):
+            response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 503)
+        self.assertIn('Mahnung.docx', response.json()['detail'])
+        self.assertFalse((self.root / '1_R1/Mahnung_1_R1.docx').exists())
+
+    def test_render_failure_does_not_publish_a_partial_document(self):
+        with patch('app.document_generation.DocxTemplate') as template:
+            template.return_value.render.side_effect = RuntimeError('broken template')
+            with self.assertRaises(RuntimeError):
+                self.client.get(self.url)
+        self.assertFalse((self.root / '1_R1/Mahnung_1_R1.docx').exists())
+        self.assertEqual(list((self.root / '.upload-staging').iterdir()), [])
+
+    def test_concurrent_creation_reuses_one_result(self):
+        created = []
+
+        def create(path):
+            created.append(path)
+            path.write_bytes(b'rendered')
+
+        def load(_):
+            return get_or_create_file({'Client_DB': '1', 'Beleg_Nr': 'R1'}, 'Rechnung_1_R1.docx', create)
+
+        with ThreadPoolExecutor(max_workers=3) as pool:
+            paths = list(pool.map(load, range(3)))
+        self.assertEqual(len(created), 1)
+        self.assertEqual(len(set(paths)), 1)
+        self.assertEqual(paths[0].read_bytes(), b'rendered')
+
+    def test_document_paths_are_validated_before_creating_files(self):
+        for number in ('../escape', 'a/b', 'CON'):
+            with self.subTest(number=number), self.assertRaises(ValueError):
+                get_or_create_file({'Client_DB': '1', 'Beleg_Nr': number}, 'Rechnung.docx', lambda path: None)
+
+    def test_form_buttons_select_the_correct_template_and_allow_downloads(self):
+        from html.parser import HTMLParser
+        from urllib.parse import parse_qs, urlsplit
+        from app.jinja_templates import templates
+
+        class ExportLinks(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self.links = []
+
+            def handle_starttag(self, tag, attrs):
+                attrs = dict(attrs)
+                if tag == 'a' and '/export/' in attrs.get('href', ''):
+                    self.links.append(attrs)
+
+        html = templates.env.get_template('forderungen/details/details_formular.html').render(
+            forderungen_details=[{**self.row, 'Wiedervorlage': date(2026, 11, 18)}], versicherungen=[],
+            request=SimpleNamespace(state=SimpleNamespace(principal=SimpleNamespace(csrf='csrf'))),
+            return_url='/app/forderungen/liste', detail_url='/app/forderungen/details/1_R1', add7days='2026-11-25',
+        )
+        parser = ExportLinks()
+        parser.feed(html)
+        self.assertEqual(len(parser.links), 3)
+        for link, kind in zip(parser.links, ('Rechnung', 'Mahnung', 'Beitreibungsauftrag')):
+            self.assertEqual(link['hx-boost'], 'false')
+            url = urlsplit(link['href'])
+            self.assertEqual(url.path, self.url)
+            self.assertEqual(parse_qs(url.query), {'document_type': [kind]})

+ 55 - 3
tests/test_documents.py

@@ -161,6 +161,44 @@ class DocumentTests(unittest.TestCase):
                 MockAdapter().search("1", document_no="R1")
 
 
+    def test_database_email_sources_enable_recipients_and_address_drafts(self):
+        self.prepare()
+        from app.documents import identity
+
+        self.db.connection.executescript("""
+            ALTER TABLE dbo.Benutzer_Rolle ADD Benutzer_Email TEXT;
+            UPDATE dbo.Benutzer_Rolle SET Benutzer_Email=' me@example.com ' WHERE Benutzer_ID='tester';
+            INSERT INTO dbo.Benutzer_Rolle (Benutzer_ID, Benutzer_Email) VALUES ('tester', 'me@example.com');
+            INSERT INTO dbo.Benutzer_Rolle (Benutzer_ID, Benutzer_Email) VALUES ('other', 'wrong-user@example.com');
+            CREATE TABLE dbo.Forderungen_Liste (Client_DB TEXT, Beleg_Nr TEXT, Verursacher_Email TEXT);
+            INSERT INTO dbo.Forderungen_Liste VALUES ('1', 'R1', 'assignee@example.com');
+            INSERT INTO dbo.Forderungen_Liste VALUES ('2', 'R1', 'wrong-tenant@example.com');
+        """)
+        execute = self.db.execute
+
+        def details_and_queries(statement, values=None):
+            if 'AS [Kunde_offen_gesamt]' in str(statement):
+                result = Mock()
+                result.mappings.return_value.first.return_value = dict(
+                    Verursacher_Aktuell_Benutzer_ID='assignee', Kunde_Email='', Vers_Email='')
+                return result
+            return execute(statement, values)
+
+        token = identity('dw', 'sample', '1')
+        with patch.object(self.db, 'execute', side_effect=details_and_queries), patch('app.documents.lookup_directory_user') as lookup:
+            response = self.client.get(self.base + '/recipients/' + token)
+            self.assertEqual(response.status_code, 200)
+            self.assertIn('An mich: me@example.com', response.text)
+            self.assertIn('Verursacher: assignee@example.com', response.text)
+            for target, expected in [('self', 'me@example.com'), ('colleague', 'assignee@example.com')]:
+                response = self.client.get(self.base + '/draft/' + token, params={'recipient': target})
+                self.assertEqual(response.status_code, 200)
+                message = BytesParser(policy=policy.default).parsebytes(response.content)
+                self.assertEqual(message['To'], expected)
+                self.assertEqual(len(list(message.iter_attachments())), 1)
+            lookup.assert_not_called()
+
+
 class AdapterTests(unittest.TestCase):
     def test_live_exact_search_missing_fields_download_and_full_iteration(self):
         document = SimpleNamespace(id=1, title="Test", fields=[SimpleNamespace(name="Belegnummer", value="R1")])
@@ -199,13 +237,14 @@ class AdapterTests(unittest.TestCase):
             self.assertNotIn("sensitive-token", json.dumps(result))
 
     def test_recipients_from_open_case_and_ad_override(self):
-        request = SimpleNamespace(state=SimpleNamespace(principal=SimpleNamespace(email="self@example.com")))
+        request = SimpleNamespace(state=SimpleNamespace(principal=SimpleNamespace(username="tester", email="self@example.com")))
         db = Mock()
-        db.execute.return_value.mappings.return_value.first.return_value = dict(
+        db.execute.return_value.mappings.return_value.first.side_effect = [dict(
             Verursacher_Aktuell_Benutzer_ID="override",
             Kunde_Email="customer@example.com",
             Vers_Email="insurance@example.com",
-        )
+        ), None]
+        db.execute.return_value.mappings.return_value.fetchall.return_value = []
         with patch(
             "app.documents.lookup_directory_user",
             return_value=SimpleNamespace(email="colleague@example.com", disabled=False),
@@ -217,3 +256,16 @@ class AdapterTests(unittest.TestCase):
                 ["self@example.com", "colleague@example.com", "customer@example.com", "insurance@example.com"],
             )
         self.assertEqual(db.execute.call_args.args[1], dict(client_db="1", beleg_nr="R1"))
+
+    def test_missing_or_invalid_database_emails_keep_valid_session_fallback(self):
+        request = SimpleNamespace(state=SimpleNamespace(principal=SimpleNamespace(username='tester', email='session@example.com')))
+        for database_emails in [[], [{'Benutzer_Email': None}], [{'Benutzer_Email': 'invalid'}],
+                                [{'Benutzer_Email': 'invalid'}, {'Benutzer_Email': 'db@example.com'}]]:
+            with self.subTest(emails=database_emails):
+                db = Mock()
+                db.execute.return_value.mappings.return_value.first.side_effect = [dict(Kunde_Email='', Vers_Email=''), None]
+                db.execute.return_value.mappings.return_value.fetchall.return_value = database_emails
+                targets = recipients(request, '1_R1', db)
+                expected = 'db@example.com' if len(database_emails) == 2 else 'session@example.com'
+                self.assertEqual(targets[0]['email'], expected)
+                self.assertEqual(targets[1]['email'], '')