feat: Vorschlaege buchen und Telefon-Dateien nur ablegen

Zwei Luecken geschlossen:

Mail-Vorschlaege standen als "pending" im Eingang, aber es gab keinen Knopf
zum Buchen – der Weg war hinten offen. Jetzt je Eintrag "Buchen" und ein
"Alle buchen". Unklare bleiben liegen: Bei ihnen fehlt etwas oder die
Erkennung war unsicher, die soll man ansehen statt im Stapel durchzuwinken.

Der Auszug vom Telefon bucht nicht mehr sofort, sondern wird nur abgelegt.
Am Telefon prueft man keine 500 Zeilen; die Datei wartet in der
Import-Ansicht und laeuft dort durch die normale Vorschau mit
Saldo-Abgleich, Zeilenfilter und Duplikatpruefung.

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

backend/app/models.py

@@ -23,6 +23,7 @@ from sqlalchemy import (
     Enum as SAEnum,
     ForeignKey,
     Integer,
+    LargeBinary,
     Numeric,
     String,
     Text,
@@ -744,3 +745,27 @@ class MailSender(Base):
         ForeignKey("accounts.id", ondelete="SET NULL"), nullable=True
     )
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
+
+
+class PendingUpload(Base):
+    """Eine vom Telefon abgelieferte Datei, die noch niemand geprüft hat.
+
+    Am Telefon lässt sich ein Auszug nicht sinnvoll durchsehen – hunderte
+    Zeilen mit Kategorie-Auswahl sind auf dem Bildschirm keine Erleichterung.
+    Die Datei wird deshalb nur entgegengenommen; geprüft und gebucht wird
+    später in der normalen Import-Ansicht, mit Saldo-Abgleich und allem.
+    """
+
+    __tablename__ = "pending_uploads"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    owner_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    account_id: Mapped[int] = mapped_column(
+        ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False
+    )
+    filename: Mapped[str] = mapped_column(String(255), nullable=False, default="")
+    content: Mapped[bytes] = mapped_column(LargeBinary, nullable=False)
+    size_bytes: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)

backend/app/routers/imports.py

@@ -7,7 +7,9 @@ from sqlalchemy.orm import Session
 
 from ..database import get_db
 from ..deps import get_current_user, get_owned
