feat: Angebundene Konten buchen selbst – der Saldo kann nicht abweichen

Bisher legte der Bankabruf Vorschlaege in den Eingang, die man von Hand buchen
musste. Ein angebundenes Konto ist aber die Quelle der Wahrheit: Was die Bank
gebucht hat, IST gebucht. Jetzt wird es sofort gebucht; uebrig bleibt das
Zuordnen der Kategorie.

Drei Dinge mussten dafuer stimmen, sonst haette es Salden verfaelscht:

- Der erste Abruf greift nicht mehr hinter die neueste vorhandene Buchung des
  Kontos zurueck. Vorher holte er neunzig Tage – mitten in Monate, die schon
  per CSV eingelesen sind. Der Duplikatschutz haette die nicht gefunden: Sein
  Schluessel enthaelt den Empfaengertext, und der lautet bei der Bank anders
  als im Kontoauszug. Das Startdatum steht in der Rueckmeldung.
- Vorgemerkte Umsaetze werden nicht gebucht. Sie kommen spaeter noch einmal,
  dann mit anderer Kennung, weil die Bank beim Buchen eine neue vergibt.
  Beides zu nehmen hiesse doppelt buchen. Ihre Zahl wird gemeldet, nicht
  verschwiegen.
- Nach dem Buchen wird nach Uebertraegen gesucht. Ein Uebertrag zwischen zwei
  angebundenen Konten kommt in EINEM Abruf an – beide Seiten.

Nebenbei schliesst das eine bestehende Luecke: Der Eingangs-Abgleich beim
CSV-Import sieht nur gebuchte Eintraege. Solange Bank-Vorschlaege unbeachtet
liegen blieben, haette ein spaeterer Import derselben Wochen sie verdoppelt.

Das Buchen aus dem Eingang ist dafuer vom 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/bank_sync.py

@@ -20,6 +20,7 @@ import logging
 import secrets
 from datetime import date, datetime, timedelta, timezone
 
