"""Shared, case-authorized document collection and mail drafts.""" import hashlib import logging import mimetypes from email.message import EmailMessage from email.policy import SMTP from typing import Literal from urllib.parse import quote from fastapi import APIRouter, Depends, HTTPException, Request from fastapi.responses import HTMLResponse, Response from sqlalchemy import text from .db import get_session from .docuware_search import get_adapter from .file_storage import get_file, get_files from .jinja_templates import templates from .ldap import DirectoryUnavailable, lookup_directory_user from .permissions import current_principal, ensure_forderung_access router = APIRouter() logger = logging.getLogger(__name__) Scope = Literal["invoice", "open", "debtor", "vehicle"] BASE = "/app/forderungen/documents" def case_context(request, primary_key, db): from .routes import convert_primary_key key = convert_primary_key("forderungen", primary_key) ensure_forderung_access(db, current_principal(request), key["Client_DB"], key["Beleg_Nr"]) row = ( db.execute( text("SELECT TOP 1 * FROM dbo.Forderungen_Kopf WHERE Client_DB=:Client_DB AND Beleg_Nr=:Beleg_Nr"), key ) .mappings() .first() ) if not row: raise HTTPException(404, "Forderung nicht gefunden") return key, row def scoped_keys(db, key, row, scope): if scope == "invoice": return [key] column = "Fahrzeug_Nr" if scope == "vehicle" else "Kunde_Nr" value = row.get(column) if not value: return [] condition = f"Client_DB=:tenant AND {column}=:value" sql = f"SELECT Client_DB, Beleg_Nr FROM dbo.Forderungen_Kopf WHERE {condition}" if scope == "open": sql += " AND Beleg_Offen <> 0" else: sql += f" UNION SELECT Client_DB, Beleg_Nr FROM dbo.Forderungen_Historie WHERE {condition}" return [ dict(item) for item in db.execute(text(sql), {"tenant": key["Client_DB"], "value": value}).mappings().fetchall() ] def identity(source, *parts): return source + "-" + hashlib.sha256("\0".join(map(str, parts)).encode()).hexdigest() def collect(db, key, row, scope): documents, errors = {}, [] keys = scoped_keys(db, key, row, scope) adapter = get_adapter() try: if scope in ("invoice", "open"): searches = [dict(document_no=k["Beleg_Nr"]) for k in keys] elif scope == "debtor": searches = [dict(customer_no=str(row["Kunde_Nr"]))] if row.get("Kunde_Nr") else [] else: vin = None if row.get("Fahrzeug_Nr"): vehicle = ( db.execute( text( "SELECT TOP 1 Fahrzeug_VIN FROM dbo.Fahrzeuge WHERE Client_DB=:tenant AND Fahrzeug_Nr=:vehicle" ), {"tenant": key["Client_DB"], "vehicle": row["Fahrzeug_Nr"]}, ) .mappings() .first() ) vin = vehicle["Fahrzeug_VIN"] if vehicle else None searches = [dict(vehicle_no=str(vin))] if vin else [] for search in searches: for item in adapter.search(key["Client_DB"], **search): doc = {**item, "source": "DocuWare", "pdf": True} doc["token"] = identity("dw", doc["archive"], doc["id"]) documents[doc["token"]] = doc except Exception: logger.exception("DocuWare-Dokumentliste konnte nicht geladen werden") errors.append("Keine Verbindung zu DocuWare") if not errors and not documents: errors.append( f"Keine Dokumente für Beleg {key['Beleg_Nr']} gefunden" if scope == "invoice" else "Keine DocuWare-Dokumente für diesen Filter gefunden" ) try: for item_key in keys: for file in get_files(item_key): token = identity("local", file.relative_path) documents[token] = dict( token=token, source="Lokal", number=item_key["Beleg_Nr"], date="", kind="", editor="", name=file.name, path=file.relative_path, pdf=file.name.lower().endswith(".pdf"), ) except OSError: logger.exception("Lokale Dokumentliste konnte nicht geladen werden") errors.append("Die lokalen Dateien konnten nicht geladen werden.") docs = sorted(documents.values(), key=lambda d: (d.get("name", "").casefold(), d["token"])) docs.sort(key=lambda d: d.get("date", ""), reverse=True) return docs, errors def context(request, primary_key, db, scope): key, row = case_context(request, primary_key, db) docs, errors = collect(db, key, row, scope) return dict( documents=docs, document_errors=errors, document_scope=scope, document_base=BASE + "/" + quote(primary_key, safe=""), document_key=primary_key, customer_missing=not row.get("Kunde_Nr"), vehicle_missing=not row.get("Fahrzeug_Nr"), ) def selected(request, primary_key, db, scope, token): ctx = context(request, primary_key, db, scope) doc = next((d for d in ctx["documents"] if d["token"] == token), None) if doc is None: if token.startswith("dw-") and "Keine Verbindung zu DocuWare" in ctx["document_errors"]: raise HTTPException(503, "Keine Verbindung zu DocuWare") raise HTTPException(404, "Dokument nicht gefunden oder nicht mehr verfügbar") return doc, ctx def content(primary_key, doc): try: if doc["source"] == "Lokal": path = get_file(doc["path"]) return path.read_bytes(), mimetypes.guess_type(path.name)[0] or "application/octet-stream", path.name return get_adapter().download(primary_key.split("_", 1)[0], doc) except FileNotFoundError: raise HTTPException(404, "Dokumentdatei nicht gefunden") except Exception: logger.exception("Dokument konnte nicht geöffnet werden") raise HTTPException(503, "Dokument konnte nicht geladen werden. Bitte erneut versuchen.") @router.get(BASE + "/{primary_key}", response_class=HTMLResponse) def listing( request: Request, primary_key: str, scope: Scope = "invoice", detail: bool = False, db=Depends(get_session) ): ctx = context(request, primary_key, db, scope) ctx["document_detail"] = detail return templates.TemplateResponse( request, "forderungen/documents/list.html", ctx, headers={"Cache-Control": "no-store"} ) @router.get(BASE + "/{primary_key}/content/{token}") def download(request: Request, primary_key: str, token: str, scope: Scope = "invoice", db=Depends(get_session)): doc, _ = selected(request, primary_key, db, scope, token) data, media, name = content(primary_key, doc) disposition = "inline" if doc["pdf"] else "attachment" return Response( data, media_type=media, headers={ "Content-Disposition": f"{disposition}; filename*=UTF-8''{quote(name, safe='')}", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", }, ) def recipients(request, primary_key, db): # Always use the opened case, regardless of the selected document's receipt. 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() 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: colleague = user.email except (DirectoryUnavailable, ValueError): pass values = [ ("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 ""), ] return [ dict(id=id_, label=label, email=address if valid_address(address) else "") for id_, label, address in values ] def valid_address(value): from email.headerregistry import Address if not value or any(c in value for c in "\r\n"): return False try: address = Address(addr_spec=value) return bool(address.username and address.domain) except ValueError: return False @router.get(BASE + "/{primary_key}/recipients/{token}", response_class=HTMLResponse) def recipient_list(request: Request, primary_key: str, token: str, scope: Scope = "invoice", db=Depends(get_session)): doc, ctx = selected(request, primary_key, db, scope, token) ctx.update(document=doc, recipients=recipients(request, primary_key, db)) return templates.TemplateResponse( request, "forderungen/documents/recipients.html", ctx, headers={"Cache-Control": "no-store"} ) @router.get(BASE + "/{primary_key}/draft/{token}") def draft( request: Request, primary_key: str, token: str, recipient: str, scope: Scope = "invoice", db=Depends(get_session) ): doc, _ = selected(request, primary_key, db, scope, token) target = next((r for r in recipients(request, primary_key, db) if r["id"] == recipient), None) if not target or not target["email"]: raise HTTPException(422, "Keine gültige hinterlegte E-Mail-Adresse vorhanden") data, media, name = content(primary_key, doc) message = EmailMessage(policy=SMTP) message["To"] = target["email"] message["Subject"] = "Dokument zu Beleg " + primary_key.split("_", 1)[1] message["X-Unsent"] = "1" message.set_content("Guten Tag,\n\nim Anhang finden Sie das ausgewählte Dokument.\n") major, minor = media.split(";", 1)[0].split("/", 1) message.add_attachment(data, maintype=major, subtype=minor, filename=name) return Response( message.as_bytes(), media_type="message/rfc822", headers={"Content-Disposition": "attachment; filename=Dokument.eml", "Cache-Control": "no-store"}, )