|
|
@@ -1,15 +1,15 @@
|
|
|
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 unquote, urlencode
|
|
|
|
|
|
-import pandas as pd
|
|
|
-import requests
|
|
|
-from docx import Document
|
|
|
from docxtpl import DocxTemplate
|
|
|
-from fastapi import APIRouter, Depends, Form, HTTPException, Request, Response
|
|
|
+from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
|
|
|
from fastapi.responses import (
|
|
|
FileResponse,
|
|
|
HTMLResponse,
|
|
|
@@ -19,50 +19,170 @@ from fastapi.responses import (
|
|
|
from sqlalchemy import text
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
|
|
-from app.file_storage import get_file, get_files
|
|
|
-from app.query_filter import filter_type_option, import_filter_config
|
|
|
-
|
|
|
+from app.file_storage import file_primary_key, 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 .comment_submission import submit_comment
|
|
|
+from .config import settings
|
|
|
+from .dashboard_segment import (
|
|
|
+ DASHBOARD_VIEWS,
|
|
|
+ pack_segment,
|
|
|
+ parse_segment,
|
|
|
+ segment_label,
|
|
|
+ segment_sql,
|
|
|
+)
|
|
|
from .db import get_session
|
|
|
from .docuware_search import get_invoice_pdf_by_document_no
|
|
|
+from .forderung_dashboard import STACKS, build_dashboard
|
|
|
+from .forderung_data import 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 ldap_authenticate
|
|
|
-from .models import Forderung
|
|
|
+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(verursacher_router)
|
|
|
+router.include_router(wiedervorlage_router)
|
|
|
+logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
@router.get("/", response_class=HTMLResponse)
|
|
|
def index(request: Request):
|
|
|
- return RedirectResponse(url="/login")
|
|
|
+ return RedirectResponse(url="/select")
|
|
|
|
|
|
|
|
|
-@router.get("/login", response_class=HTMLResponse)
|
|
|
-def login_get(request: Request):
|
|
|
- return templates.TemplateResponse(request, "base/login.html", {"request": request})
|
|
|
+@router.get("/health")
|
|
|
+def health():
|
|
|
+ return {"status": "ok"}
|
|
|
|
|
|
|
|
|
-@router.get("/select", response_class=HTMLResponse)
|
|
|
-def select_get(request: Request):
|
|
|
- return templates.TemplateResponse(request, "base/select.html", {"request": request})
|
|
|
+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(username: str = Form(...), password: str = Form(...)):
|
|
|
- user = ldap_authenticate(username, password)
|
|
|
+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:
|
|
|
- raise HTTPException(status_code=401, detail="Invalid credentials")
|
|
|
- # For a simple demo we set a cookie (not secure) -- replace with real session in production
|
|
|
- response = RedirectResponse(url="/forderungen", status_code=302)
|
|
|
- response.set_cookie("user", user["username"])
|
|
|
+ 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
|
|
|
|
|
|
|
|
|
-def single_quote(text: str):
|
|
|
- return "'" + unquote(text) + "'"
|
|
|
+@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):
|
|
|
+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 = {
|
|
|
@@ -70,29 +190,39 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
|
|
|
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))
|
|
|
-
|
|
|
- context = {}
|
|
|
+ try:
|
|
|
+ selection = parse_segment(request.query_params.get("dashboard_segment"))
|
|
|
+ except ValueError as error:
|
|
|
+ raise HTTPException(400, "Ungültiger Dashboardfilter") from error
|
|
|
+ if selection:
|
|
|
+ params["dashboard_segment"] = pack_segment(selection)
|
|
|
+ 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 = {"auth_username": principal.username}
|
|
|
for f in forderung_filter_config:
|
|
|
- context[f.name] = {filter_type_option[f.filter_type]: single_quote(params.get(f.name, f.default_value))}
|
|
|
- if f.name in params:
|
|
|
- f.current_value = params[f.name]
|
|
|
+ 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", context).body.decode(
|
|
|
- "utf-8"
|
|
|
- )
|
|
|
- query_params = [
|
|
|
- f.query_param for f in forderung_filter_config if f.query_param is not None and f.filter_type != "hidden"
|
|
|
- ]
|
|
|
- if query_params:
|
|
|
- query = query.replace("1 = 1", " AND ".join(query_params))
|
|
|
- print(query)
|
|
|
- print(query_params)
|
|
|
- # q = db.execute(text("SELECT * FROM [dbo].[Forderungen]"))
|
|
|
- q_res = db.execute(text(query))
|
|
|
- col_names = list(q_res.keys())
|
|
|
- q = q_res.fetchall()
|
|
|
+ if selection:
|
|
|
+ clauses, values = segment_sql(selection)
|
|
|
+ query_clauses.extend(clauses)
|
|
|
+ query_values.update(values)
|
|
|
+ col_names, q = read_invoices(db, principal.username, query_clauses, query_values)
|
|
|
|
|
|
filters = {}
|
|
|
for f in forderung_filter_config:
|
|
|
@@ -107,27 +237,38 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
|
|
|
for row in q
|
|
|
]
|
|
|
if filter_temp:
|
|
|
- print(filter_temp[0])
|
|
|
- filters[f.name] = {item[1]: item[2] for item in sorted(list(set(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:
|
|
|
- print(f"Filter {f.name} has no options, skipping")
|
|
|
filters[f.name] = {}
|
|
|
f.options = filters[f.name]
|
|
|
|
|
|
summary = {
|
|
|
- "Beleg_offen": sum([r[col_names.index("Beleg_offen")] for r in q]),
|
|
|
+ "Beleg_Offen": sum((Decimal(str(r[col_names.index("Beleg_Offen")] or 0)) for r in q), Decimal(0)),
|
|
|
"Anzahl": len(q),
|
|
|
}
|
|
|
|
|
|
- q_limit = q[page * limit : (page + 1) * limit]
|
|
|
+ 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] = unquote(request.query_params.get(f.name, f.default_value))
|
|
|
f.current_value = defaults[f.name]
|
|
|
|
|
|
- if len(q_limit) == 0:
|
|
|
- return None
|
|
|
+ if page > 0 and not q_limit:
|
|
|
+ return HTMLResponse("")
|
|
|
|
|
|
template = "base/liste.html"
|
|
|
if page > 0:
|
|
|
@@ -143,246 +284,248 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
|
|
|
"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,
|
|
|
+ "dashboard_segment": params.get("dashboard_segment"),
|
|
|
+ "dashboard_segment_label": (
|
|
|
+ segment_label(selection, [dict(zip(col_names, q[0]))] if q else []) if selection else None
|
|
|
+ ),
|
|
|
+ "without_dashboard_segment": list_url(
|
|
|
+ {key: value for key, value in params.items() if key != "dashboard_segment"}
|
|
|
+ ),
|
|
|
},
|
|
|
+ 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:
|
|
|
- context = {
|
|
|
- "appsmith": {
|
|
|
- "URL": {
|
|
|
- "queryParams": {
|
|
|
- "Client_DB": "'" + pkey["Client_DB"] + "'",
|
|
|
- "Beleg_Nr": "'" + pkey["Beleg_Nr"] + "'",
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- "BelegeFilter": {"selectedOptionValue": "D"},
|
|
|
- "BenutzerSelect": {"selectedOptionValue": "winter"},
|
|
|
- }
|
|
|
-
|
|
|
template_context = {}
|
|
|
for filename in [
|
|
|
"auftraege_positionen",
|
|
|
- "forderungen_buchungen",
|
|
|
- "forderungen_kommentare",
|
|
|
"forderungen_details",
|
|
|
"forderungen_mahnungen",
|
|
|
"versicherungen",
|
|
|
]:
|
|
|
- query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", context).body.decode(
|
|
|
+ query = templates.TemplateResponse(request, f"forderungen/details/queries/{filename}.sql", {}).body.decode(
|
|
|
"utf-8"
|
|
|
)
|
|
|
- template_context[filename] = db.execute(text(query)).fetchall()
|
|
|
- template_context["forderung"] = {
|
|
|
- "id": "12345",
|
|
|
- "rechnungsnummer": "WERE123445",
|
|
|
- "kunde": "Burghard",
|
|
|
- "betrag": "120,00",
|
|
|
- "faelligkeit": "23.12.1983",
|
|
|
- }
|
|
|
- template_context["files"] = get_files(pkey)
|
|
|
+ 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":
|
|
|
- data = {
|
|
|
- "Client_DB": "",
|
|
|
- "Beleg_Nr": "",
|
|
|
- "Timestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
|
|
|
- "Benutzer_ID": "winter",
|
|
|
- "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": "",
|
|
|
- }
|
|
|
+ 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": "",
|
|
|
+ "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:
|
|
|
+ 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")
|
|
|
- print(query)
|
|
|
for subquery in query.split(";"):
|
|
|
- q = db.execute(text(subquery))
|
|
|
- print(q.rowcount)
|
|
|
+ if subquery.strip():
|
|
|
+ db.execute(
|
|
|
+ text(subquery).execution_options(query_name=f"forderungen/details/queries/post/post_{source}.sql"), data
|
|
|
+ )
|
|
|
db.commit()
|
|
|
- template_context = get_template_context(request, pkey, db)
|
|
|
|
|
|
+ return_url = return_url_for_request(request, primary_key, return_to if return_to is not None else redirect)
|
|
|
if redirect:
|
|
|
- return RedirectResponse(url=redirect, status_code=302)
|
|
|
- if source == "comments":
|
|
|
- return templates.TemplateResponse(request, "base/chat_container.html", template_context)
|
|
|
+ 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":
|
|
|
- pkey = ["Client_DB", "Beleg_Nr"]
|
|
|
- pkey_values = primary_key.split("_")
|
|
|
- return dict(zip(pkey, pkey_values))
|
|
|
+ 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)):
|
|
|
- context = {"summary": False}
|
|
|
- return templates.TemplateResponse(request, "forderungen/dashboard/dashboard.html", context)
|
|
|
-
|
|
|
-
|
|
|
-@router.get("/export/csv")
|
|
|
-def export_csv(db: Session = Depends(get_session)):
|
|
|
- q = db.query(Forderung).all()
|
|
|
- rows = []
|
|
|
- for f in q:
|
|
|
- rows.append(
|
|
|
- {
|
|
|
- "id": f.id,
|
|
|
- "rechnungsnummer": f.rechnungsnummer,
|
|
|
- "kunde": f.kunde.name if f.kunde else "",
|
|
|
- "betrag": float(f.betrag),
|
|
|
- "faelligkeit": f.faelligkeit.isoformat() if f.faelligkeit else "",
|
|
|
- }
|
|
|
- )
|
|
|
- df = pd.DataFrame(rows)
|
|
|
- buf = io.StringIO()
|
|
|
- df.to_csv(buf, index=False)
|
|
|
- buf.seek(0)
|
|
|
- return Response(
|
|
|
- content=buf.getvalue(),
|
|
|
- media_type="text/csv",
|
|
|
- headers={"Content-Disposition": "attachment; filename=forderungen.csv"},
|
|
|
- )
|
|
|
-
|
|
|
-
|
|
|
-@router.get("/export/xlsx")
|
|
|
-def export_xlsx(db: Session = Depends(get_session)):
|
|
|
- q = db.query(Forderung).all()
|
|
|
- rows = []
|
|
|
- for f in q:
|
|
|
- rows.append(
|
|
|
- {
|
|
|
- "id": f.id,
|
|
|
- "rechnungsnummer": f.rechnungsnummer,
|
|
|
- "kunde": f.kunde.name if f.kunde else "",
|
|
|
- "betrag": float(f.betrag),
|
|
|
- "faelligkeit": f.faelligkeit.isoformat() if f.faelligkeit else "",
|
|
|
- }
|
|
|
- )
|
|
|
- df = pd.DataFrame(rows)
|
|
|
- buf = io.BytesIO()
|
|
|
- with pd.ExcelWriter(buf, engine="openpyxl") as writer:
|
|
|
- df.to_excel(writer, index=False, sheet_name="Forderungen")
|
|
|
- buf.seek(0)
|
|
|
- return StreamingResponse(
|
|
|
- buf,
|
|
|
- media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
|
|
- headers={"Content-Disposition": "attachment; filename=forderungen.xlsx"},
|
|
|
+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,
|
|
|
)
|
|
|
-
|
|
|
-
|
|
|
-@router.get("/detail/{id}/export/docx")
|
|
|
-def export_docx(id: int, db: Session = Depends(get_session)):
|
|
|
- f = db.query(Forderung).filter(Forderung.id == id).first()
|
|
|
- if not f:
|
|
|
- raise HTTPException(status_code=404)
|
|
|
- doc = Document()
|
|
|
- doc.add_heading(f"Rechnung {f.rechnungsnummer}", level=1)
|
|
|
- doc.add_paragraph(f'Kunde: {f.kunde.name if f.kunde else ""}')
|
|
|
- doc.add_paragraph(f"Betrag: {float(f.betrag)}")
|
|
|
- doc.add_paragraph(f"Fälligkeit: {f.faelligkeit}")
|
|
|
- buf = io.BytesIO()
|
|
|
- doc.save(buf)
|
|
|
- buf.seek(0)
|
|
|
- return StreamingResponse(
|
|
|
- buf,
|
|
|
- media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
|
|
- headers={"Content-Disposition": f"attachment; filename=rechnung_{f.rechnungsnummer}.docx"},
|
|
|
+ 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)):
|
|
|
- context = {
|
|
|
- "appsmith": {
|
|
|
- "URL": {
|
|
|
- "queryParams": {
|
|
|
- "Client_DB": "'" + client_db + "'",
|
|
|
- "Document_No": "'" + document_no + "'",
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- }
|
|
|
- query = templates.TemplateResponse(request, "forderungen/details/queries/forderung_kopf.sql", context).body.decode(
|
|
|
- "utf-8"
|
|
|
- )
|
|
|
- q = db.execute(text(query)).fetchone()
|
|
|
-
|
|
|
- doc = DocxTemplate("templates\\forderungen\\docs\\Mahnung_AHR.docx")
|
|
|
- filename = Path(
|
|
|
- f"C:\\Projekte\\Reisacher-Fileserver\\{client_db}\\{document_no}\\Mahnung_{client_db}_{document_no}.docx"
|
|
|
+ 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,
|
|
|
- "Kunde_Adresse": "Im Waldhof 14a",
|
|
|
- "Kunde_PLZ": "61476",
|
|
|
- "Kunde_Ort": "Kronberg",
|
|
|
+ "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.split("-")[-1].strip(),
|
|
|
- "Fahrzeug_Kennzeichen": "OF-RB 512",
|
|
|
- "Rechnung_Nr": q.Document_No,
|
|
|
- "Betrag_SB": "250,00",
|
|
|
- "Betrag_USt": "380,00",
|
|
|
+ "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)
|
|
|
@@ -391,21 +534,34 @@ def export_docx2(request: Request, client_db: str, document_no: str, db: Session
|
|
|
|
|
|
|
|
|
@router.get("/files/")
|
|
|
-def get_files2(request: Request):
|
|
|
- filename = get_file(request.query_params.get("name"))
|
|
|
+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=HTMLResponse)
|
|
|
+@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:
|
|
|
- filestream = get_invoice_pdf_by_document_no(client_db=pkey["Client_DB"], document_no=pkey["Beleg_Nr"])
|
|
|
- # filename = "http://localhost:8093/static/assets/pdf/invoice.pdf"
|
|
|
- # filestream = requests.get(filename, stream=True).raw,
|
|
|
- return StreamingResponse(
|
|
|
- filestream,
|
|
|
- media_type="application/pdf",
|
|
|
- )
|
|
|
- except ValueError as e:
|
|
|
- raise HTTPException(status_code=404, detail=str(e))
|
|
|
+ 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",
|
|
|
+ )
|