feat: Uebertraege lassen sich endlich bedienen

Der Uebertrags-Dienst und seine fuenf Endpunkte gab es seit Wochen – ohne
einen einzigen Aufrufer in der Oberflaeche. Man konnte also nirgends sagen,
dass zwei Buchungen derselbe Uebertrag sind, und eine gefundene Verknuepfung
auch nicht wieder loesen.

Jetzt: eine Karte "Moegliche Uebertraege" im Eingang mit beiden Seiten
nebeneinander, Verbinden und Ignorieren; in der Buchungsliste eine Marke mit
dem Gegenkonto und ein Knopf zum Loesen. Das Gegenkonto kommt vom Server mit –
die andere Buchung steht oft gar nicht in der gefilterten Liste, und
"Uebertrag" ohne Angabe wohin sagt nichts.

Ausserdem wird nach dem Buchen aus dem Eingang nach Uebertraegen gesucht, so
wie bisher nur nach einem Import. Seit die Bankanbindung ihre Umsaetze in den
Eingang legt, entsteht die Gegenseite naemlich erst dort; ohne diesen Aufruf
wuerde sie nie gefunden. Ein Fehler dabei kippt das Buchen nicht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/routers/inbox.py

@@ -5,6 +5,8 @@ Einträge bleiben nach dem Buchen bestehen: Der spätere CSV-Import gleicht
 gegen sie ab, damit dieselbe Zahlung nicht ein zweites Mal verbucht wird.
 """
 
+import logging
+
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
@@ -23,6 +25,8 @@ from ..schemas import ApiTokenCreate, ApiTokenCreated, ApiTokenOut, InboxItemOut
 from ..security import generate_session_token, hash_session_token
 from ..services import currency
 
+log = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/inbox", tags=["inbox"])
 
 
@@ -115,6 +119,26 @@ def _buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None:
     return txn
 
 
+def _suche_uebertraege(db: Session, user: User) -> int:
+    """Nach dem Buchen nach Uebertraegen sehen – so wie nach einem Import.
+
+    Seit die Bankanbindung ihre Umsaetze hierher legt, entsteht die Gegenseite
+    eines Uebertrags erst beim Buchen. Ohne diesen Aufruf wuerde sie nie
+    gefunden, und die beiden Seiten zaehlten dauerhaft in der Auswertung mit.
+
+    Ein Fehler hier darf das Buchen nicht kippen: Die Buchung ist schon
+    festgeschrieben, die Verknuepfung ist nur eine Schicht darueber.
+    """
+    from ..services import uebertraege
+
+    try:
+        return uebertraege.finde(db, user).get("verknuepft", 0)
+    except Exception:                      # pragma: no cover - Sicherheitsnetz
+        log.exception("Uebertragssuche nach dem Buchen fehlgeschlagen")
+        db.rollback()
+        return 0
+
+
 @router.post("/{item_id}/book", response_model=InboxItemOut)
 def book_item(item_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
     eintrag = get_owned(db, InboxItem, item_id, user)
@@ -125,6 +149,7 @@ def book_item(item_id: int, db: Session = Depends(get_db), user: User = Depends(
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
                             detail="Lässt sich nicht buchen")
     db.commit()
+    _suche_uebertraege(db, user)
     db.refresh(eintrag)
     return eintrag
 
@@ -145,7 +170,7 @@ def book_all(db: Session = Depends(get_db), user: User = Depends(get_current_use
     )
     gebucht = sum(1 for e in offen if _buche(db, user, e) is not None)
     db.commit()
-    return {"gebucht": gebucht}
+    return {"gebucht": gebucht, "uebertraege": _suche_uebertraege(db, user)}
 
 
 @router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)

backend/app/services/uebertraege.py

@@ -297,13 +297,31 @@ def verbinde(db: Session, user: User, a: Transaction, b: Transaction,
 
 
 def linkliste(db: Session, user: User) -> dict[int, dict]:
-    """Je Buchungs-ID die Gegenseite – für die Anzeige in der Buchungsliste."""
+    """Je Buchungs-ID die Gegenseite – für die Anzeige in der Buchungsliste.
+
+    Das Gegenkonto kommt mit: Die andere Buchung steht oft gar nicht in der
+    gerade gefilterten Liste, und „Übertrag" ohne Angabe wohin sagt nichts.
+    """
+    links = db.query(TransferLink).filter(TransferLink.owner_id == user.id).all()
+    beteiligt = {i for l in links for i in (l.from_txn_id, l.to_txn_id)}
+    # Einmal nachschlagen statt je Verknüpfung – die Liste kann lang werden.
+    konto_von = dict(
+        db.query(Transaction.id, Transaction.account_id)
+        .filter(Transaction.id.in_(beteiligt or [0]))
+        .all()
+    )
+
     ergebnis: dict[int, dict] = {}
-    for link in db.query(TransferLink).filter(TransferLink.owner_id == user.id):
-        ergebnis[link.from_txn_id] = {"link_id": link.id, "other_id": link.to_txn_id,
-                                      "richtung": "raus", "automatisch": link.automatisch}
-        ergebnis[link.to_txn_id] = {"link_id": link.id, "other_id": link.from_txn_id,
-                                    "richtung": "rein", "automatisch": link.automatisch}
+    for link in links:
+        for eigen, gegen, richtung in (
+            (link.from_txn_id, link.to_txn_id, "raus"),
+            (link.to_txn_id, link.from_txn_id, "rein"),
+        ):
+            ergebnis[eigen] = {
+                "link_id": link.id, "other_id": gegen, "richtung": richtung,
+                "other_account_id": konto_von.get(gegen),
+                "automatisch": link.automatisch,
+            }
     return ergebnis