Przeglądaj źródła

Füge Unterstützung für Forderungsdetails hinzu und verbessere Berechtigungsprüfung

gc-server3 1 miesiąc temu
rodzic
commit
1ad0ad9bdc

+ 28 - 0
app/forderung_summary.py

@@ -0,0 +1,28 @@
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+
+CURRENT_SUMMARY_SQL = text("""
+    SELECT TOP 1 Beleg_Nr, Beleg_Datum, Kunde_Text, Beleg_Betrag, Beleg_offen
+    FROM dbo.Forderungen_Kopf
+    WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+    """)
+
+HISTORY_SUMMARY_SQL = text("""
+    SELECT TOP 1 Beleg_Nr, Beleg_Datum, Auszifferung_Datum
+    FROM dbo.Forderungen_Historie
+    WHERE Client_DB = :client_db AND Beleg_Nr = :beleg_nr
+    ORDER BY Auszifferung_Datum DESC, Beleg_Datum DESC
+    """)
+
+
+def get_forderung_summary(db: Session, client_db: str, beleg_nr: str) -> dict:
+    """Explicitly permitted minimal information, independent of the detail scope."""
+    params = {"client_db": client_db, "beleg_nr": beleg_nr}
+    current = db.execute(CURRENT_SUMMARY_SQL, params).mappings().first()
+    if current is not None:
+        return {"kind": "open", "forderung": dict(current)}
+    historical = db.execute(HISTORY_SUMMARY_SQL, params).mappings().first()
+    if historical is not None:
+        return {"kind": "settled", "forderung": dict(historical)}
+    return {"kind": "missing", "forderung": None}

+ 7 - 4
app/permissions.py

@@ -73,12 +73,15 @@ FORDERUNG_ACCESS_SQL = text("""
     """)
 
 
-def ensure_forderung_access(db: Session, principal: Principal, client_db: str, beleg_nr: str) -> None:
-    allowed = db.execute(
+def has_forderung_access(db: Session, principal: Principal, client_db: str, beleg_nr: str) -> bool:
+    return db.execute(
         FORDERUNG_ACCESS_SQL,
         {"client_db": client_db, "beleg_nr": beleg_nr, "auth_username": principal.username},
-    ).first()
-    if not allowed:
+    ).first() is not None
+
+
+def ensure_forderung_access(db: Session, principal: Principal, client_db: str, beleg_nr: str) -> None:
+    if not has_forderung_access(db, principal, client_db, beleg_nr):
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Forderung nicht gefunden")
 
 

+ 5 - 1
app/routes.py

@@ -25,6 +25,7 @@ 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_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
@@ -32,6 +33,7 @@ from .permissions import (
     current_principal,
     ensure_forderung_access,
     highest_role,
+    has_forderung_access,
     load_entitlements,
 )
 
