feat: Bank ueber alle Laender suchen

Unter "Deutschland" liessen sich N26 und Revolut nicht finden – und bei
Revolut kann das gar nicht klappen: Die Bank vergibt deutsche IBANs, ist aber
die Revolut Bank UAB in Litauen. Das Sitzland einer Bank steht nicht in der
IBAN, also ist die Laenderauswahl der falsche Einstieg.

Jetzt ein Suchfeld, das ohne Land ueber alle sucht; das Land ist nur noch ein
optionaler Filter. Der Treffer zeigt sein Land mit an, und verbunden wird mit
dem Land der BANK statt dem des Filters – sonst schluege die Autorisierung
fehl, sobald ohne Land gesucht wurde.

Ohne Land UND ohne Begriff wird abgelehnt: Sonst kaemen alle Banken Europas
ins Formular.

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

backend/app/routers/bank.py

@@ -56,11 +56,21 @@ def delete_app(db: Session = Depends(get_db), user: User = Depends(get_current_u
 
 
 @router.get("/banks")
-def list_banks(country: str, db: Session = Depends(get_db),
+def list_banks(country: str | None = None, search: str | None = None,
+               db: Session = Depends(get_db),
                user: User = Depends(get_current_user)) -> list[dict]:
-    """Verfügbare Banken eines Landes – für die Auswahl beim Verbinden."""
+    """Banken suchen – in einem Land oder über alle hinweg.
+
+    Ohne ``country`` wird überall gesucht. Das braucht es, weil die IBAN nicht
+    verrät, wo eine Bank sitzt: Revolut vergibt deutsche IBANs aus Litauen.
+    """
+    if not country and not search:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Bitte ein Land wählen oder einen Suchbegriff eingeben.",
+        )
     try:
-        return bank_sync.banken(db, user, country)
+        return bank_sync.banken(db, user, country, search)
     except BankFehler as e:
         raise _fehler(e) from e
 

backend/app/services/bank_api.py

@@ -108,10 +108,15 @@ class BankClient:
 
     # --- Die vier Endpunkte -------------------------------------------------
 
-    def banken(self, land: str) -> list[dict]:
-        """Verfügbare Banken eines Landes – für die Auswahl beim Verbinden."""
-        daten = self._anfrage("GET", f"/aspsps?country={land.upper()}")
-        return daten.get("aspsps", [])
+    def banken(self, land: str | None = None) -> list[dict]:
+        """Verfügbare Banken – eines Landes oder alle.
+
+        Ohne Land liefert die Schnittstelle die vollständige Liste. Das ist
+        nötig, weil das Sitzland einer Bank nicht an der IBAN ablesbar ist:
+        Revolut gibt deutsche IBANs aus, ist aber in Litauen ansässig.
+        """
+        pfad = f"/aspsps?country={land.upper()}" if land else "/aspsps"
+        return self._anfrage("GET", pfad).get("aspsps", [])
 
     def starte_autorisierung(self, aspsp_name: str, land: str, redirect_url: str,
                              state: str, tage: int, psu_type: str = "personal") -> dict:

backend/app/services/bank_sync.py

@@ -60,14 +60,32 @@ def _client(db: Session, user: User) -> BankClient:
     return BankClient(app.application_id, schluessel)
 
 
-def banken(db: Session, user: User, land: str) -> list[dict]:
-    """Banken eines Landes, auf das Nötige eingedampft."""
+# Nicht die ganze Liste ins Formular kippen – über alle Länder sind es
+# tausende. Wer sucht, bekommt Treffer; wer ein Land wählt, dessen Banken.
+MAX_TREFFER = 200
+
+
+def banken(db: Session, user: User, land: str | None = None,
+           suche: str | None = None) -> list[dict]:
+    """Banken suchen – in einem Land oder über alle hinweg.
+
+    Die Suche über alle Länder ist kein Luxus: Das Sitzland einer Bank steht
+    nicht in der IBAN. Revolut gibt deutsche IBANs aus, ist aber in Litauen
+    ansässig – wer unter „Deutschland" sucht, findet es dort nie.
+    """
     roh = _client(db, user).banken(land)
-    return [
-        {"name": b.get("name"), "country": b.get("country"),
-         "logo": b.get("logo"), "psu_types": b.get("psu_types", [])}
-        for b in roh if b.get("name")
-    ]
+    begriff = (suche or "").strip().lower()
+    treffer = []
+    for b in roh:
+        name = b.get("name")
+        if not name:
+            continue
+        if begriff and begriff not in name.lower():
+            continue
+        treffer.append({"name": name, "country": b.get("country"),
+                        "logo": b.get("logo"), "psu_types": b.get("psu_types", [])})
+    treffer.sort(key=lambda b: (b["name"].lower(), b.get("country") or ""))
+    return treffer[:MAX_TREFFER]
 
 
 def starte_verbindung(db: Session, user: User, aspsp_name: str, land: str,