feat: Bankanbindung ueber PSD2 (Backend)

Seit PSD2 muessen EU-Banken eine Schnittstelle anbieten, aber nur fuer
lizenzierte Dienste mit eIDAS-Zertifikat. Enable Banking haelt die Lizenz und
reicht sie weiter: eigene Anwendung registrieren, eigene Konten verknuepfen,
danach genau diese lesen. Deckt N26 und Revolut ab; die Schweiz faellt nicht
unter PSD2, Raiffeisen bleibt beim CSV-Weg.

Es gibt keinen API-Schluessel. Jede Anfrage traegt ein selbst gebautes JWT,
signiert mit dem privaten Schluessel der Anwendung (RS256). Signiert wird mit
cryptography, das ohnehin schon fuer die Verschluesselung im Projekt ist – der
Test prueft die Signatur echt gegen den oeffentlichen Schluessel, denn genau
daran scheitert so eine Anbindung sonst als Erstes.

Abgerufene Umsaetze werden NICHT gebucht. Sie laufen durch detect_rows und
landen als Vorschlag im Eingang – dieselbe Strecke wie Mail und Kurzbefehl,
also greifen Duplikatschutz und Schlagwortregeln ohne Sonderbehandlung. Eine
dritte Quelle, kein dritter Sonderweg.

Bewusst eng gehalten: nur Lesen; Zuordnung Bankkonto -> Konto trifft der
Nutzer; die Zuordnung verlangt dieselbe Waehrung; die Rueckleitungs-Adresse
wird eingetragen statt geraten (hinter einem Proxy sieht der Dienst "http",
obwohl der Browser HTTPS spricht) und muss HTTPS sein.

Der Ablauf der Zustimmung (bis 180 Tage) wird sichtbar gemeldet, damit der
Abruf nicht eines Tages stumm aufhoert.

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

backend/app/routers/bank.py

