feat: Umsaetze je Konto holen, Takt fuer den automatischen Abruf

Drei Sachen an der Bankanbindung.

'Umsaetze holen' lief ueber alle Konten einer Verbindung. Seit angebundene
Konten selbst buchen, ist ein Klick damit folgenreich: Er bucht auf zwei
Konten. Der Knopf sitzt jetzt in der Kontozeile; an der Verbindung bleibt
'Alle Konten holen'.

Dabei musste der Zeitstempel mitwandern. last_sync_at hing an der
Verbindung – ein Einzelabruf haette damit das Startdatum der uebrigen Konten
mit vorgeschoben, und deren Umsaetze aus dem uebersprungenen Zeitraum waeren
nie angekommen. Der Stempel gehoert an das Konto, das abgerufen wurde.

Neu ist ein Takt je Verbindung, nach demselben Muster wie beim Postfach: ein
Hintergrund-Thread, der jede Minute nachsieht, ob etwas faellig ist. Bewusst
ein eigener Thread – ein haengender Bankzugang darf den Mail-Abruf nicht
mitreissen. Die Vorgabe ist 0, also aus: Anders als beim Mail-Abruf entstehen
hier Buchungen, das laeuft nicht ungefragt los. Schlaegt ein Abruf fehl, wird
der Stempel trotzdem gesetzt, sonst liefe die Verbindung jede Minute in
denselben Fehler.

Und die Abschnitte heissen jetzt 'Bankkonten Anbindung' und 'Mail Import'.

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

backend/app/main.py

@@ -106,6 +106,40 @@ async def lifespan(app: FastAPI):
                 s.close()
 
     threading.Thread(target=_mails, name="mail-abruf", daemon=True).start()
+
+    # Bankumsätze im selben Takt-Muster. Bewusst ein EIGENER Thread: Ein
+    # hängender Bankzugang darf den Mail-Abruf nicht mitreissen.
+    #
+    # Anders als beim Mail-Abruf entstehen hier BUCHUNGEN. Deshalb steht der
+    # Takt je Verbindung auf 0, bis ihn jemand einschaltet – nichts läuft
+    # ungefragt los. Gegen doppelte Buchungen sichern die Kennung des Umsatzes,
+    # das Startdatum hinter der letzten Buchung und das Übergehen vorgemerkter
+    # Umsätze; siehe bank_sync.
+    def _bank() -> None:
+        from datetime import datetime, timezone
+
+        from .models import BankConnection, User
+        from .services import bank_sync
+
+        while not stopp.wait(60):
+            s = SessionLocal()
+            try:
+                jetzt = datetime.now(timezone.utc)
+                for verbindung in s.query(BankConnection).filter(
+                    BankConnection.poll_minutes > 0
+                ):
+                    if not bank_sync.faellig(verbindung, jetzt):
+                        continue
+                    nutzer = s.get(User, verbindung.owner_id)
+                    if nutzer is None:
+                        continue
+                    bank_sync.abruf_mit_fehlerbehandlung(s, nutzer, verbindung)
+            except Exception:
+                log.exception("Bank-Abruf fehlgeschlagen")
+            finally:
+                s.close()
+
+    threading.Thread(target=_bank, name="bank-abruf", daemon=True).start()
     yield
     stopp.set()
 

backend/app/models.py

@@ -881,6 +881,9 @@ class BankConnection(Base):
     # Solange die Autorisierung läuft, steht hier der state-Wert aus /auth.
     pending_state: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
     last_sync_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    # Takt des automatischen Abrufs in Minuten, 0 = aus. Wie beim Postfach –
+    # nur ist die Vorgabe hier bewusst aus, denn ein Abruf bucht.
+    poll_minutes: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     last_error: Mapped[str | None] = mapped_column(Text, nullable=True)
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
 
@@ -924,6 +927,12 @@ class BankAccountLink(Base):
     account_id: Mapped[int | None] = mapped_column(
         ForeignKey("accounts.id", ondelete="SET NULL"), nullable=True
     )
