feat: Konto wird aus der Datei erkannt – ein Kurzbefehl genuegt

Bisher brauchte es je Konto einen eigenen Kurzbefehl, weil account_id
Pflicht war. Jetzt ist sie optional: Raiffeisen fuehrt die eigene IBAN in der
Datei mit (Treffer gegen die Erkennungs-Texte der Konten), Revolut die
Waehrung – zusammen mit der erkannten Bank und dem Import-Verlauf reicht das.

Bleibt es mehrdeutig, wird NICHT geraten: Ein Auszug im falschen Konto
verfaelscht zwei Salden auf einmal. Stattdessen nennt die Fehlermeldung die
Konten samt Nummern, sodass man sie im Kurzbefehl nachtragen kann. Hat der
Schluessel ein Standardkonto, gilt das.

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

backend/app/routers/quick.py

@@ -154,7 +154,7 @@ MAX_UPLOAD = 5 * 1024 * 1024
 @router.post("/statement", status_code=status.HTTP_201_CREATED)
 async def quick_statement(
     file: UploadFile = File(...),
-    account_id: int = Form(...),
+    account_id: int | None = Form(None),
     marke: ApiToken = Depends(require_quick_token),
     db: Session = Depends(get_db),
 ) -> dict:
@@ -165,7 +165,6 @@ async def quick_statement(
     wartet in der Import-Ansicht – dort gibt es Vorschau, Saldo-Abgleich und
     die Möglichkeit, einzelne Zeilen abzuwählen.
     """
-    konto = _konto(db, marke, account_id)
     daten = await file.read()
     if not daten:
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Datei ist leer")
@@ -176,6 +175,33 @@ async def quick_statement(
                    f"{MAX_UPLOAD // 1024 // 1024} MB)",
         )
 
+    # Ohne ausdrückliche Angabe das Konto aus der Datei ableiten – dann reicht
+    # EIN Kurzbefehl fürs Telefon statt einer je Konto.
+    if account_id is not None:
+        konto = _konto(db, marke, account_id)
+        herkunft = "angegeben"
+    else:
+        user = db.get(User, marke.owner_id)
+        erkannt = csv_import.erkenne_format(daten)
+        gefunden = csv_import.erkenne_konto(db, user, daten, erkannt)
+        if gefunden["account_id"] is None:
+            if marke.default_account_id:
+                konto = _konto(db, marke, marke.default_account_id)
+                herkunft = "Standardkonto des Schlüssels"
+            else:
+                namen = ", ".join(
+                    f"{a.name} = {a.id}" for a in db.query(Account).filter(
+                        Account.owner_id == marke.owner_id, Account.is_archived.is_(False))
+                )
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=(f"{gefunden['grund']}. Bitte account_id im Kurzbefehl "
+                            f"angeben. Deine Konten: {namen}"),
+                )
+        else:
+            konto = _konto(db, marke, gefunden["account_id"])
+            herkunft = gefunden["grund"]
+
     upload = PendingUpload(
         owner_id=marke.owner_id,
         account_id=konto.id,
@@ -190,5 +216,6 @@ async def quick_statement(
         "id": upload.id,
         "konto": konto.name,
         "size_bytes": upload.size_bytes,
-        "message": f"Empfangen für {konto.name} – zum Prüfen in Certain öffnen",
+        "erkannt_als": herkunft,
+        "message": f"Empfangen für {konto.name} ({herkunft}) – zum Prüfen in Certain öffnen",
     }

backend/app/services/csv_import.py

@@ -14,6 +14,7 @@ from sqlalchemy.orm import Session
 
 from ..models import (
     Account,
+    AccountIdentifier,
     InboxItem,
     InboxStatus,
     AmountMode,
@@ -273,6 +274,82 @@ def erkenne_format(data: bytes, encoding: str = "utf-8") -> dict:
     }
 
 
+def erkenne_konto(db: Session, user: User, data: bytes, erkannt: dict) -> dict:
+    """Zu welchem Konto gehört diese Datei?
+
+    Damit reicht EIN Kurzbefehl fürs Telefon statt einer je Konto. Zwei
+    Anhaltspunkte, in dieser Reihenfolge:
+
+    1. Eine Spalte mit der EIGENEN IBAN (Raiffeisen führt sie in Spalte 0).
+       Trifft sie einen Erkennungs-Text eines Kontos, ist die Sache eindeutig.
+    2. Die Währung der Zeilen zusammen mit der erkannten Bank. Revolut liefert
+       je Währung eine eigene Datei; welches Konto gemeint ist, verrät der
+       Import-Verlauf – dorthin ging zuletzt eine Datei derselben Bank.
+
+    Bleibt es mehrdeutig, wird NICHT geraten: Ein Auszug im falschen Konto
+    verfälscht zwei Salden auf einmal.
+    """
+    if not erkannt.get("ok"):
+        return {"account_id": None, "grund": erkannt.get("grund", "Format unbekannt")}
+
+    config = erkannt["config"]
+    text = decode_bytes(data, config.get("encoding") or "utf-8")
+    zeilen = [r for r in csv.reader(io.StringIO(text), delimiter=config["delimiter"])
+              if any((c or "").strip() for c in r)]
+    if len(zeilen) < 2:
+        return {"account_id": None, "grund": "Zu wenige Zeilen"}
+    proben = zeilen[1:31]
+
+    konten = db.query(Account).filter(Account.owner_id == user.id,
+                                      Account.is_archived.is_(False)).all()
+
+    # 1. Eigene IBAN in einer Spalte.
+    idents: dict[str, int] = {}
+    for acc_id, wert in db.query(AccountIdentifier.account_id, AccountIdentifier.value_norm).join(
+        Account, Account.id == AccountIdentifier.account_id
+    ).filter(Account.owner_id == user.id):
+        if wert:
+            idents[normalize_iban(wert)] = acc_id
+    breite = max(len(r) for r in proben)
+    for i in range(breite):
+        werte = {normalize_iban(r[i]) for r in proben if i < len(r) and r[i].strip()}
+        werte = {w for w in werte if len(w) >= 15}
+        if len(werte) == 1:
+            treffer = idents.get(next(iter(werte)))
+            if treffer:
+                return {"account_id": treffer, "grund": "eigene IBAN in der Datei",
+                        "sicher": True}
+
+    # 2. Währung plus zuletzt benutztes Konto derselben Bank.
+    waehrung_i = config["column_map"].get("currency")
+    waehrungen = set()
+    if waehrung_i is not None:
+        waehrungen = {r[waehrung_i].strip().upper()
+                      for r in proben if waehrung_i < len(r) and r[waehrung_i].strip()}
+    if len(waehrungen) == 1:
+        w = next(iter(waehrungen))
+        passend = [a for a in konten if a.currency.upper() == w]
+        if len(passend) == 1:
+            return {"account_id": passend[0].id, "grund": f"einziges Konto in {w}", "sicher": True}
+        if passend and erkannt.get("preset"):
+            frueher = {
+                b.account_id
+                for b in db.query(ImportBatch).filter(
+                    ImportBatch.owner_id == user.id,
+                    ImportBatch.preset == erkannt["preset"],
+                    ImportBatch.status == ImportStatus.committed,
+                )
+            }
+            treffer = [a for a in passend if a.id in frueher]
+            if len(treffer) == 1:
+                return {"account_id": treffer[0].id,
+                        "grund": f"{w} und zuletzt für „{erkannt['preset']}“ benutzt",
+                        "sicher": True}
+
+    return {"account_id": None,
+            "grund": "Das Konto lässt sich aus der Datei nicht sicher ableiten"}
+
+
 # --- Kleine Parser-Helfer --------------------------------------------------