From a471eba617b26d9e374483afcb4032b68e91fe11 Mon Sep 17 00:00:00 2001 From: Guido Date: Thu, 27 Aug 2026 06:31:49 +0200 Subject: [PATCH] feat: Kontouebertraege lassen sich im Eingang buchen MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bisher blieb im Eingang nur, eine Umbuchung als Ausgabe oder Einnahme zu kategorisieren. Sie zaehlte dann als Ausgabe, obwohl kein Geld weg ist – nur verschoben. Jetzt gibt es je Vorschlag den Weg 'Als Uebertrag buchen': Zielkonto waehlen, fertig. Es entsteht EINE Buchung, die beide Salden bewegt und in keiner Auswertung zaehlt. Die Richtung kommt aus dem Vorzeichen – ein Abgang geht von hier weg, ein Zugang kommt vom Gegenkonto her; entsprechend fragt der Dialog 'wohin' oder 'woher'. Bei verschiedenen Waehrungen wird die Seite exakt gesetzt, die wir wirklich kennen, und die andere umgerechnet. Der teuerste Fehler an dieser Stelle waere ein Zielkonto, das selbst an einer Bank haengt: Es meldet den Zugang von allein, eine Gegenbuchung hier haette das Geld zweimal. Der Server lehnt das mit einer Begruendung ab; wer es besser weiss, bestaetigt und kommt durch. Das Wissen bleibt an einer Stelle – die Oberflaeche fragt nicht selbst nach, sie zeigt die Antwort des Servers. Die Betragslogik ist dafuer aus dem Buchungs-Router in einen Dienst gewandert. Zwei Kopien derselben Umrechnung waeren genau die Stelle, an der Salden auseinanderlaufen. Co-Authored-By: Claude Opus 5 --- backend/app/routers/inbox.py | 44 +++++++++ backend/app/routers/transactions.py | 30 +----- backend/app/services/buchung.py | 36 +++++++ backend/app/services/eingang.py | 78 ++++++++++++++- backend/tests/test_inbox.py | 144 ++++++++++++++++++++++++++++ web/src/api.js | 8 ++ web/src/locales/de.json | 8 +- web/src/locales/en.json | 8 +- web/src/pages/Eingang.jsx | 92 +++++++++++++++++- 9 files changed, 415 insertions(+), 33 deletions(-) create mode 100644 backend/app/services/buchung.py create mode 100644 backend/tests/test_inbox.py diff --git a/backend/app/routers/inbox.py b/backend/app/routers/inbox.py index 6d8be02..be08e71 100644 --- a/backend/app/routers/inbox.py +++ b/backend/app/routers/inbox.py @@ -6,6 +6,7 @@ gegen sie ab, damit dieselbe Zahlung nicht ein zweites Mal verbucht wird. """ from fastapi import APIRouter, Depends, HTTPException, status +from pydantic import BaseModel from sqlalchemy.orm import Session from ..database import get_db @@ -101,6 +102,49 @@ def book_item(item_id: int, db: Session = Depends(get_db), user: User = Depends( return eintrag +class InboxTransferIn(BaseModel): + to_account_id: int + # Nur setzen, wenn man es besser weiss als Certain – siehe unten. + trotzdem: bool = False + + +@router.post("/{item_id}/transfer", response_model=InboxItemOut) +def book_as_transfer(item_id: int, payload: InboxTransferIn, + db: Session = Depends(get_db), user: User = Depends(get_current_user)): + """Einen Vorschlag als Kontoübertrag buchen statt als Ausgabe oder Einnahme. + + Es entsteht EINE Buchung, die das Geld vom einen Konto ins andere bewegt. + Sie zählt auf beiden Seiten im Saldo und in keiner Auswertung – ein + Übertrag ist keine Ausgabe. + """ + eintrag = get_owned(db, InboxItem, item_id, user) + if eintrag.account_id is None: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, + detail="Kein Konto zugeordnet") + ziel = get_owned(db, Account, payload.to_account_id, user) + if ziel.id == eintrag.account_id: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, + detail="Ein Übertrag braucht ein anderes Zielkonto") + + # Der teuerste Fehler an dieser Stelle: Das Zielkonto hängt selbst an einer + # Bank, liefert die Gegenbuchung also von allein. Wer hier trotzdem eine + # anlegt, hat das Geld zweimal auf dem Zielkonto. + if not payload.trotzdem and eingang.ist_angebunden(db, user, ziel): + raise HTTPException( + status_code=status.HTTP_409_CONFLICT, + detail=(f"'{ziel.name}' ist selbst an eine Bank angebunden und meldet " + f"den Zugang von allein. Buche das hier als Ausgabe – beide " + f"Seiten werden danach automatisch als Übertrag verbunden."), + ) + + if eingang.buche_als_uebertrag(db, user, eintrag, ziel) is None: + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, + detail="Lässt sich nicht buchen") + db.commit() + db.refresh(eintrag) + return eintrag + + @router.post("/book-all") def book_all(db: Session = Depends(get_db), user: User = Depends(get_current_user)) -> dict: """Alle offenen Vorschläge buchen, die ein Konto haben. diff --git a/backend/app/routers/transactions.py b/backend/app/routers/transactions.py index cfe6b48..7d7d7cf 100644 --- a/backend/app/routers/transactions.py +++ b/backend/app/routers/transactions.py @@ -14,34 +14,12 @@ from ..database import get_db from ..deps import get_current_user, get_owned from ..models import Account, Category, Transaction, TxnType, User from ..schemas import TransactionCreate, TransactionOut, TransactionUpdate -from ..services import currency +from ..services import buchung, currency from .accounts import base_currency router = APIRouter(prefix="/transactions", tags=["transactions"]) -def _fx(txn: Transaction) -> float | None: - return float(txn.fx_rate) if txn.fx_rate is not None else None - - -def _recompute(db: Session, txn: Transaction, from_acc: Account, to_acc: Account | None) -> None: - """Setzt amount_eur_cents und (bei Transfers) to_amount_cents neu.""" - txn.amount_eur_cents = currency.compute_amount_eur_cents( - db, txn.amount_cents, from_acc.currency, txn.date, _fx(txn) - ) - if txn.type == TxnType.transfer and to_acc is not None: - if txn.to_amount_cents is None: - if to_acc.currency == from_acc.currency: - txn.to_amount_cents = txn.amount_cents - else: - conv = currency.convert( - db, txn.amount_cents, from_acc.currency, to_acc.currency, txn.date, _fx(txn) - ) - txn.to_amount_cents = conv if conv is not None else txn.amount_cents - else: - txn.to_amount_cents = None - - def to_out(db: Session, txn: Transaction, base: str, ccy_by_account: dict[int, str]) -> TransactionOut: acc_ccy = ccy_by_account.get(txn.account_id, "EUR") if base == "EUR": @@ -59,7 +37,7 @@ def to_out(db: Session, txn: Transaction, base: str, ccy_by_account: dict[int, s account_currency=acc_ccy, amount_cents=txn.amount_cents, to_amount_cents=txn.to_amount_cents, - fx_rate=_fx(txn), + fx_rate=buchung.fx(txn), amount_eur_cents=txn.amount_eur_cents, amount_base_cents=amount_base, category_id=txn.category_id, @@ -168,7 +146,7 @@ def create_transaction( description=(payload.description or None), notes=(payload.notes or None), ) - _recompute(db, txn, from_acc, to_acc) + buchung.setze_betraege(db, txn, from_acc, to_acc) db.add(txn) db.commit() db.refresh(txn) @@ -222,7 +200,7 @@ def update_transaction( txn.category_id = None else: txn.to_account_id = None - _recompute(db, txn, from_acc, to_acc) + buchung.setze_betraege(db, txn, from_acc, to_acc) db.commit() db.refresh(txn) diff --git a/backend/app/services/buchung.py b/backend/app/services/buchung.py new file mode 100644 index 0000000..6c83133 --- /dev/null +++ b/backend/app/services/buchung.py @@ -0,0 +1,36 @@ +"""Betraege einer Buchung berechnen. + +Eigener Dienst, weil zwei Wege Buchungen anlegen: das Formular und der +Eingang, der einen Vorschlag als Uebertrag bucht. Zwei Kopien derselben +Umrechnung waeren genau die Stelle, an der Salden auseinanderlaufen. +""" + +from __future__ import annotations + +from sqlalchemy.orm import Session + +from ..models import Account, Transaction, TxnType +from . import currency + + +def fx(txn: Transaction) -> float | None: + return float(txn.fx_rate) if txn.fx_rate is not None else None + + +def setze_betraege(db: Session, txn: Transaction, von: Account, + nach: Account | None) -> None: + """Setzt amount_eur_cents und (bei Uebertraegen) to_amount_cents neu.""" + txn.amount_eur_cents = currency.compute_amount_eur_cents( + db, txn.amount_cents, von.currency, txn.date, fx(txn) + ) + if txn.type == TxnType.transfer and nach is not None: + if txn.to_amount_cents is None: + if nach.currency == von.currency: + txn.to_amount_cents = txn.amount_cents + else: + conv = currency.convert( + db, txn.amount_cents, von.currency, nach.currency, txn.date, fx(txn) + ) + txn.to_amount_cents = conv if conv is not None else txn.amount_cents + else: + txn.to_amount_cents = None diff --git a/backend/app/services/eingang.py b/backend/app/services/eingang.py index 75adfc2..e80c4b2 100644 --- a/backend/app/services/eingang.py +++ b/backend/app/services/eingang.py @@ -12,8 +12,16 @@ import logging from sqlalchemy.orm import Session -from ..models import Account, InboxItem, InboxStatus, Transaction, TxnType, User -from . import currency +from ..models import ( + Account, + BankAccountLink, + InboxItem, + InboxStatus, + Transaction, + TxnType, + User, +) +from . import buchung, currency log = logging.getLogger(__name__) @@ -47,6 +55,72 @@ def buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None: return txn +def ist_angebunden(db: Session, user: User, konto: Account) -> bool: + """Holt Certain die Umsaetze dieses Kontos selbst von der Bank? + + Entscheidend fuer einen Uebertrag: Bei einem angebundenen Gegenkonto + liefert die Bank die Gegenbuchung selbst. Wer sie hier trotzdem anlegt, + hat das Geld zweimal. + """ + return db.query(BankAccountLink.id).filter( + BankAccountLink.owner_id == user.id, + BankAccountLink.account_id == konto.id, + ).first() is not None + + +def buche_als_uebertrag(db: Session, user: User, eintrag: InboxItem, + ziel: Account) -> Transaction | None: + """Einen Vorschlag als Kontouebertrag buchen. + + Statt Ausgabe oder Einnahme entsteht EINE Buchung, die das Geld vom einen + Konto ins andere bewegt. Die Richtung kommt aus dem Vorzeichen: Ein + negativer Betrag ist ein Abgang von diesem Konto, ein positiver ein Zugang. + + Bei verschiedenen Waehrungen wird die Seite exakt gesetzt, die wir wirklich + kennen – die aus dem Vorschlag. Die andere wird umgerechnet. + """ + if eintrag.status == InboxStatus.booked or eintrag.transaction_id is not None: + return None + if eintrag.account_id is None or eintrag.account_id == ziel.id: + return None + konto = db.get(Account, eintrag.account_id) + if konto is None or konto.owner_id != user.id: + return None + + betrag = abs(eintrag.amount_cents) + if eintrag.amount_cents < 0: + von, nach = konto, ziel + ziel_betrag = None # wird umgerechnet + else: + von, nach = ziel, konto + # Bekannt ist der Zugang, gesucht der Abgang – also rueckwaerts. + ziel_betrag = betrag + if ziel.currency != konto.currency: + umgerechnet = currency.convert( + db, betrag, konto.currency, ziel.currency, eintrag.date) + betrag = umgerechnet if umgerechnet is not None else betrag + + txn = Transaction( + owner_id=user.id, + type=TxnType.transfer, + date=eintrag.date, + account_id=von.id, + to_account_id=nach.id, + amount_cents=betrag, + to_amount_cents=ziel_betrag, + payee=eintrag.payee, + description=eintrag.note, + ) + buchung.setze_betraege(db, txn, von, nach) + db.add(txn) + db.flush() + eintrag.transaction_id = txn.id + eintrag.status = InboxStatus.booked + # Ein Uebertrag traegt keine Kategorie – er ist keine Ausgabe. + eintrag.category_id = None + return txn + + def suche_uebertraege(db: Session, user: User) -> int: """Nach dem Buchen nach Uebertraegen sehen – so wie nach einem Import. diff --git a/backend/tests/test_inbox.py b/backend/tests/test_inbox.py new file mode 100644 index 0000000..4caf4c2 --- /dev/null +++ b/backend/tests/test_inbox.py @@ -0,0 +1,144 @@ +"""Eingang: einen Vorschlag als Kontoübertrag buchen. + +Ohne diesen Weg bleibt nur, eine Umbuchung als Ausgabe zu kategorisieren – sie +zählt dann als Ausgabe, obwohl kein Geld weg ist. +""" + +import secrets + + +def _konto(admin, **kw): + body = {"name": "Girokonto", "type": "girokonto", "currency": "CHF", + "opening_balance_cents": 0} + body.update(kw) + r = admin.post("/api/accounts", json=body) + assert r.status_code == 201, r.text + return r.json() + + +def _eingang(admin, konto, betrag_cents, datum="2026-08-20", payee="Umbuchung"): + """Ein OFFENER Eintrag – so wie ihn Mail und Bankabruf hinterlassen. + + Nicht ueber die Schnellerfassung: Die bucht sofort, und dann gaebe es + nichts mehr als Uebertrag zu buchen. + """ + from datetime import date + + from app.database import SessionLocal + from app.models import InboxItem, InboxSource, InboxStatus, User + + db = SessionLocal() + try: + besitzer = db.query(User).order_by(User.id).first() + eintrag = InboxItem( + owner_id=besitzer.id, + source=InboxSource.mail, + status=InboxStatus.pending, + account_id=konto["id"], + date=date.fromisoformat(datum), + amount_cents=betrag_cents, + currency=konto["currency"], + payee=payee, + ) + db.add(eintrag) + db.commit() + return {"id": eintrag.id} + finally: + db.close() + + +def test_eingang_laesst_sich_als_uebertrag_buchen(admin): + von = _konto(admin, name=f"Von {secrets.token_hex(3)}", currency="CHF") + nach = _konto(admin, name=f"Nach {secrets.token_hex(3)}", currency="CHF") + eintrag = _eingang(admin, von, -50000) + + r = admin.post(f"/api/inbox/{eintrag['id']}/transfer", + json={"to_account_id": nach["id"]}) + assert r.status_code == 200, r.text + assert r.json()["status"] == "booked" + assert r.json()["category_id"] is None + + txn = admin.get(f"/api/transactions/{r.json()['transaction_id']}").json() + assert txn["type"] == "transfer" + assert txn["account_id"] == von["id"] + assert txn["to_account_id"] == nach["id"] + assert txn["amount_cents"] == 50000 + + # Das Geld ist verschoben, nicht ausgegeben. + assert admin.get(f"/api/accounts/{von['id']}").json()["balance_cents"] == -50000 + assert admin.get(f"/api/accounts/{nach['id']}").json()["balance_cents"] == 50000 + + +def test_zugang_dreht_die_richtung_um(admin): + """Ein positiver Betrag heisst: Auf DIESEM Konto kam das Geld an. Die + Buchung muss vom Gegenkonto hierher gehen, nicht umgekehrt.""" + hier = _konto(admin, name=f"Hier {secrets.token_hex(3)}", currency="CHF") + dort = _konto(admin, name=f"Dort {secrets.token_hex(3)}", currency="CHF") + eintrag = _eingang(admin, hier, 25000) + + r = admin.post(f"/api/inbox/{eintrag['id']}/transfer", json={"to_account_id": dort["id"]}) + assert r.status_code == 200, r.text + txn = admin.get(f"/api/transactions/{r.json()['transaction_id']}").json() + assert txn["account_id"] == dort["id"], "der Abgang gehört zum Gegenkonto" + assert txn["to_account_id"] == hier["id"] + assert admin.get(f"/api/accounts/{hier['id']}").json()["balance_cents"] == 25000 + assert admin.get(f"/api/accounts/{dort['id']}").json()["balance_cents"] == -25000 + + +def test_uebertrag_zaehlt_in_keiner_auswertung(admin): + """Der eigentliche Zweck: Ein Übertrag ist keine Ausgabe.""" + von = _konto(admin, name=f"Budget-Von {secrets.token_hex(3)}", currency="CHF") + nach = _konto(admin, name=f"Budget-Nach {secrets.token_hex(3)}", currency="CHF") + eintrag = _eingang(admin, von, -30000, datum="2026-08-05") + admin.post(f"/api/inbox/{eintrag['id']}/transfer", json={"to_account_id": nach["id"]}) + + v = admin.get("/api/budget/2026-08").json() + gesamt = sum(z.get("actual_cents") or 0 for z in v.get("rows", [])) + assert gesamt == 0, "ein Übertrag darf im Budget nicht auftauchen" + + +def _binde_an(konto): + """Konto so markieren, als haenge es an einer Bank.""" + from app.database import SessionLocal + from app.models import BankAccountLink, BankApp, BankConnection, User + + db = SessionLocal() + try: + besitzer = db.query(User).order_by(User.id).first() + app = BankApp(owner_id=besitzer.id, application_id="app-x", + private_key_enc="x", base_url="https://x.example") + db.add(app) + verbindung = BankConnection(owner_id=besitzer.id, aspsp_name="Zielbank", + aspsp_country="CH") + db.add(verbindung) + db.flush() + db.add(BankAccountLink( + owner_id=besitzer.id, connection_id=verbindung.id, + remote_uid=f"acc-{secrets.token_hex(4)}", currency=konto["currency"], + account_id=konto["id"])) + db.commit() + finally: + db.close() + + +def test_angebundenes_zielkonto_wird_abgefangen(admin): + """Der teuerste Fehler an dieser Stelle: Das Zielkonto haengt selbst an + einer Bank und meldet den Zugang von allein – eine Gegenbuchung hier + bedeutet das Geld zweimal.""" + ziel = _konto(admin, name=f"Angebunden {secrets.token_hex(3)}", currency="CHF") + _binde_an(ziel) + + quelle = _konto(admin, name=f"Quelle {secrets.token_hex(3)}", currency="CHF") + eintrag = _eingang(admin, quelle, -10000) + + r = admin.post(f"/api/inbox/{eintrag['id']}/transfer", json={"to_account_id": ziel["id"]}) + assert r.status_code == 409, r.text + assert "angebunden" in r.json()["detail"] + # Nichts gebucht, nichts verschoben. + assert admin.get(f"/api/accounts/{ziel['id']}").json()["balance_cents"] == 0 + + # Wer es besser weiss, kommt trotzdem durch. + r = admin.post(f"/api/inbox/{eintrag['id']}/transfer", + json={"to_account_id": ziel["id"], "trotzdem": True}) + assert r.status_code == 200, r.text + assert admin.get(f"/api/accounts/{ziel['id']}").json()["balance_cents"] == 10000 diff --git a/web/src/api.js b/web/src/api.js index d663492..ec11645 100644 --- a/web/src/api.js +++ b/web/src/api.js @@ -204,6 +204,14 @@ export const api = { bankCallback: (state, code) => request(`/bank/callback?state=${encodeURIComponent(state)}&code=${encodeURIComponent(code)}`, { method: "POST" }), + // Einen Eingangs-Vorschlag als Kontoübertrag buchen statt als Ausgabe. + // `trotzdem` nur setzen, wenn der Server mit 409 gewarnt hat und der Nutzer + // die Warnung gelesen und bestätigt hat. + bookInboxAsTransfer: (id, toAccountId, trotzdem = false) => + request(`/inbox/${id}/transfer`, { + method: "POST", body: { to_account_id: toAccountId, trotzdem }, + }), + // --- Überträge zwischen eigenen Konten ----------------------------------- // Ändern ausschliesslich die Verknüpfungs-Schicht. Keine Buchung wird // angefasst – deshalb ist auch eine falsche Verknüpfung folgenlos. diff --git a/web/src/locales/de.json b/web/src/locales/de.json index 54f047e..c4d91db 100644 --- a/web/src/locales/de.json +++ b/web/src/locales/de.json @@ -519,7 +519,13 @@ "bookedN": "{{n}} gebucht.", "booked": "gebucht", "unclear": "unklar – bitte ansehen", - "viaMail": "aus einer E-Mail" + "viaMail": "aus einer E-Mail", + "asTransfer": "Als Übertrag buchen", + "transferTitle": "Kontoübertrag", + "transferIntro": "Kein Geld ausgegeben, nur verschoben. Es entsteht eine Buchung, die beide Salden bewegt und in keiner Auswertung zählt.", + "transferTargetOut": "Wohin ging das Geld?", + "transferTargetIn": "Woher kam das Geld?", + "transferBooked": "Als Übertrag gebucht." }, "mailbox": { "title": "Postfach für Zahlungs-Mails", diff --git a/web/src/locales/en.json b/web/src/locales/en.json index 5cf0f74..af05749 100644 --- a/web/src/locales/en.json +++ b/web/src/locales/en.json @@ -519,7 +519,13 @@ "bookedN": "{{n}} booked.", "booked": "booked", "unclear": "unclear – please review", - "viaMail": "from an email" + "viaMail": "from an email", + "asTransfer": "Book as transfer", + "transferTitle": "Account transfer", + "transferIntro": "No money spent, only moved. This creates one transaction that changes both balances and counts in no evaluation.", + "transferTargetOut": "Where did the money go?", + "transferTargetIn": "Where did the money come from?", + "transferBooked": "Booked as a transfer." }, "mailbox": { "title": "Mailbox for payment emails", diff --git a/web/src/pages/Eingang.jsx b/web/src/pages/Eingang.jsx index 98792e9..d19fd04 100644 --- a/web/src/pages/Eingang.jsx +++ b/web/src/pages/Eingang.jsx @@ -5,6 +5,8 @@ import { api } from "../api"; import CategorySelect from "../components/CategorySelect"; import Icon from "../components/Icon"; import IconChip from "../components/IconChip"; +import AccountSelect from "../components/AccountSelect"; +import Modal from "../components/Modal"; import Money from "../components/Money"; import Uebertragsvorschlaege from "../components/Uebertragsvorschlaege"; import { useToast } from "../toast"; @@ -25,6 +27,8 @@ export default function Eingang() { const [rows, setRows] = useState(null); const [accounts, setAccounts] = useState([]); const [groups, setGroups] = useState([]); + // Vorschlag, der gerade als Übertrag gebucht wird, samt Zielkonto. + const [uebertrag, setUebertrag] = useState(null); const expenseGroups = useMemo(() => gruppenFuer(groups, "expense"), [groups]); const incomeGroups = useMemo(() => gruppenFuer(groups, "income"), [groups]); @@ -74,6 +78,33 @@ export default function Eingang() { } } + async function uebertragBuchen() { + const { item, ziel } = uebertrag; + if (!ziel) return; + try { + await api.bookInboxAsTransfer(item.id, Number(ziel)); + } catch (e) { + // 409: Das Zielkonto haengt selbst an einer Bank und meldet den Zugang + // von allein. Die Begruendung kommt vom Server – dort steht das Wissen, + // ob ein Konto angebunden ist. + if (e.status !== 409) { toast(e.message, "error"); return; } + if (!(await confirm({ + title: t("inbox.transferTitle"), + message: e.message, + confirmLabel: t("inbox.asTransfer"), + }))) return; + try { + await api.bookInboxAsTransfer(item.id, Number(ziel), true); + } catch (zweiter) { + toast(zweiter.message, "error"); + return; + } + } + setUebertrag(null); + toast(t("inbox.transferBooked")); + laden(); + } + async function verwerfen(item) { if (!(await confirm({ title: t("inbox.discard"), @@ -107,6 +138,53 @@ export default function Eingang() { deshalb steht der Vorschlag hier und nicht in der Buchungsliste. */} + {uebertrag && ( + setUebertrag(null)} + footer={ + <> + + + + } + > +

{t("inbox.transferIntro")}

+
+
+
{uebertrag.item.payee || t("inbox.noText")}
+
+ {formatDate(uebertrag.item.date)} ·{" "} + {accountById[uebertrag.item.account_id]?.name || "—"} +
+
+ +
+ + + )} + {rows.length === 0 ? (
{t("inbox.empty")}
) : ( @@ -141,9 +219,17 @@ export default function Eingang() { onChange={(id) => zuordnen(item, id)} /> {item.status !== "booked" && item.account_id && ( - + <> + + {/* Eine Umbuchung ist keine Ausgabe. Ohne diesen Weg + bliebe nur, sie als solche zu kategorisieren. */} + + )}