@@ -248,7 +250,9 @@ def forderungen_liste(request: Request, db: Session = Depends(get_session), limi
 def forderungen_details(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"])
+    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)
 

+ 22 - 0
templates/forderungen/details/notice.html

@@ -0,0 +1,22 @@
+{% extends "base/base.html" %}
+{% block content %}
+<section class="gc-card p-4 my-4" aria-labelledby="forderung-hinweis">
+  <h2 id="forderung-hinweis">Forderungsinformation</h2>
+  {% if kind == 'open' %}
+  <p>Forderung {{ forderung.Beleg_Nr }} vom {{ forderung.Beleg_Datum|date_format if forderung.Beleg_Datum is not none else 'nicht hinterlegt' }} ist noch offen.</p>
+  <dl class="row">
+    <dt class="col-sm-4">Kunde</dt>
+    <dd class="col-sm-8">{{ forderung.Kunde_Text or 'nicht hinterlegt' }}</dd>
+    <dt class="col-sm-4">Rechnungsbetrag</dt>
+    <dd class="col-sm-8">{% if forderung.Beleg_Betrag is not none %}{{ forderung.Beleg_Betrag|number_format }} €{% else %}nicht hinterlegt{% endif %}</dd>
+    <dt class="col-sm-4">Offener Betrag</dt>
+    <dd class="col-sm-8">{% if forderung.Beleg_offen is not none %}{{ forderung.Beleg_offen|number_format }} €{% else %}nicht hinterlegt{% endif %}</dd>
+  </dl>
+  {% elif kind == 'settled' %}
+  <p>Forderung {{ forderung.Beleg_Nr }} vom {{ forderung.Beleg_Datum|date_format if forderung.Beleg_Datum is not none else 'nicht hinterlegt' }} wurde am {{ forderung.Auszifferung_Datum|date_format if forderung.Auszifferung_Datum is not none else 'nicht hinterlegt' }} beglichen.</p>
+  {% else %}
+  <p>Eintrag nicht gefunden.</p>
+  {% endif %}
+  <a class="btn btn-primary" href="/app/forderungen/liste">Zurück zur Liste</a>
+</section>
+{% endblock %}

+ 3 - 0
tests/test_auth.py

@@ -97,6 +97,9 @@ class PermissionTests(unittest.TestCase):
 
 class AuthenticationFlowTests(unittest.TestCase):
     def setUp(self):
+        debug_config = patch.object(settings, "DEBUG_AUTH", False)
+        debug_config.start()
+        self.addCleanup(debug_config.stop)
         self.old_proxies = list(settings.TRUSTED_PROXY_IPS)
         self.old_secure = settings.COOKIE_SECURE
         settings.TRUSTED_PROXY_IPS = ["testclient"]

+ 131 - 0
tests/test_forderung_notice.py

@@ -0,0 +1,131 @@
+import unittest
+from datetime import date
+from decimal import Decimal
+from unittest.mock import MagicMock, patch
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.testclient import TestClient
+
+from app.db import get_session
+from app.permissions import Principal
+from app.routes import router
+
+
+class ForderungNoticeTests(unittest.TestCase):
+    def setUp(self):
+        self.db = MagicMock()
+        self.application = FastAPI()
+        self.application.include_router(router)
+        self.application.dependency_overrides[get_session] = lambda: self.db
+
+        @self.application.middleware("http")
+        async def authenticated(request: Request, call_next):
+            request.state.principal = Principal("tester", "Tester", "", "Mitarbeiter", "ldap", "csrf", ())
+            return await call_next(request)
+
+        self.client = TestClient(self.application)
+        self.addCleanup(self.client.close)
+        self.detail_context_patch = patch("app.routes.get_template_context")
+        self.detail_context = self.detail_context_patch.start()
+        self.addCleanup(self.detail_context_patch.stop)
+        self.current = {
+            "Beleg_Nr": "WGG24501320",
+            "Beleg_Datum": date(2024, 5, 13),
+            "Kunde_Text": "Beispielkunde <script>alert(1)</script>",
+            "Beleg_Betrag": Decimal("1234.50"),
+            "Beleg_offen": Decimal("250.00"),
+        }
+
+    def result(self, row=None, access=False):
+        result = MagicMock()
+        result.first.return_value = (1,) if access else None
+        result.mappings.return_value.first.return_value = row
+        return result
+
+    def get_notice(self, htmx=False):
+        return self.client.get(
+            "/app/forderungen/details/1_WGG24501320", headers={"HX-Request": "true"} if htmx else {}
+        )
+
+    def assert_notice(self, response):
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('href="/app/forderungen/liste">Zurück zur Liste', response.text)
+        self.assertNotIn('id="formular"', response.text)
+        self.assertNotIn('name="Kommentar"', response.text)
+        self.detail_context.assert_not_called()
+
+    def test_open_forderung_displays_only_summary_and_skips_history(self):
+        self.db.execute.side_effect = [self.result(), self.result(self.current)]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertIn("Forderung WGG24501320 vom 13.05.2024 ist noch offen.", response.text)
+        self.assertIn("1.234,50 €", response.text)
+        self.assertIn("250,00 €", response.text)
+        self.assertIn("&lt;script&gt;", response.text)
+        self.assertNotIn("<script>alert(1)</script>", response.text)
+        self.assertEqual(self.db.execute.call_count, 2)
+
+    def test_history_displays_dates_and_queries_exact_tenant_key(self):
+        history = {"Beleg_Nr": "WGG24501320", "Beleg_Datum": date(2024, 5, 13), "Auszifferung_Datum": date(2024, 6, 2)}
+        self.db.execute.side_effect = [self.result(), self.result(), self.result(history)]
+        response = self.get_notice(htmx=True)
+        self.assert_notice(response)
+        self.assertIn("wurde am 02.06.2024 beglichen.", response.text)
+        query, params = self.db.execute.call_args.args
+        self.assertIn("dbo.Forderungen_Historie", str(query))
+        self.assertIn("ORDER BY Auszifferung_Datum DESC", str(query))
+        self.assertEqual(params, {"client_db": "1", "beleg_nr": "WGG24501320"})
+        self.assertNotIn("WGG24501320", str(query))
+
+    def test_missing_entry_displays_short_message(self):
+        self.db.execute.side_effect = [self.result(), self.result(), self.result()]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertIn("Eintrag nicht gefunden.", response.text)
+
+    def test_null_fields_and_zero_amount_render_correctly(self):
+        row = dict(self.current, Beleg_Datum=None, Kunde_Text=None, Beleg_Betrag=None, Beleg_offen=Decimal("0"))
+        self.db.execute.side_effect = [self.result(), self.result(row)]
+        response = self.get_notice()
+        self.assert_notice(response)
+        self.assertEqual(response.text.count("nicht hinterlegt"), 3)
+        self.assertIn("0,00 €", response.text)
+
+    def test_authorized_user_retains_existing_detail_flow(self):
+        self.db.execute.return_value = self.result(access=True)
+        self.detail_context.return_value = {"existing": "context"}
+        with patch("app.routes.templates.TemplateResponse", return_value=HTMLResponse("Full details")) as render:
+            response = self.get_notice()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, "Full details")
+        self.detail_context.assert_called_once()
+        self.assertEqual(render.call_args.args[1], "forderungen/details/details.html")
+        self.db.execute.assert_called_once()
+
+    def test_database_failure_is_not_reported_as_missing(self):
+        self.db.execute.side_effect = [self.result(), RuntimeError("Database unavailable")]
+        with TestClient(self.application, raise_server_exceptions=False) as client:
+            response = client.get("/app/forderungen/details/1_WGG24501320")
+        self.assertEqual(response.status_code, 500)
+        self.assertNotIn("Eintrag nicht gefunden", response.text)
+
+    def test_write_file_and_export_routes_remain_denied(self):
+        self.db.execute.return_value = self.result()
+        cases = [
+            ("post", "/app/forderungen/details/1_WGG24501320", {"data": {"source": "comments", "Kommentar": "test"}}),
+            ("get", "/app/forderungen/files/1_WGG24501320", {}),
+            ("get", "/files/?name=1/WGG24501320/invoice.pdf", {}),
+            ("get", "/app/forderungen/export/1_WGG24501320/", {}),
+        ]
+        for method, url, kwargs in cases:
+            with self.subTest(url=url):
+                self.db.execute.reset_mock()
+                response = getattr(self.client, method)(url, **kwargs)
+                self.assertEqual(response.status_code, 404)
+                self.db.execute.assert_called_once()
+        self.db.commit.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()