+from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 from ..models import (
@@ -30,9 +31,10 @@ from ..models import (
     InboxItem,
     InboxSource,
     InboxStatus,
+    Transaction,
     User,
 )
-from . import csv_import, geheimnis
+from . import csv_import, eingang, geheimnis
 from .bank_api import ERSTER_ABRUF_TAGE, BankClient, BankFehler
 
 log = logging.getLogger(__name__)
@@ -392,6 +394,53 @@ def hole_salden(db: Session, user: User, verbindung: BankConnection,
     return aktualisiert
 
 
+# Nur abgeschlossene Umsaetze zaehlen fuer den Saldo. Vorgemerkte kommen ein
+# oder zwei Tage spaeter noch einmal – dann mit anderer Kennung, weil die Bank
+# beim Buchen eine neue vergibt. Beides aufzunehmen hiesse: doppelt gebucht.
+GEBUCHT = {"BOOK", "BOOKED"}
+VORGEMERKT = {"PDNG", "PENDING"}
+
+
+def _ist_gebucht(umsatz: dict) -> bool | None:
+    """True = gebucht, False = vorgemerkt, None = weder noch (storniert o. ae.).
+
+    Fehlt die Angabe, gilt der Umsatz als gebucht: Die meisten Anbindungen
+    liefern ueber diesen Endpunkt ohnehin nur gebuchte.
+    """
+    status = str(umsatz.get("status") or "").upper()
+    if not status or status in GEBUCHT:
+        return True
+    if status in VORGEMERKT:
+        return False
+    return None
+
+
+def _startdatum(db: Session, user: User, konto: Account,
+                verbindung: BankConnection) -> date:
+    """Ab welchem Tag Umsaetze geholt werden.
+
+    Beim ERSTEN Abruf ab dem Tag nach der neuesten vorhandenen Buchung des
+    Kontos. Ohne das holte die Bank neunzig Tage zurueck – mitten in Monate,
+    die schon per CSV eingelesen sind. Der Duplikatschutz faende die nicht:
+    Sein Schluessel enthaelt den Empfaengertext, und der lautet bei der Bank
+    anders als im Kontoauszug.
+
+    Spaeter genuegt ein kleiner Rueckgriff hinter den letzten Abruf; einen
+    doppelten Abruf faengt die Kennung des Umsatzes exakt ab.
+    """
+    if verbindung.last_sync_at:
+        return verbindung.last_sync_at.date() - timedelta(days=3)
+    frueheste = date.today() - timedelta(days=ERSTER_ABRUF_TAGE)
+    letzte = (
+        db.query(func.max(Transaction.date))
+        .filter(Transaction.owner_id == user.id, Transaction.account_id == konto.id)
+        .scalar()
+    )
+    if letzte is None:
+        return frueheste
+    return max(frueheste, letzte + timedelta(days=1))
+
+
 def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
     """Umsätze aller zugeordneten Konten dieser Verbindung in den Eingang holen."""
     client = _client(db, user)
@@ -410,17 +459,27 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
         return {"geholt": 0, "neu": 0, "saldi": saldi, "ohne_zuordnung": True}
 
     konten = {a.id: a for a in db.query(Account).filter(Account.owner_id == user.id)}
-    seit = (verbindung.last_sync_at.date() - timedelta(days=3)
-            if verbindung.last_sync_at
-            else date.today() - timedelta(days=ERSTER_ABRUF_TAGE))
 
-    geholt = neu = 0
+    geholt = neu = gebucht = vorgemerkt = 0
+    ab: date | None = None
     for verknuepfung in verknuepfungen:
         konto = konten.get(verknuepfung.account_id)
         if konto is None:
             continue
+        # Je Konto eigen: Das eine ist bis gestern per CSV gepflegt, das andere
+        # ganz neu.
+        seit = _startdatum(db, user, konto, verbindung)
+        ab = seit if ab is None else min(ab, seit)
         for umsatz in client.umsaetze(verknuepfung.remote_uid, seit):
             geholt += 1
+            zustand = _ist_gebucht(umsatz)
+            if zustand is None:
+                continue
+            if zustand is False:
+                # Nicht stillschweigend verwerfen: Sonst fehlt die Zahlung im
+                # Eingang und niemand weiss, warum.
+                vorgemerkt += 1
+                continue
             kennung = (umsatz.get("entry_reference") or umsatz.get("transaction_id")
                        or umsatz.get("uid"))
             if not kennung:
@@ -453,7 +512,7 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
             if zeile.get("is_duplicate"):
                 continue
 
-            db.add(InboxItem(
+            eintrag = InboxItem(
                 owner_id=user.id,
                 source=InboxSource.bank,
                 status=InboxStatus.pending,
@@ -466,13 +525,30 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
                 note=zweck,
                 category_id=zeile.get("category_id"),
                 external_id=kennung,
-            ))
+            )
+            db.add(eintrag)
+            db.flush()
             neu += 1
 
+            # Sofort buchen. Ein angebundenes Konto ist die Quelle der Wahrheit:
+            # Was die Bank gebucht hat, IST gebucht – erst dadurch kann Certains
+            # Saldo gar nicht mehr abweichen. Eine Kategorie fehlt oft, die
+            # traegt man in Ruhe nach; ein fehlender Betrag waere schlimmer.
+            if eingang.buche(db, user, eintrag) is not None:
+                gebucht += 1
+
     verbindung.last_sync_at = datetime.now(timezone.utc)
     verbindung.last_error = None
     db.commit()
-    return {"geholt": geholt, "neu": neu, "saldi": saldi, "ohne_zuordnung": False}
+
+    # Ein Uebertrag zwischen zwei angebundenen Konten kommt in EINEM Abruf an –
+    # beide Seiten. Ohne diesen Aufruf zaehlten sie als Ausgabe und Einnahme.
+    verknuepft = eingang.suche_uebertraege(db, user) if gebucht else 0
+    return {
+        "uebertraege": verknuepft,
+        "geholt": geholt, "neu": neu, "gebucht": gebucht, "vorgemerkt": vorgemerkt,
+        "saldi": saldi, "ab": ab.isoformat() if ab else None, "ohne_zuordnung": False,
+    }
 
 
 def _datum(umsatz: dict) -> date | None: