| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605 |
- 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 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,
- HTMLResponse,
- JSONResponse,
- RedirectResponse,
- StreamingResponse,
- )
- from sqlalchemy import text
- from sqlalchemy.orm import Session
- from app.file_storage import 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
- from .comment_submission import submit_comment
- from .config import settings
- from .dashboard_segment import (
- DASHBOARD_VIEWS,
- parse_segment,
- segment_filters,
- )
- from .db import get_session
- from .documents import router as documents_router
- from .docuware_search import get_invoice_pdf_by_document_no
- from .forderung_dashboard import STACKS, build_dashboard
- from .forderung_data import read_filter_suggestions, 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 (
- 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(documents_router)
- 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="/select")
- @router.get("/health")
- def health():
- return {"status": "ok"}
- 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(
- 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:
- 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
- @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})
- def _list_filter_params(request, config, db, username):
- params = {f.name: request.query_params[f.name] for f in config if request.query_params.get(f.name, "") != ""}
- for f in config:
- if f.filter_type == "date" and f.name in params:
- try:
- parse_filter_date(params[f.name])
- except ValueError as error:
- raise HTTPException(422, f"Ungültiges Datum für {f.text}. Erwartet wird JJJJ-MM-TT.") from error
- try:
- legacy = parse_segment(request.query_params.get("dashboard_segment"))
- except ValueError as error:
- raise HTTPException(400, "Ungültiger Dashboardlink") from error
- names = None
- if legacy and legacy["view"] == "Verursacher" and "id" in legacy["key"] and "Verursacher" not in params:
- columns, rows = read_invoices(
- db, username, ["F.[Verursacher_Benutzer_ID] = :legacy_person"], {"legacy_person": legacy["key"]["id"]}
- )
- names = list(dict.fromkeys(row[columns.index("Verursacher_Text")] for row in rows))
- if not names:
- names = [legacy["key"]["id"]]
- return {**segment_filters(legacy, names), **params}
- @router.get("/app/forderungen/liste", response_class=HTMLResponse)
- 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 = _list_filter_params(request, forderung_filter_config, db, principal.username)
- 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 = filter_clauses(forderung_filter_config, params)
- for f in forderung_filter_config:
- f.current_value = params.get(f.name, f.default_value)
- selected_options = {}
- if page == 0:
- for f in forderung_filter_config:
- if f.filter_type == "select" and f.key_column != f.value_column and f.selected_values:
- items = read_filter_suggestions(db, principal.username, f, [], {}, selected=f.selected_values)
- selected_options[f.name] = {item["value"]: item["label"] for item in items}
- col_names, q = read_invoices(db, principal.username, query_clauses, query_values)
- filters = {}
- for f in forderung_filter_config:
- if f.key_column not in col_names:
- continue
- filter_temp = [
- (
- row[col_names.index(f.sort_column)] or "",
- row[col_names.index(f.key_column)],
- row[col_names.index(f.value_column)],
- )
- for row in q
- ]
- if 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:
- filters[f.name] = {}
- f.options = {**selected_options.get(f.name, {}), **filters[f.name]}
- summary = {
- "Beleg_Offen": sum((Decimal(str(r[col_names.index("Beleg_Offen")] or 0)) for r in q), Decimal(0)),
- "Anzahl": len(q),
- }
- 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] = params.get(f.name, f.default_value)
- f.current_value = defaults[f.name]
- if page > 0 and not q_limit:
- return HTMLResponse("")
- template = "base/liste.html"
- if page > 0:
- template = "base/liste_tabelle.html"
- return templates.TemplateResponse(
- request,
- template,
- {
- "request": request,
- "forderungen_liste": q_limit,
- "filter": filters,
- "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,
- },
- headers={"Cache-Control": "no-store", **({"HX-Push-Url": list_url(params, focus)} if page == 0 else {})},
- )
- @router.get("/app/forderungen/liste/vorschlaege")
- def forderungen_vorschlaege(request: Request, field: str, search: str = "", db: Session = Depends(get_session)):
- principal = current_principal(request)
- config = import_filter_config("forderungen")
- target = next((f for f in config if f.name == field and f.filter_type in {"select", "text"}), None)
- if target is None:
- raise HTTPException(400, "Ungültiges Vorschlagsfeld")
- params = _list_filter_params(request, config, db, principal.username)
- clauses, values = filter_clauses(config, params, exclude=field)
- items = read_filter_suggestions(db, principal.username, target, clauses, values, search)
- return JSONResponse({"items": items[:50], "has_more": len(items) > 50}, 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:
- template_context = {}
- for filename in [
- "auftraege_positionen",
- "forderungen_details",
- "forderungen_mahnungen",
- "versicherungen",
- ]:
- query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", {}).body.decode(
- "utf-8"
- )
- 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":
- 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": "",
- "Schadennummer": "",
- "Schaden_Details": "",
- "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 == "Versicherung_Schadennummer":
- k = "Schadennummer"
- if k in data and k not in {"Client_DB", "Beleg_Nr", "Benutzer_ID", "Timestamp"}:
- if v == "on":
- v = "J"
- if k in {"Selbstbeteiligung_Betrag", "Mwst_Betrag"}:
- v = v.replace(",", ".")
- data[k] = v
- try:
- data["Wiedervorlage"] = parse_filter_date(data["Wiedervorlage"]) if data["Wiedervorlage"] else None
- except ValueError as error:
- raise HTTPException(422, "Bitte ein gültiges Wiedervorlagedatum auswählen.") from error
- # Set audit values after reading the form so clients cannot override them.
- # SQL Server datetime stores local wall time without a timezone offset.
- data.update(
- Bearbeitung_Benutzer_ID=principal.username,
- Bearbeitung_Timestamp=datetime.now(ZoneInfo("Europe/Berlin")).replace(tzinfo=None),
- )
- # Set audit values after reading the form so clients cannot override them.
- # SQL Server datetime stores local wall time without a timezone offset.
- data.update(
- Bearbeitung_Benutzer_ID=principal.username,
- Bearbeitung_Timestamp=datetime.now(ZoneInfo("Europe/Berlin")).replace(tzinfo=None),
- )
- 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")
- for subquery in query.split(";"):
- if subquery.strip():
- db.execute(
- text(subquery).execution_options(query_name=f"forderungen/details/queries/post/post_{source}.sql"), data
- )
- db.commit()
- return_url = return_url_for_request(request, primary_key, return_to if return_to is not None else redirect)
- if redirect:
- 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" 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),
- 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,
- )
- 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)):
- 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_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/")
- 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=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:
- file_content = get_invoice_pdf_by_document_no(client_db=pkey["Client_DB"], document_no=pkey["Beleg_Nr"])
- filestream = io.BytesIO(file_content)
- except FileNotFoundError:
- raise HTTPException(404, f"Keine Dokumente für Beleg {pkey['Beleg_Nr']} gefunden")
- except Exception:
- logger.exception("Rechnung konnte nicht aus DocuWare geladen werden")
- raise HTTPException(503, "Keine Verbindung zu DocuWare")
- return StreamingResponse(
- filestream,
- media_type="application/pdf",
- )
|