| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458 |
- import io
- import logging
- import re
- import secrets
- from datetime import datetime, timedelta
- from pathlib import Path
- from typing import Annotated
- from urllib.parse import unquote, urlencode
- from docxtpl import DocxTemplate
- from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
- from fastapi.responses import (
- FileResponse,
- HTMLResponse,
- RedirectResponse,
- StreamingResponse,
- )
- from sqlalchemy import text
- from sqlalchemy.orm import Session
- from app.file_storage import get_file, get_files
- from app.query_filter import import_filter_config
- from .auth import clear_session_cookie, safe_next_url, set_session_cookie
- from .config import settings
- from .db import get_session
- from .docuware_search import get_invoice_pdf_by_document_no
- 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 .oauth_token import create_access_token
- from .permissions import (
- current_principal,
- ensure_forderung_access,
- highest_role,
- has_forderung_access,
- load_entitlements,
- )
- router = APIRouter()
- 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})
- @router.get("/app/forderungen/liste", response_class=HTMLResponse)
- def forderungen_liste(request: Request, db: Session = Depends(get_session), limit: int = 100, page: int = 0):
- principal = current_principal(request)
- forderung_filter_config = import_filter_config("forderungen")
- params = {
- f.name: request.query_params[f.name]
- for f in forderung_filter_config
- if request.query_params.get(f.name, "") != ""
- }
- if page == 0 and len(params) < len(request.query_params):
- return RedirectResponse(url="/app/forderungen/liste?" + urlencode(params))
- query_clauses = []
- query_values = {"auth_username": principal.username}
- for f in forderung_filter_config:
- f.current_value = unquote(params.get(f.name, f.default_value))
- if f.filter_type == "hidden" or not f.current_value:
- continue
- parameter = f"filter_{f.name.lower()}"
- if f.filter_type == "date":
- operator = "<=" if "bis" in f.name.lower() else ">="
- query_clauses.append(f"F.[{f.key_column}] {operator} :{parameter}")
- query_values[parameter] = f.current_value
- else:
- query_clauses.append(f"F.[{f.key_column}] LIKE :{parameter}")
- query_values[parameter] = f"%{f.current_value}%"
- query = templates.TemplateResponse(request, "forderungen/liste/queries/forderungen_liste.sql", {}).body.decode(
- "utf-8"
- )
- if query_clauses:
- query = query.replace("AND 1 = 1", "AND 1 = 1 AND " + " AND ".join(query_clauses))
- q_res = db.execute(text(query), query_values)
- col_names = list(q_res.keys())
- q = q_res.fetchall()
- 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(list(set(filter_temp))) if item[1]}
- else:
- filters[f.name] = {}
- f.options = filters[f.name]
- summary = {
- "Beleg_offen": sum([r[col_names.index("Beleg_offen")] for r in q]),
- "Anzahl": len(q),
- }
- q_limit = q[page * limit : (page + 1) * limit]
- defaults = {}
- for f in forderung_filter_config:
- defaults[f.name] = unquote(request.query_params.get(f.name, f.default_value))
- f.current_value = defaults[f.name]
- if len(q_limit) == 0:
- return None
- 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,
- "filter_config": forderung_filter_config,
- },
- )
- @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"])
- return templates.TemplateResponse(request, "forderungen/details/notice.html", context)
- template_context = get_template_context(request, pkey, db)
- 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), values).fetchall()
- for section in ("kommentare", "buchungen"):
- template_context.update(section_context(db, pkey, template_context["forderungen_details"][0], section))
- template_context["files"] = get_files(pkey)
- 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,
- comment_scope: Annotated[HistoryScope, Form()] = "invoice",
- db: Session = Depends(get_session),
- ):
- principal = current_principal(request)
- pkey = convert_primary_key("forderungen", primary_key)
- ensure_forderung_access(db, principal, pkey["Client_DB"], pkey["Beleg_Nr"])
- if source == "comments":
- data = {
- "Client_DB": "",
- "Beleg_Nr": "",
- "Timestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
- "Benutzer_ID": principal.username,
- "Kommentar": "",
- }
- else:
- data = {
- "Client_DB": "",
- "Beleg_Nr": "",
- "Bearbeitet": "J",
- "Versicherung": "N",
- "Rechtsanwalt": "N",
- "Reklamation": "N",
- "Mahnen_aussetzen": "N",
- "Selbstbeteiligung": "",
- "Selbstbeteiligung_Betrag": "0.0",
- "Mwst": "",
- "Mwst_Betrag": "0.0",
- "Wiedervorlage": "",
- "Vers_Adresse_ID": "",
- "Versicherung_Typ": "",
- "Reklamation_Begruendung": "",
- "Rechtsanwalt_Begruendung": "",
- "Rechtsanwalt_Aktenzeichen": "",
- "Rechtsanwalt_Stand": "",
- "Mahnen_Begruendung": "",
- }
- data.update(pkey)
- async with request.form() as form:
- for k, v in form.items():
- if k in data and k not in {"Client_DB", "Beleg_Nr", "Benutzer_ID", "Timestamp"}:
- if v == "on":
- v = "J"
- if re.match(r"\d+,?\d*", v):
- v = v.replace(",", ".")
- data[k] = v
- if source not in {"comments", "details"}:
- raise HTTPException(status_code=400, detail="Ungültige Datenquelle")
- query = templates.TemplateResponse(
- request, f"forderungen/details/queries/post/post_{source}.sql", context={"data": data}
- ).body.decode("utf-8")
- for subquery in query.split(";"):
- if subquery.strip():
- db.execute(text(subquery), data)
- db.commit()
- if redirect:
- return RedirectResponse(url=redirect, status_code=302)
- if source == "comments":
- context = history_context(db, pkey, "kommentare", comment_scope)
- return templates.TemplateResponse(request, "forderungen/details/details_kommentare.html", context)
- template_context = get_template_context(request, pkey, db)
- 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)):
- current_principal(request)
- context = {"summary": False}
- return templates.TemplateResponse(request, "forderungen/dashboard/dashboard.html", context)
- # 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", "")
- parts = Path(unquote(name)).parts
- if len(parts) < 3:
- raise HTTPException(status_code=404, detail="Datei nicht gefunden")
- ensure_forderung_access(db, principal, parts[0], parts[1])
- 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 Exception:
- logger.exception("Rechnung konnte nicht aus DocuWare geladen werden")
- filestream = io.BytesIO(Path("static/assets/pdf/invoice.pdf").read_bytes())
- return StreamingResponse(
- filestream,
- media_type="application/pdf",
- )
|