routes.py 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605
  1. import io
  2. import logging
  3. import re
  4. import secrets
  5. from datetime import datetime, timedelta
  6. from decimal import Decimal
  7. from pathlib import Path
  8. from typing import Annotated
  9. from urllib.parse import urlencode
  10. from zoneinfo import ZoneInfo
  11. from zoneinfo import ZoneInfo
  12. from docxtpl import DocxTemplate
  13. from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
  14. from fastapi.responses import (
  15. FileResponse,
  16. HTMLResponse,
  17. JSONResponse,
  18. RedirectResponse,
  19. StreamingResponse,
  20. )
  21. from sqlalchemy import text
  22. from sqlalchemy.orm import Session
  23. from app.file_storage import file_primary_key, get_file, get_files
  24. from app.query_filter import filter_clauses, import_filter_config, parse_filter_date
  25. from .auth import clear_session_cookie, safe_next_url, set_session_cookie
  26. from .comment_submission import submit_comment
  27. from .config import settings
  28. from .dashboard_segment import (
  29. DASHBOARD_VIEWS,
  30. parse_segment,
  31. segment_filters,
  32. )
  33. from .db import get_session
  34. from .documents import router as documents_router
  35. from .docuware_search import get_invoice_pdf_by_document_no
  36. from .forderung_dashboard import STACKS, build_dashboard
  37. from .forderung_data import read_filter_suggestions, read_invoices
  38. from .forderung_history import HistoryScope, history_context, section_context
  39. from .forderung_summary import get_forderung_summary
  40. from .jinja_templates import templates
  41. from .ldap import (
  42. DirectoryUnavailable,
  43. DirectoryUser,
  44. ldap_authenticate,
  45. normalize_username,
  46. )
  47. from .navigation import (
  48. detail_navigation_context,
  49. list_url,
  50. return_url_for_request,
  51. valid_focus,
  52. )
  53. from .oauth_token import create_access_token
  54. from .permissions import (
  55. current_principal,
  56. ensure_forderung_access,
  57. has_forderung_access,
  58. highest_role,
  59. load_entitlements,
  60. )
  61. from .verursacher import router as verursacher_router
  62. from .wiedervorlage import router as wiedervorlage_router
  63. router = APIRouter()
  64. router.include_router(documents_router)
  65. router.include_router(verursacher_router)
  66. router.include_router(wiedervorlage_router)
  67. logger = logging.getLogger(__name__)
  68. @router.get("/", response_class=HTMLResponse)
  69. def index(request: Request):
  70. return RedirectResponse(url="/select")
  71. @router.get("/health")
  72. def health():
  73. return {"status": "ok"}
  74. def _login_response(request: Request, next: str | None, error: str | None = None, status_code: int = 200):
  75. # Keep open login forms valid when another tab loads the login page.
  76. csrf = request.cookies.get(settings.LOGIN_CSRF_COOKIE_NAME, "")
  77. if not re.fullmatch(r"[A-Za-z0-9_-]{43}", csrf):
  78. csrf = secrets.token_urlsafe(32)
  79. response = templates.TemplateResponse(
  80. request,
  81. "base/login.html",
  82. {"request": request, "csrf": csrf, "next": safe_next_url(next), "error": error},
  83. status_code=status_code,
  84. headers={"Cache-Control": "no-store"},
  85. )
  86. response.set_cookie(
  87. settings.LOGIN_CSRF_COOKIE_NAME,
  88. csrf,
  89. secure=settings.COOKIE_SECURE,
  90. httponly=True,
  91. samesite="lax",
  92. path="/login",
  93. )
  94. return response
  95. @router.get("/login", response_class=HTMLResponse)
  96. def login_get(request: Request, next: str | None = None):
  97. if getattr(request.state, "principal", None):
  98. return RedirectResponse(safe_next_url(next), status_code=303)
  99. return _login_response(request, next)
  100. @router.post("/login")
  101. def login_post(
  102. request: Request,
  103. username: Annotated[str, Form()],
  104. password: Annotated[str, Form()],
  105. csrf: Annotated[str, Form(alias="_csrf")] = "",
  106. next: Annotated[str | None, Form()] = None,
  107. db: Session = Depends(get_session),
  108. ):
  109. if getattr(request.state, "principal", None):
  110. return RedirectResponse(safe_next_url(next), status_code=303)
  111. expected_csrf = request.cookies.get(settings.LOGIN_CSRF_COOKIE_NAME, "")
  112. if not expected_csrf or not secrets.compare_digest(expected_csrf, csrf):
  113. return _login_response(
  114. request,
  115. next,
  116. error="Das Anmeldeformular ist nicht mehr gültig. Bitte melden Sie sich erneut an. "
  117. "Falls der Fehler erneut auftritt, prüfen Sie, ob Cookies für diese Website erlaubt sind.",
  118. status_code=status.HTTP_403_FORBIDDEN,
  119. )
  120. try:
  121. if settings.debug_auth_enabled:
  122. user = None
  123. if username and secrets.compare_digest(username.encode("utf-8"), password.encode("utf-8")):
  124. normalized = normalize_username(username)
  125. user = DirectoryUser(
  126. username=normalized,
  127. distinguished_name="",
  128. name=normalized,
  129. email="",
  130. )
  131. else:
  132. user = ldap_authenticate(username, password)
  133. except DirectoryUnavailable:
  134. logger.exception("LDAP-Anmeldedienst nicht verfügbar")
  135. return _login_response(request, next, error="Anmeldedienst ist derzeit nicht verfügbar", status_code=503)
  136. except ValueError:
  137. user = None
  138. if not user:
  139. return _login_response(request, next, error="Anmeldung fehlgeschlagen", status_code=401)
  140. entitlements = load_entitlements(db, user.username)
  141. role = highest_role(entitlements)
  142. token = create_access_token(
  143. username=user.username,
  144. name=user.name,
  145. email=user.email,
  146. role=role,
  147. auth_source="debug" if settings.debug_auth_enabled else "ldap",
  148. )
  149. response = RedirectResponse(url=safe_next_url(next), status_code=303)
  150. set_session_cookie(response, token)
  151. response.delete_cookie(settings.LOGIN_CSRF_COOKIE_NAME, path="/login")
  152. return response
  153. @router.post("/logout")
  154. def logout(request: Request):
  155. request.state.suppress_session_refresh = True
  156. response = templates.TemplateResponse(request, "base/logout.html", {"request": request})
  157. clear_session_cookie(response)
  158. return response
  159. @router.get("/select", response_class=HTMLResponse)
  160. def select_get(request: Request):
  161. return templates.TemplateResponse(request, "base/select.html", {"request": request})
  162. def _list_filter_params(request, config, db, username):
  163. params = {f.name: request.query_params[f.name] for f in config if request.query_params.get(f.name, "") != ""}
  164. for f in config:
  165. if f.filter_type == "date" and f.name in params:
  166. try:
  167. parse_filter_date(params[f.name])
  168. except ValueError as error:
  169. raise HTTPException(422, f"Ungültiges Datum für {f.text}. Erwartet wird JJJJ-MM-TT.") from error
  170. try:
  171. legacy = parse_segment(request.query_params.get("dashboard_segment"))
  172. except ValueError as error:
  173. raise HTTPException(400, "Ungültiger Dashboardlink") from error
  174. names = None
  175. if legacy and legacy["view"] == "Verursacher" and "id" in legacy["key"] and "Verursacher" not in params:
  176. columns, rows = read_invoices(
  177. db, username, ["F.[Verursacher_Benutzer_ID] = :legacy_person"], {"legacy_person": legacy["key"]["id"]}
  178. )
  179. names = list(dict.fromkeys(row[columns.index("Verursacher_Text")] for row in rows))
  180. if not names:
  181. names = [legacy["key"]["id"]]
  182. return {**segment_filters(legacy, names), **params}
  183. @router.get("/app/forderungen/liste", response_class=HTMLResponse)
  184. def forderungen_liste(
  185. request: Request, db: Session = Depends(get_session), limit: int = 100, page: int = 0, focus: str | None = None
  186. ):
  187. principal = current_principal(request)
  188. forderung_filter_config = import_filter_config("forderungen")
  189. params = _list_filter_params(request, forderung_filter_config, db, principal.username)
  190. if not valid_focus(focus):
  191. focus = None
  192. if page == 0:
  193. canonical = list_url(params, focus)
  194. if request.url.path + ("?" + request.url.query if request.url.query else "") != canonical:
  195. return RedirectResponse(url=canonical)
  196. query_clauses, query_values = filter_clauses(forderung_filter_config, params)
  197. for f in forderung_filter_config:
  198. f.current_value = params.get(f.name, f.default_value)
  199. selected_options = {}
  200. if page == 0:
  201. for f in forderung_filter_config:
  202. if f.filter_type == "select" and f.key_column != f.value_column and f.selected_values:
  203. items = read_filter_suggestions(db, principal.username, f, [], {}, selected=f.selected_values)
  204. selected_options[f.name] = {item["value"]: item["label"] for item in items}
  205. col_names, q = read_invoices(db, principal.username, query_clauses, query_values)
  206. filters = {}
  207. for f in forderung_filter_config:
  208. if f.key_column not in col_names:
  209. continue
  210. filter_temp = [
  211. (
  212. row[col_names.index(f.sort_column)] or "",
  213. row[col_names.index(f.key_column)],
  214. row[col_names.index(f.value_column)],
  215. )
  216. for row in q
  217. ]
  218. if filter_temp:
  219. filters[f.name] = {
  220. item[1]: item[2]
  221. for item in sorted(set(filter_temp), key=lambda item: tuple(str(value or "") for value in item))
  222. if item[1]
  223. }
  224. else:
  225. filters[f.name] = {}
  226. f.options = {**selected_options.get(f.name, {}), **filters[f.name]}
  227. summary = {
  228. "Beleg_Offen": sum((Decimal(str(r[col_names.index("Beleg_Offen")] or 0)) for r in q), Decimal(0)),
  229. "Anzahl": len(q),
  230. }
  231. end = (page + 1) * limit
  232. focus_found = False
  233. if page == 0 and focus:
  234. tenant_column, number_column = col_names.index("Client_DB"), col_names.index("Beleg_Nr")
  235. for index, row in enumerate(q):
  236. if f"{row[tenant_column]}_{row[number_column]}" == focus:
  237. end = max(end, (index // limit + 1) * limit)
  238. focus_found = True
  239. break
  240. q_limit = q[page * limit : end]
  241. defaults = {}
  242. for f in forderung_filter_config:
  243. defaults[f.name] = params.get(f.name, f.default_value)
  244. f.current_value = defaults[f.name]
  245. if page > 0 and not q_limit:
  246. return HTMLResponse("")
  247. template = "base/liste.html"
  248. if page > 0:
  249. template = "base/liste_tabelle.html"
  250. return templates.TemplateResponse(
  251. request,
  252. template,
  253. {
  254. "request": request,
  255. "forderungen_liste": q_limit,
  256. "filter": filters,
  257. "defaults": defaults,
  258. "summary": summary,
  259. "page": page,
  260. "limit": limit,
  261. "has_more": end < len(q),
  262. "next_page": end // limit,
  263. "list_url": list_url(params),
  264. "focus": focus if page == 0 else None,
  265. "focus_missing": bool(page == 0 and focus and not focus_found),
  266. "filter_config": forderung_filter_config,
  267. },
  268. headers={"Cache-Control": "no-store", **({"HX-Push-Url": list_url(params, focus)} if page == 0 else {})},
  269. )
  270. @router.get("/app/forderungen/liste/vorschlaege")
  271. def forderungen_vorschlaege(request: Request, field: str, search: str = "", db: Session = Depends(get_session)):
  272. principal = current_principal(request)
  273. config = import_filter_config("forderungen")
  274. target = next((f for f in config if f.name == field and f.filter_type in {"select", "text"}), None)
  275. if target is None:
  276. raise HTTPException(400, "Ungültiges Vorschlagsfeld")
  277. params = _list_filter_params(request, config, db, principal.username)
  278. clauses, values = filter_clauses(config, params, exclude=field)
  279. items = read_filter_suggestions(db, principal.username, target, clauses, values, search)
  280. return JSONResponse({"items": items[:50], "has_more": len(items) > 50}, headers={"Cache-Control": "no-store"})
  281. @router.get("/app/forderungen/details/{primary_key}", response_class=HTMLResponse)
  282. def forderungen_details(request: Request, primary_key: str, db: Session = Depends(get_session)):
  283. principal = current_principal(request)
  284. pkey = convert_primary_key("forderungen", primary_key)
  285. if not has_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"]):
  286. context = get_forderung_summary(db, pkey["Client_DB"], pkey["Beleg_Nr"])
  287. context["return_url"] = return_url_for_request(request, primary_key)
  288. return templates.TemplateResponse(request, "forderungen/details/notice.html", context)
  289. template_context = get_template_context(request, pkey, db)
  290. template_context.update(detail_navigation_context(request, primary_key))
  291. return templates.TemplateResponse(request, "forderungen/details/details.html", template_context)
  292. def get_template_context(request: Request, pkey: dict[str, str], db: Session) -> dict:
  293. template_context = {}
  294. for filename in [
  295. "auftraege_positionen",
  296. "forderungen_details",
  297. "forderungen_mahnungen",
  298. "versicherungen",
  299. ]:
  300. query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", {}).body.decode(
  301. "utf-8"
  302. )
  303. values = {"client_db": pkey["Client_DB"], "beleg_nr": pkey["Beleg_Nr"]}
  304. template_context[filename] = db.execute(
  305. text(query).execution_options(query_name=f"forderungen/details/queries/{filename}.sql"), values
  306. ).fetchall()
  307. for section in ("kommentare", "buchungen"):
  308. template_context.update(section_context(db, pkey, template_context["forderungen_details"][0], section))
  309. try:
  310. template_context["files"] = get_files(pkey)
  311. except OSError:
  312. logger.exception("Dateiliste konnte nicht geladen werden")
  313. template_context["files"] = []
  314. template_context["files_error"] = "Die Dateiliste konnte nicht geladen werden."
  315. template_context["upload_max_mb"] = settings.UPLOAD_MAX_FILE_SIZE_MB
  316. template_context["upload_max_bytes"] = settings.UPLOAD_MAX_FILE_SIZE_MB * 1024 * 1024
  317. template_context["add7days"] = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
  318. return template_context
  319. @router.get("/app/forderungen/details/{primary_key}/kommentare", response_class=HTMLResponse)
  320. def forderungen_kommentare(
  321. request: Request, primary_key: str, scope: HistoryScope = "invoice", db: Session = Depends(get_session)
  322. ):
  323. pkey = convert_primary_key("forderungen", primary_key)
  324. ensure_forderung_access(db, current_principal(request), pkey["Client_DB"], pkey["Beleg_Nr"])
  325. context = history_context(db, pkey, "kommentare", scope)
  326. return templates.TemplateResponse(request, "forderungen/details/details_kommentare.html", context)
  327. @router.get("/app/forderungen/details/{primary_key}/buchungen", response_class=HTMLResponse)
  328. def forderungen_buchungen(
  329. request: Request, primary_key: str, scope: HistoryScope = "invoice", db: Session = Depends(get_session)
  330. ):
  331. pkey = convert_primary_key("forderungen", primary_key)
  332. ensure_forderung_access(db, current_principal(request), pkey["Client_DB"], pkey["Beleg_Nr"])
  333. context = history_context(db, pkey, "buchungen", scope)
  334. return templates.TemplateResponse(request, "forderungen/details/details_buchungen.html", context)
  335. @router.post("/app/forderungen/details/{primary_key}", response_class=HTMLResponse)
  336. async def post_forderungen_details(
  337. request: Request,
  338. primary_key: str,
  339. source: Annotated[str, Form()],
  340. redirect: Annotated[str | None, Form()] = None,
  341. return_to: Annotated[str | None, Form()] = None,
  342. comment_scope: Annotated[HistoryScope, Form()] = "invoice",
  343. db: Session = Depends(get_session),
  344. ):
  345. principal = current_principal(request)
  346. pkey = convert_primary_key("forderungen", primary_key)
  347. ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
  348. if source == "comments":
  349. return await submit_comment(request, pkey, db, comment_scope)
  350. if source != "details":
  351. raise HTTPException(status_code=400, detail="Ungültige Datenquelle")
  352. data = {
  353. "Client_DB": "",
  354. "Beleg_Nr": "",
  355. "Bearbeitet": "J",
  356. "Versicherung": "N",
  357. "Rechtsanwalt": "N",
  358. "Reklamation": "N",
  359. "Mahnen_aussetzen": "N",
  360. "Selbstbeteiligung": "",
  361. "Selbstbeteiligung_Betrag": "0.0",
  362. "Mwst": "",
  363. "Mwst_Betrag": "0.0",
  364. "Wiedervorlage": "",
  365. "Vers_Adresse_ID": "",
  366. "Versicherung_Typ": "",
  367. "Schadennummer": "",
  368. "Schaden_Details": "",
  369. "Reklamation_Begruendung": "",
  370. "Rechtsanwalt_Begruendung": "",
  371. "Rechtsanwalt_Aktenzeichen": "",
  372. "Rechtsanwalt_Stand": "",
  373. "Mahnen_Begruendung": "",
  374. }
  375. data.update(pkey)
  376. async with request.form() as form:
  377. for k, v in form.items():
  378. if k == "Versicherung_Schadennummer":
  379. k = "Schadennummer"
  380. if k in data and k not in {"Client_DB", "Beleg_Nr", "Benutzer_ID", "Timestamp"}:
  381. if v == "on":
  382. v = "J"
  383. if k in {"Selbstbeteiligung_Betrag", "Mwst_Betrag"}:
  384. v = v.replace(",", ".")
  385. data[k] = v
  386. try:
  387. data["Wiedervorlage"] = parse_filter_date(data["Wiedervorlage"]) if data["Wiedervorlage"] else None
  388. except ValueError as error:
  389. raise HTTPException(422, "Bitte ein gültiges Wiedervorlagedatum auswählen.") from error
  390. # Set audit values after reading the form so clients cannot override them.
  391. # SQL Server datetime stores local wall time without a timezone offset.
  392. data.update(
  393. Bearbeitung_Benutzer_ID=principal.username,
  394. Bearbeitung_Timestamp=datetime.now(ZoneInfo("Europe/Berlin")).replace(tzinfo=None),
  395. )
  396. # Set audit values after reading the form so clients cannot override them.
  397. # SQL Server datetime stores local wall time without a timezone offset.
  398. data.update(
  399. Bearbeitung_Benutzer_ID=principal.username,
  400. Bearbeitung_Timestamp=datetime.now(ZoneInfo("Europe/Berlin")).replace(tzinfo=None),
  401. )
  402. if source not in {"comments", "details"}:
  403. raise HTTPException(status_code=400, detail="Ungültige Datenquelle")
  404. query = templates.TemplateResponse(
  405. request, f"forderungen/details/queries/post/post_{source}.sql", context={"data": data}
  406. ).body.decode("utf-8")
  407. for subquery in query.split(";"):
  408. if subquery.strip():
  409. db.execute(
  410. text(subquery).execution_options(query_name=f"forderungen/details/queries/post/post_{source}.sql"), data
  411. )
  412. db.commit()
  413. return_url = return_url_for_request(request, primary_key, return_to if return_to is not None else redirect)
  414. if redirect:
  415. if request.headers.get("HX-Request", "").lower() == "true":
  416. return HTMLResponse("", headers={"HX-Redirect": return_url})
  417. return RedirectResponse(url=return_url, status_code=303)
  418. template_context = get_template_context(request, pkey, db)
  419. template_context.update(detail_navigation_context(request, primary_key, return_url))
  420. return templates.TemplateResponse(request, "forderungen/details/details_formular.html", template_context)
  421. def convert_primary_key(area: str, primary_key: str) -> dict[str, str]:
  422. if area != "forderungen" or "_" not in primary_key:
  423. raise HTTPException(status_code=400, detail="Ungültiger Primärschlüssel")
  424. client_db, beleg_nr = primary_key.split("_", 1)
  425. if not client_db or not beleg_nr or len(client_db) > 20 or len(beleg_nr) > 100:
  426. raise HTTPException(status_code=400, detail="Ungültiger Primärschlüssel")
  427. return {"Client_DB": client_db, "Beleg_Nr": beleg_nr}
  428. @router.get("/app/forderungen/dashboard", response_class=HTMLResponse)
  429. def forderungen_dashboard(
  430. request: Request,
  431. db: Session = Depends(get_session),
  432. page: str = "Standort",
  433. metric: str = "betrag",
  434. only_invoices: bool = False,
  435. stack: str = "abteilung",
  436. ):
  437. principal = current_principal(request)
  438. if page == "Wiedervorlage" and metric in {"betrag", "anzahl"} and stack in STACKS:
  439. params = dict(page="Standort", metric=metric, stack="wiedervorlage")
  440. if only_invoices:
  441. params["only_invoices"] = "true"
  442. return RedirectResponse("/app/forderungen/dashboard?" + urlencode(params), status_code=303)
  443. if page not in DASHBOARD_VIEWS or metric not in {"betrag", "anzahl"} or stack not in STACKS:
  444. raise HTTPException(422, "Ungültige Dashboardansicht")
  445. context = dict(
  446. summary=False,
  447. dashboard_view=page,
  448. dashboard_metric=metric,
  449. dashboard_stack=stack,
  450. dashboard_only_invoices=only_invoices,
  451. dashboard=None,
  452. dashboard_error=None,
  453. )
  454. status_code = 200
  455. try:
  456. context["dashboard"] = build_dashboard(db, principal.username, only_invoices=only_invoices, stack=stack)
  457. except Exception:
  458. logger.exception("Forderungsdashboard konnte nicht geladen werden")
  459. context["dashboard_error"] = "Das Dashboard konnte nicht geladen werden. Bitte erneut versuchen."
  460. status_code = 503
  461. return templates.TemplateResponse(
  462. request,
  463. "forderungen/dashboard/dashboard.html",
  464. context,
  465. status_code=status_code,
  466. headers={"Cache-Control": "no-store"},
  467. )
  468. # TODO
  469. @router.get("/app/forderungen/export/{client_db}_{document_no}/")
  470. def export_docx2(request: Request, client_db: str, document_no: str, db: Session = Depends(get_session)):
  471. principal = current_principal(request)
  472. ensure_forderung_access(db, principal, client_db, document_no)
  473. q = (
  474. db.execute(
  475. text("""SELECT TOP 1 F.*, K.Kunde_Name, K.Kunde_Adresse, K.Kunde_PLZ, K.Kunde_Ort
  476. FROM dbo.Forderungen_Kopf AS F
  477. LEFT JOIN dbo.Kunden AS K ON K.Client_DB = F.Client_DB AND K.Kunde_Nr = F.Kunde_Nr
  478. WHERE F.Client_DB = :client_db AND F.Beleg_Nr = :beleg_nr"""),
  479. {"client_db": client_db, "beleg_nr": document_no},
  480. )
  481. .mappings()
  482. .first()
  483. )
  484. if not q or not settings.LOCAL_STORAGE:
  485. raise HTTPException(status_code=503, detail="Dokumentablage ist nicht konfiguriert")
  486. doc = DocxTemplate("templates\\forderungen\\details\\docs\\Mahnung_AHR.docx")
  487. storage_root = Path(settings.LOCAL_STORAGE).resolve()
  488. filename = (storage_root / client_db / document_no / f"Mahnung_{client_db}_{document_no}.docx").resolve()
  489. if storage_root not in filename.parents:
  490. raise HTTPException(status_code=400, detail="Ungültiger Dokumentpfad")
  491. filename.parent.mkdir(parents=True, exist_ok=True)
  492. context = {
  493. "Kunde_Name": q["Kunde_Name"] or "",
  494. "Kunde_Adresse": q["Kunde_Adresse"] or "",
  495. "Kunde_PLZ": q["Kunde_PLZ"] or "",
  496. "Kunde_Ort": q["Kunde_Ort"] or "",
  497. "Datum_heute": datetime.now().strftime("%d.%m.%Y"),
  498. "Kunde_Nr": q["Kunde_Nr"] or "",
  499. "Fahrzeug_Kennzeichen": q.get("Fahrzeug_Kennzeichen", "") or "",
  500. "Rechnung_Nr": q["Beleg_Nr"],
  501. "Betrag_SB": q.get("Selbstbeteiligung_Betrag", "") or "",
  502. "Betrag_USt": q.get("Mwst_Betrag", "") or "",
  503. }
  504. doc.render(context)
  505. doc.save(filename)
  506. return FileResponse(filename, media_type="application/octet-stream", filename=filename.name)
  507. @router.get("/files/")
  508. def get_files2(request: Request, db: Session = Depends(get_session)):
  509. principal = current_principal(request)
  510. name = request.query_params.get("name", "")
  511. try:
  512. pkey = file_primary_key(name)
  513. except FileNotFoundError:
  514. raise HTTPException(status_code=404, detail="Datei nicht gefunden")
  515. ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
  516. try:
  517. filename = get_file(name)
  518. except FileNotFoundError:
  519. raise HTTPException(status_code=404, detail="Datei nicht gefunden")
  520. return FileResponse(filename, media_type="application/octet-stream", filename=filename.name)
  521. @router.get("/app/forderungen/files/{primary_key}", response_class=StreamingResponse)
  522. def forderungen_files(request: Request, primary_key: str, db: Session = Depends(get_session)):
  523. principal = current_principal(request)
  524. pkey = convert_primary_key("forderungen", primary_key)
  525. ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
  526. try:
  527. file_content = get_invoice_pdf_by_document_no(client_db=pkey["Client_DB"], document_no=pkey["Beleg_Nr"])
  528. filestream = io.BytesIO(file_content)
  529. except FileNotFoundError:
  530. raise HTTPException(404, f"Keine Dokumente für Beleg {pkey['Beleg_Nr']} gefunden")
  531. except Exception:
  532. logger.exception("Rechnung konnte nicht aus DocuWare geladen werden")
  533. raise HTTPException(503, "Keine Verbindung zu DocuWare")
  534. return StreamingResponse(
  535. filestream,
  536. media_type="application/pdf",
  537. )