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?
 

backend/migrations/versions/0024_abruf_je_konto.py

@@ -0,0 +1,37 @@
+"""Abruf je Konto und ein Takt fuer den automatischen Abruf.
+
+``last_sync_at`` hing bisher nur an der Verbindung. Solange immer alle Konten
+zusammen abgerufen wurden, ging das; sobald man ein einzelnes abruft, nicht
+mehr: Der Zeitstempel schoebe das Startdatum der uebrigen Konten mit vor, und
+deren Umsaetze aus dem uebersprungenen Zeitraum kaemen nie an. Der Stempel
+gehoert deshalb an das Konto, das tatsaechlich abgerufen wurde.
+
+``poll_minutes`` ist der Takt des automatischen Abrufs, wie ihn ein Postfach
+schon hat. Vorgabe 0 – nichts laeuft ungefragt los, denn ein Abruf bucht.
+
+Revision ID: 0024
+Revises: 0023
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0024"
+down_revision = "0023"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("bank_account_links") as b:
+        b.add_column(sa.Column("last_sync_at", sa.DateTime(timezone=True), nullable=True))
+    with op.batch_alter_table("bank_connections") as b:
+        b.add_column(sa.Column("poll_minutes", sa.Integer(), nullable=False,
+                               server_default="0"))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("bank_connections") as b:
+        b.drop_column("poll_minutes")
+    with op.batch_alter_table("bank_account_links") as b:
+        b.drop_column("last_sync_at")

backend/tests/test_bank.py

@@ -13,7 +13,7 @@ die Anbindung sonst als Erstes, und der Fehler wäre von aussen nicht zu sehen.
 import base64
 import json
 import secrets
-from datetime import date
+from datetime import date, timedelta
 
 import pytest
 from cryptography.hazmat.primitives import hashes, serialization
@@ -740,3 +740,98 @@ def test_saldo_kommt_auch_ohne_zuordnung(admin, fake_bank):
     assert r.json()["saldi"] == 1
     link = [v for v in admin.get("/api/bank/links").json() if v["remote_uid"] == uid][0]
     assert link["balance_cents"] == 248000
+
+
+def test_abruf_je_konto_ruehrt_das_andere_nicht_an(admin, fake_bank):
+    """Ein Abruf bucht. Wer ein Konto abruft, will nicht, dass nebenbei auf
+    einem zweiten Buchungen entstehen."""
+    _app(admin)
+    eins, zwei = f"acc-{secrets.token_hex(4)}", f"acc-{secrets.token_hex(4)}"
+    heute = date.today().isoformat()
+    fake_bank(
+        konten=[{"uid": eins, "name": "Erstes", "currency": "EUR"},
+                {"uid": zwei, "name": "Zweites", "currency": "EUR"}],
+        umsaetze=[dict(UMSATZ, booking_date=heute)],
+    )
+    state = admin.post("/api/bank/connect",
+                       json={"aspsp_name": f"Zweikonto-{secrets.token_hex(3)}",
+                             "country": "DE"}).json()["state"]
+    admin.post(f"/api/bank/callback?state={state}&code=guter-code")
+
+    links = {v["remote_uid"]: v for v in admin.get("/api/bank/links").json()}
+    ka = _konto(admin, name=f"Konto A {secrets.token_hex(3)}", currency="EUR")
+    kb = _konto(admin, name=f"Konto B {secrets.token_hex(3)}", currency="EUR")
+    admin.post(f"/api/bank/links/{links[eins]['id']}/account/{ka['id']}")
+    admin.post(f"/api/bank/links/{links[zwei]['id']}/account/{kb['id']}")
+
+    r = admin.post(f"/api/bank/links/{links[eins]['id']}/sync")
+    assert r.status_code == 200, r.text
+    assert r.json()["gebucht"] == 1
+
+    assert admin.get(f"/api/accounts/{ka['id']}").json()["balance_cents"] == -1490
+    assert admin.get(f"/api/accounts/{kb['id']}").json()["balance_cents"] == 0, \
+        "das zweite Konto wurde angefasst"
+
+
+def test_einzelabruf_verschiebt_nicht_das_startdatum_des_anderen(admin, fake_bank):
+    """Haenge der Stempel an der Verbindung, schoebe ein Einzelabruf das
+    Startdatum der uebrigen Konten mit vor – deren Umsaetze kaemen nie an."""
+    _app(admin)
+    eins, zwei = f"acc-{secrets.token_hex(4)}", f"acc-{secrets.token_hex(4)}"
+    alt = (date.today() - timedelta(days=30)).isoformat()
+    gegenstelle = fake_bank(
+        konten=[{"uid": eins, "currency": "EUR"}, {"uid": zwei, "currency": "EUR"}],
+        umsaetze=[dict(UMSATZ, booking_date=alt)],
+    )
+    state = admin.post("/api/bank/connect",
+                       json={"aspsp_name": f"Stempel-{secrets.token_hex(3)}",
+                             "country": "DE"}).json()["state"]
+    admin.post(f"/api/bank/callback?state={state}&code=guter-code")
+    links = {v["remote_uid"]: v for v in admin.get("/api/bank/links").json()}
+    ka = _konto(admin, name=f"Stempel A {secrets.token_hex(3)}", currency="EUR")
+    kb = _konto(admin, name=f"Stempel B {secrets.token_hex(3)}", currency="EUR")
+    admin.post(f"/api/bank/links/{links[eins]['id']}/account/{ka['id']}")
+    admin.post(f"/api/bank/links/{links[zwei]['id']}/account/{kb['id']}")
+
+    admin.post(f"/api/bank/links/{links[eins]['id']}/sync")
+    # Das zweite Konto war noch nie dran – es muss weiterhin weit zurueckgreifen.
+    admin.post(f"/api/bank/links/{links[zwei]['id']}/sync")
+    assert gegenstelle.date_from < alt, f"greift nur bis {gegenstelle.date_from} zurueck"
+    assert admin.get(f"/api/accounts/{kb['id']}").json()["balance_cents"] == -1490
+
+
+def test_takt_null_laeuft_nie_und_sonst_erst_wenn_faellig(admin):
+    """Nichts laeuft ungefragt los – ein automatischer Abruf bucht."""
+    from datetime import datetime, timezone
+
+    from app.models import BankConnection
+    from app.services import bank_sync
+
+    jetzt = datetime.now(timezone.utc)
+    aus = BankConnection(owner_id=1, aspsp_name="X", aspsp_country="DE", poll_minutes=0)
+    assert bank_sync.faellig(aus, jetzt) is False
+
+    nie_gelaufen = BankConnection(owner_id=1, aspsp_name="X", aspsp_country="DE",
+                                  poll_minutes=60)
+    assert bank_sync.faellig(nie_gelaufen, jetzt) is True
+
+    frisch = BankConnection(owner_id=1, aspsp_name="X", aspsp_country="DE",
+                            poll_minutes=60,
+                            last_sync_at=jetzt - timedelta(minutes=30))
+    assert bank_sync.faellig(frisch, jetzt) is False
+
+    # SQLite gibt Zeitstempel OHNE Zeitzone zurueck – das darf nicht werfen.
+    ohne_zone = BankConnection(owner_id=1, aspsp_name="X", aspsp_country="DE",
+                               poll_minutes=60,
+                               last_sync_at=(jetzt - timedelta(hours=2)).replace(tzinfo=None))
+    assert bank_sync.faellig(ohne_zone, jetzt) is True
+
+
+def test_takt_wird_geprueft(admin, fake_bank):
+    verbindung, _, _ = _verbunden(admin, fake_bank)
+    assert admin.put(f"/api/bank/connections/{verbindung}/takt",
+                     params={"minutes": 5}).status_code == 400
+    assert admin.put(f"/api/bank/connections/{verbindung}/takt",
+                     params={"minutes": 0}).json()["poll_minutes"] == 0
+    assert admin.put(f"/api/bank/connections/{verbindung}/takt",
+                     params={"minutes": 240}).json()["poll_minutes"] == 240

web/src/api.js

@@ -228,6 +228,11 @@ export const api = {
   syncBankConnection: (id) => request(`/bank/connections/${id}/sync`, { method: "POST" }),
   refreshBankBalances: (id) =>
     request(`/bank/connections/${id}/salden`, { method: "POST" }),
+  // Nur dieses eine Konto abrufen – ein Abruf bucht, und wer ein Konto holt,
+  // will das andere nicht angefasst haben.
+  syncBankLink: (linkId) => request(`/bank/links/${linkId}/sync`, { method: "POST" }),
+  setBankPoll: (id, minutes) =>
+    request(`/bank/connections/${id}/takt?minutes=${minutes}`, { method: "PUT" }),
   deleteBankConnection: (id) => request(`/bank/connections/${id}`, { method: "DELETE" }),
   listBankLinks: () => request("/bank/links"),
   setBankLinkAccount: (linkId, accountId) =>

web/src/locales/de.json

@@ -528,7 +528,7 @@
     "transferBooked": "Als Übertrag gebucht."
   },
   "mailbox": {
-    "title": "Postfach für Zahlungs-Mails",
+    "title": "Mail Import",
     "intro": "Raiffeisen und Revolut melden Überweisungen per E-Mail. Certain holt sie ab und legt sie als Vorschlag in den Eingang – gebucht wird nur, was du abnickst. Kartenzahlungen im Laden melden die Banken nicht per Mail; dafür gibt es die Schnellerfassung per Kurzbefehl unter „Mein Konto“.",
     "add": "Postfach hinzufügen",
     "name": "Bezeichnung",
@@ -572,7 +572,7 @@
     "anyCurrency": "jede Währung"
   },
   "bank": {
-    "title": "Bankkonten direkt verbinden",
+    "title": "Bankkonten Anbindung",
     "intro": "Seit PSD2 müssen EU-Banken eine Schnittstelle anbieten – aber nur für lizenzierte Dienste. Enable Banking hält diese Lizenz und reicht sie weiter. Damit lassen sich N26 und Revolut direkt abrufen, ohne CSV. Die Schweiz fällt nicht unter PSD2; Raiffeisen bleibt beim Datei-Import.",
     "setupTitle": "Einmal einrichten",
     "setupHint": "Du brauchst eine eigene Anwendung bei Enable Banking. Mitliefern lässt sich das nicht – der Schlüssel ist an deine Registrierung gebunden.",
@@ -597,11 +597,10 @@
     "notMapped": "noch keinem Konto zugeordnet",
     "mapHint": "Ohne Zuordnung wird von diesem Konto nichts abgerufen.",
     "noAccountsFound": "Es wurden keine Konten übermittelt. Im eingeschränkten Betrieb gibt die Bank nur heraus, was du bei Enable Banking unter „Activate by linking accounts“ verknüpft hast – dort diese Bank ergänzen und hier neu verbinden.",
-    "sync": "Umsätze holen",
     "synced": "{{gebucht}} Buchungen übernommen (ab {{ab}}).",
     "noMapping": "Kein Konto zugeordnet – ordne oben zuerst zu, dann wird abgerufen.",
-    "lastSync": "zuletzt geholt am {{datum}}",
-    "neverSynced": "noch nie geholt",
+    "lastSync": "zuletzt {{when}}",
+    "neverSynced": "noch nie abgerufen",
     "lastError": "Fehler",
     "validUntil": "Zustimmung gültig bis {{datum}}",
     "expiresSoon": "Zustimmung läuft am {{datum}} ab – danach musst du neu autorisieren.",
@@ -629,7 +628,13 @@
     "balancesFetched": "{{n}} Salden aktualisiert.",
     "syncedPending": "{{n}} vorgemerkt – die kommen, sobald die Bank sie bucht.",
     "syncedTransfers": "{{n}} als Übertrag verbunden.",
-    "syncHint": "Umsätze angebundener Konten werden direkt gebucht – der Saldo stimmt damit von selbst. Übrig bleibt das Zuordnen der Kategorie."
+    "syncHint": "Umsätze angebundener Konten werden direkt gebucht – der Saldo stimmt damit von selbst. Übrig bleibt das Zuordnen der Kategorie.",
+    "syncAll": "Alle Konten holen",
+    "syncOne": "Umsätze holen",
+    "poll": "Automatisch holen",
+    "pollUnit": "Minuten (0 = aus)",
+    "pollHint": "Certain holt die Umsätze dann von selbst und bucht sie. 0 schaltet das ab; weniger als 15 Minuten lassen die Banken nicht zu.",
+    "pollSaved": "Takt gespeichert."
   },
   "bankReturn": {
     "title": "Rückkehr von der Bank",

web/src/locales/en.json

@@ -528,7 +528,7 @@
     "transferBooked": "Booked as a transfer."
   },
   "mailbox": {
-    "title": "Mailbox for payment emails",
+    "title": "Mail import",
     "intro": "Raiffeisen and Revolut send an email for transfers. Certain fetches them and puts them into the inbox as suggestions – only what you approve gets booked. Card payments in a shop are not emailed by the banks; use the shortcut capture under “My account” for those.",
     "add": "Add mailbox",
     "name": "Label",
@@ -572,7 +572,7 @@
     "anyCurrency": "any currency"
   },
   "bank": {
-    "title": "Connect bank accounts directly",
+    "title": "Bank account connection",
     "intro": "Under PSD2, EU banks must offer an interface – but only to licensed services. Enable Banking holds that licence and passes it on, so N26 and Revolut can be read directly, without CSV. Switzerland is not covered by PSD2; Raiffeisen stays on file import.",
     "setupTitle": "One-time setup",
     "setupHint": "You need your own Enable Banking application. It cannot ship with Certain – the key is bound to your registration.",
@@ -597,10 +597,9 @@
     "notMapped": "not mapped to an account yet",
     "mapHint": "Without a mapping nothing is fetched from this account.",
     "noAccountsFound": "No accounts were returned. In restricted mode the bank only releases what you linked at Enable Banking under “Activate by linking accounts” – add this bank there and reconnect here.",
-    "sync": "Fetch transactions",
     "synced": "{{gebucht}} transactions booked (from {{ab}}).",
     "noMapping": "No account mapped – map one above first, then it will fetch.",
-    "lastSync": "last fetched on {{datum}}",
+    "lastSync": "last {{when}}",
     "neverSynced": "never fetched",
     "lastError": "Error",
     "validUntil": "Consent valid until {{datum}}",
@@ -629,7 +628,13 @@
     "balancesFetched": "{{n}} balances updated.",
     "syncedPending": "{{n}} pending – they arrive once the bank books them.",
     "syncedTransfers": "{{n}} connected as transfers.",
-    "syncHint": "Transactions from connected accounts are booked directly – the balance then matches by itself. What remains is assigning a category."
+    "syncHint": "Transactions from connected accounts are booked directly – the balance then matches by itself. What remains is assigning a category.",
+    "syncAll": "Fetch all accounts",
+    "syncOne": "Fetch transactions",
+    "poll": "Fetch automatically",
+    "pollUnit": "minutes (0 = off)",
+    "pollHint": "Certain then fetches and books transactions on its own. 0 turns this off; banks do not allow less than 15 minutes.",
+    "pollSaved": "Interval saved."
   },
   "bankReturn": {
     "title": "Back from your bank",

web/src/pages/settings/Bankanbindung.jsx

@@ -113,20 +113,44 @@ export default function Bankanbindung() {
     }
   }
 
+  function meldung(r) {
+    // Vorgemerkte nicht verschweigen: Sie fehlen sonst im Saldo und niemand
+    // weiss, warum.
+    const teile = [t("bank.synced", { gebucht: r.gebucht, ab: formatDate(r.ab) })];
+    if (r.vorgemerkt > 0) teile.push(t("bank.syncedPending", { n: r.vorgemerkt }));
+    if (r.uebertraege > 0) teile.push(t("bank.syncedTransfers", { n: r.uebertraege }));
+    return teile.join(" ");
+  }
+
+  async function kontoAbrufen(l) {
+    setBusy(true);
+    try {
+      const r = await api.syncBankLink(l.id);
+      toast(r.ohne_zuordnung ? t("bank.noMapping") : meldung(r));
+      laden();
+    } catch (e) {
+      toast(e.message, "error");
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function taktSetzen(v, minuten) {
+    try {
+      await api.setBankPoll(v.id, minuten);
+      toast(t("bank.pollSaved"));
+      laden();
+    } catch (e) {
+      toast(e.message, "error");
+      laden();          // Feld auf den gespeicherten Wert zurückstellen
+    }
+  }
+
   async function abrufen(v) {
     setBusy(true);
     try {
       const r = await api.syncBankConnection(v.id);
-      if (r.ohne_zuordnung) {
-        toast(t("bank.noMapping"));
-      } else {
-        // Vorgemerkte nicht verschweigen: Sie fehlen sonst im Saldo und
-        // niemand weiss, warum.
-        const teile = [t("bank.synced", { gebucht: r.gebucht, ab: formatDate(r.ab) })];
-        if (r.vorgemerkt > 0) teile.push(t("bank.syncedPending", { n: r.vorgemerkt }));
-        if (r.uebertraege > 0) teile.push(t("bank.syncedTransfers", { n: r.uebertraege }));
-        toast(teile.join(" "));
-      }
+      toast(r.ohne_zuordnung ? t("bank.noMapping") : meldung(r));
       laden();
     } catch (e) {
       toast(e.message, "error");
@@ -277,6 +301,19 @@ export default function Bankanbindung() {
                       )}
                     </p>
                   )}
+                  {l.account_id && (
+                    <div className="mail-actions" style={{ marginTop: 4 }}>
+                      <button className="btn sm" disabled={busy}
+                              onClick={() => kontoAbrufen(l)}>
+                        {t("bank.syncOne")}
+                      </button>
+                      <span className="muted small">
+                        {l.last_sync_at
+                          ? t("bank.lastSync", { when: formatDate(l.last_sync_at) })
+                          : t("bank.neverSynced")}
+                      </span>
+                    </div>
+                  )}
                   {Object.keys(l.bank_felder || {}).length > 0 && (
                     <details className="muted small" style={{ marginTop: 4 }}>
                       <summary>{t("bank.rawFields")}</summary>
@@ -298,9 +335,22 @@ export default function Bankanbindung() {
 
           <p className="muted small">{t("bank.syncHint")}</p>
 
+          <label style={{ maxWidth: 260 }}>
+            <span>{t("bank.poll")}</span>
+            <div className="input-with-button">
+              <input type="number" min="0" max="1440" defaultValue={v.poll_minutes}
+                     onBlur={(e) => {
+                       const n = Math.max(0, Math.min(1440, Number(e.target.value) || 0));
+                       if (n !== v.poll_minutes) taktSetzen(v, n);
+                     }} />
+              <span className="muted small">{t("bank.pollUnit")}</span>
+            </div>
+          </label>
+          <p className="muted small" style={{ marginTop: -8 }}>{t("bank.pollHint")}</p>
+
           <div className="mail-actions">
             <button className="btn sm primary" disabled={busy} onClick={() => abrufen(v)}>
-              {t("bank.sync")}
+              {t("bank.syncAll")}
             </button>
             <button className="btn sm" disabled={busy} onClick={() => saldenHolen(v)}>
               {t("bank.fetchBalances")}