-from ..models import Account, AmountMode, ImportBatch, ImportStatus, ImportTemplate, User
+from fastapi.responses import Response
+
+from ..models import PendingUpload, Account, AmountMode, ImportBatch, ImportStatus, ImportTemplate, User
 from ..schemas import (
     ImportBatchOut,
     ImportCommitIn,
@@ -179,3 +181,39 @@ def remove_batch_record(
         )
     db.delete(batch)
     db.commit()
+
+
+# --- Vom Telefon abgelieferte Dateien ---------------------------------------
+
+
+@router.get("/uploads")
+def list_uploads(db: Session = Depends(get_db), user: User = Depends(get_current_user)) -> list[dict]:
+    """Wartende Dateien. Der Inhalt bleibt hier draussen – nur die Eckdaten."""
+    zeilen = (
+        db.query(PendingUpload)
+        .filter(PendingUpload.owner_id == user.id)
+        .order_by(PendingUpload.created_at.desc(), PendingUpload.id.desc())
+        .all()
+    )
+    return [
+        {"id": u.id, "filename": u.filename, "account_id": u.account_id,
+         "size_bytes": u.size_bytes, "created_at": u.created_at.isoformat() if u.created_at else None}
+        for u in zeilen
+    ]
+
+
+@router.get("/uploads/{upload_id}/content")
+def upload_content(upload_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    """Die Datei selbst – damit die Import-Ansicht sie wie eine lokale behandelt."""
+    upload = get_owned(db, PendingUpload, upload_id, user)
+    return Response(
+        content=upload.content,
+        media_type="text/csv",
+        headers={"Content-Disposition": f'attachment; filename="{upload.filename}"'},
+    )
+
+
+@router.delete("/uploads/{upload_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_upload(upload_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    db.delete(get_owned(db, PendingUpload, upload_id, user))
+    db.commit()

backend/app/routers/inbox.py

@@ -10,9 +10,18 @@ from sqlalchemy.orm import Session
 
 from ..database import get_db
 from ..deps import get_current_user, get_owned
-from ..models import Account, ApiToken, InboxItem, InboxStatus, Transaction, User
+from ..models import (
+    Account,
+    ApiToken,
+    InboxItem,
+    InboxStatus,
+    Transaction,
+    TxnType,
+    User,
+)
 from ..schemas import ApiTokenCreate, ApiTokenCreated, ApiTokenOut, InboxItemOut
 from ..security import generate_session_token, hash_session_token
+from ..services import currency
 
 router = APIRouter(prefix="/inbox", tags=["inbox"])
 
@@ -77,6 +86,68 @@ def list_inbox(
     )
 
 
+def _buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None:
+    """Aus einem Vorschlag eine Buchung machen. Ohne Konto geht es nicht."""
+    if eintrag.status == InboxStatus.booked or eintrag.transaction_id is not None:
+        return None
+    if eintrag.account_id is None:
+        return None
+    konto = db.get(Account, eintrag.account_id)
+    if konto is None or konto.owner_id != user.id:
+        return None
+    betrag = abs(eintrag.amount_cents)
+    txn = Transaction(
+        owner_id=user.id,
+        type=TxnType.expense if eintrag.amount_cents < 0 else TxnType.income,
+        date=eintrag.date,
+        account_id=konto.id,
+        amount_cents=betrag,
+        amount_eur_cents=currency.compute_amount_eur_cents(
+            db, betrag, konto.currency, eintrag.date),
+        category_id=eintrag.category_id,
+        payee=eintrag.payee,
+        description=eintrag.note,
+    )
+    db.add(txn)
+    db.flush()
+    eintrag.transaction_id = txn.id
+    eintrag.status = InboxStatus.booked
+    return txn
+
+
+@router.post("/{item_id}/book", response_model=InboxItemOut)
+def book_item(item_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    eintrag = get_owned(db, InboxItem, item_id, user)
+    if eintrag.account_id is None:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                            detail="Kein Konto zugeordnet")
+    if _buche(db, user, eintrag) is None:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+                            detail="Lässt sich nicht buchen")
+    db.commit()
+    db.refresh(eintrag)
+    return eintrag
+
+
+@router.post("/book-all")
+def book_all(db: Session = Depends(get_db), user: User = Depends(get_current_user)) -> dict:
+    """Alle offenen Vorschläge buchen, die ein Konto haben.
+
+    Unklare bleiben liegen: Bei ihnen fehlt etwas oder die Erkennung war
+    unsicher – die soll man ansehen, nicht im Stapel durchwinken.
+    """
+    offen = (
+        db.query(InboxItem)
+        .filter(InboxItem.owner_id == user.id,
+                InboxItem.status == InboxStatus.pending,
+                InboxItem.account_id.isnot(None))
+        .all()
+    )
+    gebucht = sum(1 for e in offen if _buche(db, user, e) is not None)
+    db.commit()
+    return {"gebucht": gebucht}
+
+
 @router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
 def discard_item(item_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
     """Eintrag verwerfen – samt der Buchung, die daraus entstanden ist.

backend/app/routers/quick.py

@@ -13,8 +13,6 @@ Auswahl braucht – sie liefert nur Name, Symbol und Farbe, keine Salden.
 from datetime import date as date_t
 from decimal import ROUND_HALF_UP, Decimal
 
-import json
-
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
 from sqlalchemy.orm import Session
 
@@ -23,13 +21,11 @@ from ..deps import require_quick_token
 from ..models import (
     Account,
     ApiToken,
-    ImportBatch,
-    ImportStatus,
-    ImportTemplate,
     InboxItem,
     InboxSource,
     InboxStatus,
     Transaction,
+    PendingUpload,
     TxnType,
     User,
 )
@@ -151,34 +147,8 @@ def quick_booking(
     )
 
 
-def _letzte_vorlage(db: Session, konto: Account) -> ImportTemplate | None:
-    """Die Einstellung, mit der dieses Konto zuletzt erfolgreich eingelesen wurde.
-
-    Am Telefon lässt sich keine Spaltenzuordnung vornehmen. Der Kurzbefehl
-    setzt deshalb voraus, dass die Datei am Rechner schon einmal für dieses
-    Konto eingelesen wurde – dann steht im Import-Verlauf, wie es ging.
-    """
-    stapel = (
-        db.query(ImportBatch)
-        .filter(ImportBatch.owner_id == konto.owner_id,
-                ImportBatch.account_id == konto.id,
-                ImportBatch.status == ImportStatus.committed)
-        .order_by(ImportBatch.created_at.desc(), ImportBatch.id.desc())
-        .first()
-    )
-    if stapel is None:
-        return None
-    if stapel.template_id:
-        vorlage = db.get(ImportTemplate, stapel.template_id)
-        if vorlage is not None and vorlage.owner_id == konto.owner_id:
-            return vorlage
-    if stapel.preset:
-        for p in csv_import.PRESETS:
-            if p["name"] == stapel.preset:
-                felder = {k: v for k, v in p.items() if k not in ("name", "column_map")}
-                return ImportTemplate(owner_id=konto.owner_id, name="_kurzbefehl",
-                                      column_map=json.dumps(p["column_map"]), **felder)
-    return None
+# Grosszuegig, aber nicht unbegrenzt: Ein Jahresauszug liegt weit darunter.
+MAX_UPLOAD = 5 * 1024 * 1024
 
 
 @router.post("/statement", status_code=status.HTTP_201_CREATED)
@@ -188,43 +158,37 @@ async def quick_statement(
     marke: ApiToken = Depends(require_quick_token),
     db: Session = Depends(get_db),
 ) -> dict:
-    """Kontoauszug vom Telefon aus einlesen (Teilen-Menü).
+    """Kontoauszug vom Telefon entgegennehmen (Teilen-Menü).
 
-    Gebucht wird sofort – ein Auszug hat schnell hunderte Zeilen, die einzeln
-    abzunicken wäre keine Erleichterung. Sicher ist das, weil die
-    Duplikaterkennung greift und der ganze Stapel im Import-Verlauf mit einem
-    Klick rückgängig zu machen ist.
+    Hier wird NICHT gebucht. Ein Auszug hat schnell hunderte Zeilen; die am
+    Telefon durchzusehen wäre keine Erleichterung. Die Datei wird abgelegt und
+    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)
-    user = db.get(User, marke.owner_id)
-    vorlage = _letzte_vorlage(db, konto)
-    if vorlage is None:
+    daten = await file.read()
+    if not daten:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Datei ist leer")
+    if len(daten) > MAX_UPLOAD:
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(f"Für „{konto.name}“ gibt es noch keine Einstellung. Bitte einen Auszug "
-                    "dieses Kontos einmal am Rechner einlesen – danach geht es vom Telefon."),
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f"Datei zu gross ({len(daten) // 1024} KB, erlaubt sind "
+                   f"{MAX_UPLOAD // 1024 // 1024} MB)",
         )
 
-    daten = await file.read()
-    try:
-        kandidaten = csv_import.parse_file_to_candidates(daten, vorlage)
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
-                            detail=f"Datei nicht lesbar: {e}") from e
-
-    zeilen = csv_import.detect_rows(db, user, konto, kandidaten)
-    zu_buchen = [z for z in zeilen if z.get("include")]
-    stapel = csv_import.commit_import(
-        db, user, konto, vorlage.id if vorlage.id else None,
-        (file.filename or "Vom Telefon")[:255], zu_buchen,
-        preset=None if vorlage.id else vorlage.name,
+    upload = PendingUpload(
+        owner_id=marke.owner_id,
+        account_id=konto.id,
+        filename=(file.filename or "Vom Telefon")[:255],
+        content=daten,
+        size_bytes=len(daten),
     )
-    dubletten = sum(1 for z in zeilen if z.get("is_duplicate"))
+    db.add(upload)
+    db.commit()
+    db.refresh(upload)
     return {
-        "gelesen": len(zeilen),
-        "gebucht": stapel.imported_count,
-        "duplikate": dubletten,
+        "id": upload.id,
         "konto": konto.name,
-        "message": f"{stapel.imported_count} gebucht auf {konto.name}"
-                   f" · {dubletten} schon vorhanden",
+        "size_bytes": upload.size_bytes,
+        "message": f"Empfangen für {konto.name} – zum Prüfen in Certain öffnen",
     }