+    # Wann DIESES Konto zuletzt abgerufen wurde. An der Verbindung waere der
+    # Stempel falsch, sobald man ein einzelnes Konto abruft: Er schoebe das
+    # Startdatum der uebrigen mit vor, und deren Umsaetze kaemen nie an.
+    last_sync_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
 
     __table_args__ = (

backend/app/routers/bank.py

@@ -127,6 +127,43 @@ def sync(connection_id: int, db: Session = Depends(get_db),
         raise _fehler(e) from e
 
 
+@router.post("/links/{link_id}/sync")
+def sync_link(link_id: int, db: Session = Depends(get_db),
+              user: User = Depends(get_current_user)) -> dict:
+    """Nur die Umsätze DIESES Kontos holen.
+
+    Ein Abruf bucht. Wer ein einzelnes Konto abruft, will nicht, dass nebenbei
+    auf einem zweiten Buchungen entstehen.
+    """
+    verknuepfung = get_owned(db, BankAccountLink, link_id, user)
+    verbindung = get_owned(db, BankConnection, verknuepfung.connection_id, user)
+    try:
+        return bank_sync.hole_umsaetze(db, user, verbindung, nur_link_id=verknuepfung.id)
+    except BankFehler as e:
+        verbindung.last_error = str(e)[:500]
+        db.commit()
+        raise _fehler(e) from e
+
+
+@router.put("/connections/{connection_id}/takt")
+def set_poll(connection_id: int, minutes: int, db: Session = Depends(get_db),
+             user: User = Depends(get_current_user)) -> dict:
+    """Takt des automatischen Abrufs. 0 schaltet ihn ab.
+
+    Untergrenze 15 Minuten: Banken begrenzen unter PSD2 die Zahl der Abrufe je
+    Tag, und häufiger bringt nichts – Umsätze erscheinen nicht im Minutentakt.
+    """
+    verbindung = get_owned(db, BankConnection, connection_id, user)
+    if minutes != 0 and not 15 <= minutes <= 1440:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Der Takt muss 0 (aus) oder zwischen 15 und 1440 Minuten liegen.",
+        )
+    verbindung.poll_minutes = minutes
+    db.commit()
+    return {"poll_minutes": verbindung.poll_minutes}
+
+
 @router.post("/connections/{connection_id}/salden")
 def refresh_balances(connection_id: int, db: Session = Depends(get_db),
                      user: User = Depends(get_current_user)) -> dict:

backend/app/schemas.py

@@ -644,6 +644,8 @@ class BankConnectionOut(BaseModel):
     aspsp_country: str
     valid_until: datetime | None
     last_sync_at: datetime | None
+    # Takt des automatischen Abrufs in Minuten, 0 = aus.
+    poll_minutes: int = 0
     last_error: str | None
     expires_soon: bool = False
 
@@ -663,6 +665,7 @@ class BankAccountLinkOut(BaseModel):
     balance_cents: int | None = None
     balance_type: str | None = None
     balance_at: datetime | None = None
+    last_sync_at: datetime | None = None
     account_id: int | None
 
     model_config = ConfigDict(from_attributes=True)

backend/app/services/bank_sync.py

@@ -363,8 +363,25 @@ def _saldo(salden: list[dict]) -> tuple[int | None, str | None, datetime | None]
     return beste[1], beste[2], beste[3]
 
 
+def _verknuepfungen(db: Session, user: User, verbindung: BankConnection,
+                    nur_link_id: int | None) -> list[BankAccountLink]:
+    """Die Konten einer Verbindung – oder genau eines davon.
+
+    Ein Abruf bucht. Wer ein einzelnes Konto abruft, will nicht, dass nebenbei
+    auf einem zweiten Buchungen entstehen.
+    """
+    frage = db.query(BankAccountLink).filter(
+        BankAccountLink.connection_id == verbindung.id,
+        BankAccountLink.owner_id == user.id,
+    )
+    if nur_link_id is not None:
+        frage = frage.filter(BankAccountLink.id == nur_link_id)
+    return frage.all()
+
+
 def hole_salden(db: Session, user: User, verbindung: BankConnection,
-                client: BankClient | None = None) -> int:
+                client: BankClient | None = None,
+                nur_link_id: int | None = None) -> int:
     """Den von der Bank gefuehrten Saldo je Konto auffrischen.
 
     Auch fuer noch nicht zugeordnete Konten: Bei Revolut-Pockets ist der Betrag
@@ -375,10 +392,7 @@ def hole_salden(db: Session, user: User, verbindung: BankConnection,
     """
     client = client or _client(db, user)
     aktualisiert = 0
-    for verknuepfung in db.query(BankAccountLink).filter(
-        BankAccountLink.connection_id == verbindung.id,
-        BankAccountLink.owner_id == user.id,
-    ):
+    for verknuepfung in _verknuepfungen(db, user, verbindung, nur_link_id):
         try:
             cents, art, stand = _saldo(client.salden(verknuepfung.remote_uid))
         except BankFehler as e:
