feat: Kontouebertraege lassen sich im Eingang buchen

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 <noreply@anthropic.com>

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.