@@ -0,0 +1,170 @@
+"""Bankkonten über PSD2 verbinden und abrufen."""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..deps import get_current_user, get_owned
+from ..models import Account, BankAccountLink, BankApp, BankConnection, User
+from ..schemas import (
+    BankAccountLinkOut,
+    BankAppIn,
+    BankAppOut,
+    BankConnectionOut,
+    BankConnectStart,
+)
+from ..services import bank_sync, geheimnis
+from ..services.bank_api import BankFehler
+
+router = APIRouter(prefix="/bank", tags=["bank"])
+
+
+def _fehler(e: BankFehler) -> HTTPException:
+    return HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+
+
+# --- Die Anwendung dieser Installation ---------------------------------------
+
+
+@router.get("/app", response_model=BankAppOut | None)
+def get_app(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    return db.query(BankApp).filter(BankApp.owner_id == user.id).first()
+
+
+@router.put("/app", response_model=BankAppOut)
+def set_app(payload: BankAppIn, db: Session = Depends(get_db),
+            user: User = Depends(get_current_user)):
+    """Application ID, Schlüsseldatei und Rückleitungs-Adresse hinterlegen."""
+    app = db.query(BankApp).filter(BankApp.owner_id == user.id).first()
+    if app is None:
+        app = BankApp(owner_id=user.id)
+        db.add(app)
+    app.application_id = payload.application_id.strip()
+    app.private_key_enc = geheimnis.verschluesseln(payload.private_key)
+    app.base_url = payload.base_url
+    db.commit()
+    db.refresh(app)
+    return app
+
+
+@router.delete("/app", status_code=status.HTTP_204_NO_CONTENT)
+def delete_app(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    app = db.query(BankApp).filter(BankApp.owner_id == user.id).first()
+    if app is not None:
+        db.delete(app)
+        db.commit()
+
+
+@router.get("/banks")
+def list_banks(country: str, db: Session = Depends(get_db),
+               user: User = Depends(get_current_user)) -> list[dict]:
+    """Verfügbare Banken eines Landes – für die Auswahl beim Verbinden."""
+    try:
+        return bank_sync.banken(db, user, country)
+    except BankFehler as e:
+        raise _fehler(e) from e
+
+
+# --- Verbindungen ------------------------------------------------------------
+
+
+@router.get("/connections", response_model=list[BankConnectionOut])
+def list_connections(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    verbindungen = (
+        db.query(BankConnection)
+        .filter(BankConnection.owner_id == user.id, BankConnection.session_id.isnot(None))
+        .order_by(BankConnection.id)
+        .all()
+    )
+    out = []
+    for v in verbindungen:
+        eintrag = BankConnectionOut.model_validate(v)
+        eintrag.expires_soon = bank_sync.laeuft_bald_ab(v)
+        out.append(eintrag)
+    return out
+
+
+@router.post("/connect")
+def connect(payload: BankConnectStart, db: Session = Depends(get_db),
+            user: User = Depends(get_current_user)) -> dict:
+    """Autorisierung starten. Die Antwort enthält die Adresse der Bank."""
+    try:
+        return bank_sync.starte_verbindung(
+            db, user, payload.aspsp_name, payload.country, payload.psu_type)
+    except BankFehler as e:
+        raise _fehler(e) from e
+
+
+@router.post("/callback")
+def callback(state: str, code: str, db: Session = Depends(get_db),
+             user: User = Depends(get_current_user)) -> dict:
+    """Der Code von der Rückleitung wird zur Sitzung samt Kontoliste."""
+    try:
+        return bank_sync.schliesse_verbindung(db, user, state, code)
+    except BankFehler as e:
+        raise _fehler(e) from e
+
+
+@router.post("/connections/{connection_id}/sync")
+def sync(connection_id: int, db: Session = Depends(get_db),
+         user: User = Depends(get_current_user)) -> dict:
+    verbindung = get_owned(db, BankConnection, connection_id, user)
+    try:
+        return bank_sync.hole_umsaetze(db, user, verbindung)
+    except BankFehler as e:
+        verbindung.last_error = str(e)[:500]
+        db.commit()
+        raise _fehler(e) from e
+
+
+@router.delete("/connections/{connection_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_connection(connection_id: int, db: Session = Depends(get_db),
+                      user: User = Depends(get_current_user)):
+    db.delete(get_owned(db, BankConnection, connection_id, user))
+    db.commit()
+
+
+# --- Kontozuordnung ----------------------------------------------------------
+
+
+@router.get("/links", response_model=list[BankAccountLinkOut])
+def list_links(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    return (
+        db.query(BankAccountLink)
+        .filter(BankAccountLink.owner_id == user.id)
+        .order_by(BankAccountLink.id)
+        .all()
+    )
+
+
+@router.post("/links/{link_id}/account/{account_id}", response_model=BankAccountLinkOut)
+def set_link_account(link_id: int, account_id: int, db: Session = Depends(get_db),
+                     user: User = Depends(get_current_user)):
+    """Ein Bankkonto einem Konto in Certain zuordnen.
+
+    Ohne Zuordnung wird nichts abgerufen – Certain rät nicht, wohin fremde
+    Umsätze gehören.
+    """
+    verknuepfung = get_owned(db, BankAccountLink, link_id, user)
+    konto = get_owned(db, Account, account_id, user)
+    if konto.currency.upper() != verknuepfung.currency.upper():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=(f"Währungen passen nicht: Das Bankkonto führt "
+                    f"{verknuepfung.currency}, das Konto '{konto.name}' führt "
+                    f"{konto.currency}."),
+        )
+    verknuepfung.account_id = konto.id
+    db.commit()
+    db.refresh(verknuepfung)
+    return verknuepfung
+
+
+@router.delete("/links/{link_id}/account", response_model=BankAccountLinkOut)
+def clear_link_account(link_id: int, db: Session = Depends(get_db),
+                       user: User = Depends(get_current_user)):
+    verknuepfung = get_owned(db, BankAccountLink, link_id, user)
+    verknuepfung.account_id = None
+    db.commit()
+    db.refresh(verknuepfung)
+    return verknuepfung