@@ -416,8 +430,8 @@ def _ist_gebucht(umsatz: dict) -> bool | None:
 
 
 def _startdatum(db: Session, user: User, konto: Account,
-                verbindung: BankConnection) -> date:
-    """Ab welchem Tag Umsaetze geholt werden.
+                verknuepfung: BankAccountLink) -> date:
+    """Ab welchem Tag Umsaetze DIESES Kontos 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,
@@ -427,9 +441,13 @@ def _startdatum(db: Session, user: User, konto: Account,
 
     Spaeter genuegt ein kleiner Rueckgriff hinter den letzten Abruf; einen
     doppelten Abruf faengt die Kennung des Umsatzes exakt ab.
+
+    Der Stempel gehoert an das Konto, nicht an die Verbindung: Sonst schoebe
+    ein Einzelabruf das Startdatum der uebrigen Konten mit vor, und deren
+    Umsaetze aus dem uebersprungenen Zeitraum kaemen nie an.
     """
-    if verbindung.last_sync_at:
-        return verbindung.last_sync_at.date() - timedelta(days=3)
+    if verknuepfung.last_sync_at:
+        return verknuepfung.last_sync_at.date() - timedelta(days=3)
     frueheste = date.today() - timedelta(days=ERSTER_ABRUF_TAGE)
     letzte = (
         db.query(func.max(Transaction.date))
@@ -441,20 +459,20 @@ def _startdatum(db: Session, user: User, konto: Account,
     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."""
+def hole_umsaetze(db: Session, user: User, verbindung: BankConnection,
+                  nur_link_id: int | None = None) -> dict:
+    """Umsätze der zugeordneten Konten dieser Verbindung in den Eingang holen.
+
+    Mit ``nur_link_id`` nur das eine Konto – samt seinem Saldo. Ein Abruf
+    bucht; wer ein Konto abruft, will das andere nicht angefasst haben.
+    """
     client = _client(db, user)
     # Zuerst die Saldi – auch fuer nicht zugeordnete Konten. Sonst saehe man
     # bei drei gleich aussehenden Pockets nie, welches welches ist.
-    saldi = hole_salden(db, user, verbindung, client)
+    saldi = hole_salden(db, user, verbindung, client, nur_link_id)
 
-    verknuepfungen = [
-        v for v in db.query(BankAccountLink).filter(
-            BankAccountLink.connection_id == verbindung.id,
-            BankAccountLink.owner_id == user.id,
-        )
-        if v.account_id is not None
-    ]
+    verknuepfungen = [v for v in _verknuepfungen(db, user, verbindung, nur_link_id)
+                      if v.account_id is not None]
     if not verknuepfungen:
         return {"geholt": 0, "neu": 0, "saldi": saldi, "ohne_zuordnung": True}
 
@@ -468,7 +486,7 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
             continue
         # Je Konto eigen: Das eine ist bis gestern per CSV gepflegt, das andere
         # ganz neu.
-        seit = _startdatum(db, user, konto, verbindung)
+        seit = _startdatum(db, user, konto, verknuepfung)
         ab = seit if ab is None else min(ab, seit)
         for umsatz in client.umsaetze(verknuepfung.remote_uid, seit):
             geholt += 1
@@ -537,6 +555,9 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection) -> dict:
             if eingang.buche(db, user, eintrag) is not None:
                 gebucht += 1
 
+        # Der Stempel gehoert an das Konto, das gerade abgerufen wurde.
+        verknuepfung.last_sync_at = datetime.now(timezone.utc)
+
     verbindung.last_sync_at = datetime.now(timezone.utc)
     verbindung.last_error = None
     db.commit()
@@ -563,6 +584,50 @@ def _datum(umsatz: dict) -> date | None:
     return None
 
 
+def _mit_zeitzone(wert: datetime | None) -> datetime | None:
+    """SQLite gibt Zeitstempel ohne Zeitzone zurueck, auch bei ``timezone=True``.
+
+    Ohne diese Ergaenzung scheitert jeder Vergleich mit einem TypeError – und
+    zwar weit weg von der Ursache.
+    """
+    if wert is None or wert.tzinfo is not None:
+        return wert
+    return wert.replace(tzinfo=timezone.utc)
+
+
+def faellig(verbindung: BankConnection, jetzt: datetime) -> bool:
+    """Ist der automatische Abruf dieser Verbindung an der Reihe?
+
+    Bei ``poll_minutes == 0`` nie – nichts laeuft ungefragt los, denn ein Abruf
+    bucht.
+    """
+    if not verbindung.poll_minutes:
+        return False
+    zuletzt = _mit_zeitzone(verbindung.last_sync_at)
+    if zuletzt is None:
+        return True
+    return zuletzt + timedelta(minutes=verbindung.poll_minutes) <= jetzt
+
+
+def abruf_mit_fehlerbehandlung(db: Session, user: User,
+                               verbindung: BankConnection) -> dict:
+    """Wie ``hole_umsaetze``, schreibt einen Fehler aber in die Verbindung.
+
+    Und setzt dabei ``last_sync_at``: Sonst waere die Verbindung sofort wieder
+    faellig und liefe jede Minute in denselben Fehler.
+    """
+    try:
+        return hole_umsaetze(db, user, verbindung)
+    except Exception as e:                 # BankFehler und alles Unerwartete
+        log.warning("Automatischer Abruf fuer %s fehlgeschlagen: %s",
+                    verbindung.aspsp_name, e)
+        db.rollback()
+        verbindung.last_error = str(e)[:500]
+        verbindung.last_sync_at = datetime.now(timezone.utc)
+        db.commit()
+        return {"geholt": 0, "neu": 0, "gebucht": 0, "fehler": str(e)}
+
+
 def laeuft_bald_ab(verbindung: BankConnection) -> bool:
     """Läuft die Zustimmung demnächst ab?