feat: Schnellerfassung per Kurzbefehl (Etappe A)

Der Kontoauszug kommt erst am Monatsende; wer im Laden bezahlt hat, weiss in dem Moment noch, wofuer. iOS laesst keine App fremde Mitteilungen mitlesen, also fuehrt der Weg ueber einen Kurzbefehl, der die Zahlung an Certain schickt. Gebaut: - Geraetemarken mit eigener Abhaengigkeit statt Sonderfall in get_current_user. Eine Marke gilt NUR an /quick – auf allen anderen Wegen ist sie keine Anmeldung. Geht das Telefon verloren, ist kein Datenabfluss moeglich; Tests halten das fuer Buchungen, Konten, Kategorien, Export und Datenbanksicherung fest. - POST /quick/booking laeuft durch detect_rows, damit Schlagwort- und Betragsregeln die Kategorie schon vorschlagen. external_id verhindert, dass ein doppelt ausgeloester Kurzbefehl zweimal bucht. - inbox_items merkt sich die Zahlung ueber das Buchen hinaus. Beim spaeteren CSV-Import greift der Import-Schluessel nicht: Der Text vom Telefon ist selten wortgleich mit dem des Auszugs und die Bank bucht ein bis zwei Tage spaeter. detect_rows vergleicht deshalb zusaetzlich unscharf – exakter Betrag, Datum +/- 3 Tage, je Eintrag nur einmal. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-22 19:34:14 +02:00
parent 9d6a53a224
commit 02260d7cd2
9 changed files with 841 additions and 1 deletions
@@ -0,0 +1,117 @@
+"""Eingang extern erfasster Zahlungen und die Gerätemarken dafür.
+
+Der Eingang zeigt, was per Kurzbefehl (später auch per Mail) hereinkam. Die
+Einträge bleiben nach dem Buchen bestehen: Der spätere CSV-Import gleicht
+gegen sie ab, damit dieselbe Zahlung nicht ein zweites Mal verbucht wird.
+"""
+
+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, ApiToken, InboxItem, InboxStatus, Transaction, User
+from ..schemas import ApiTokenCreate, ApiTokenCreated, ApiTokenOut, InboxItemOut
+from ..security import generate_session_token, hash_session_token
+
+router = APIRouter(prefix="/inbox", tags=["inbox"])
+
+
+# --- Gerätemarken ------------------------------------------------------------
+
+
+@router.get("/tokens", response_model=list[ApiTokenOut])
+def list_tokens(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    return (
+        db.query(ApiToken)
+        .filter(ApiToken.owner_id == user.id)
+        .order_by(ApiToken.created_at.desc())
+        .all()
+    )
+
+
+@router.post("/tokens", response_model=ApiTokenCreated, status_code=status.HTTP_201_CREATED)
+def create_token(
+    payload: ApiTokenCreate,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Legt eine Marke an. Der Klartext ist NUR in dieser Antwort zu sehen."""
+    if payload.default_account_id is not None:
+        get_owned(db, Account, payload.default_account_id, user)
+    klartext = generate_session_token()
+    marke = ApiToken(
+        owner_id=user.id,
+        name=payload.name.strip(),
+        token_hash=hash_session_token(klartext),
+        default_account_id=payload.default_account_id,
+    )
+    db.add(marke)
+    db.commit()
+    db.refresh(marke)
+    return ApiTokenCreated(**ApiTokenOut.model_validate(marke).model_dump(), token=klartext)
+
+
+@router.delete("/tokens/{token_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_token(token_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    marke = get_owned(db, ApiToken, token_id, user)
+    db.delete(marke)
+    db.commit()
+
+
+# --- Eingang -----------------------------------------------------------------
+
+
+@router.get("", response_model=list[InboxItemOut])
+def list_inbox(
+    limit: int = 200,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    return (
+        db.query(InboxItem)
+        .filter(InboxItem.owner_id == user.id, InboxItem.status != InboxStatus.discarded)
+        .order_by(InboxItem.date.desc(), InboxItem.id.desc())
+        .limit(min(limit, 1000))
+        .all()
+    )
+
+
+@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.
+
+    Der Eintrag selbst bleibt als ``discarded`` stehen. Sonst wäre die Zahlung
+    beim nächsten Auszug wieder neu, obwohl der Nutzer sie bewusst weggeworfen
+    hat; so kann der Abgleich sie weiterhin erkennen.
+    """
+    eintrag = get_owned(db, InboxItem, item_id, user)
+    if eintrag.transaction_id is not None:
+        txn = db.get(Transaction, eintrag.transaction_id)
+        if txn is not None and txn.owner_id == user.id:
+            db.delete(txn)
+    eintrag.status = InboxStatus.discarded
+    eintrag.transaction_id = None
+    db.commit()
+
+
+@router.post("/{item_id}/category/{category_id}", response_model=InboxItemOut)
+def set_category(
+    item_id: int,
+    category_id: int,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Kategorie setzen – auf dem Eintrag UND auf der erzeugten Buchung."""
+    from ..models import Category
+
+    eintrag = get_owned(db, InboxItem, item_id, user)
+    kategorie = get_owned(db, Category, category_id, user)
+    eintrag.category_id = kategorie.id
+    if eintrag.transaction_id is not None:
+        txn = db.get(Transaction, eintrag.transaction_id)
+        if txn is not None and txn.owner_id == user.id:
+            txn.category_id = kategorie.id
+    db.commit()
+    db.refresh(eintrag)
+    return eintrag
@@ -0,0 +1,146 @@
+"""Schnellerfassung für Geräte ohne Anmeldung (iOS-Kurzbefehle).
+
+Der Kontoauszug kommt erst am Monatsende. Wer im Laden bezahlt hat, weiss in
+dem Moment noch, wofür – auf dem Auszug steht später oft nur ein
+nichtssagender Betreibername. Diese Endpunkte nehmen so eine Zahlung entgegen.
+
+Die Anmeldung läuft NICHT über die Sitzung, sondern über eine Gerätemarke
+(``require_quick_token``). Deren Geltungsbereich ist eng: erfassen ja, lesen
+nein. Die einzige Ausnahme ist die Kontoliste, die der Kurzbefehl für seine
+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
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..deps import require_quick_token
+from ..models import (
+    Account,
+    ApiToken,
+    InboxItem,
+    InboxSource,
+    InboxStatus,
+    Transaction,
+    TxnType,
+    User,
+)
+from ..schemas import InboxItemOut, QuickBookingIn, QuickBookingOut
+from ..services import csv_import, currency
+
+router = APIRouter(prefix="/quick", tags=["quick"])
+
+
+def _konto(db: Session, marke: ApiToken, gewuenscht: int | None) -> Account:
+    """Zielkonto bestimmen: ausdrücklich genannt, sonst das der Marke."""
+    konto_id = gewuenscht or marke.default_account_id
+    if konto_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Kein Konto angegeben und die Marke hat kein Standardkonto",
+        )
+    konto = db.get(Account, konto_id)
+    if konto is None or konto.owner_id != marke.owner_id:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Konto nicht gefunden")
+    return konto
+
+
+@router.get("/accounts")
+def quick_accounts(
+    marke: ApiToken = Depends(require_quick_token), db: Session = Depends(get_db)
+) -> list[dict]:
+    """Konten für die Auswahlliste im Kurzbefehl – ohne Salden."""
+    konten = (
+        db.query(Account)
+        .filter(Account.owner_id == marke.owner_id, Account.is_archived.is_(False))
+        .order_by(Account.position, Account.name)
+        .all()
+    )
+    return [
+        {"id": a.id, "name": a.name, "currency": a.currency, "icon": a.icon, "color": a.color,
+         "default": a.id == marke.default_account_id}
+        for a in konten
+    ]
+
+
+@router.post("/booking", response_model=QuickBookingOut, status_code=status.HTTP_201_CREATED)
+def quick_booking(
+    payload: QuickBookingIn,
+    marke: ApiToken = Depends(require_quick_token),
+    db: Session = Depends(get_db),
+) -> QuickBookingOut:
+    konto = _konto(db, marke, payload.account_id)
+    user = db.get(User, marke.owner_id)
+    tag = payload.date or date_t.today()
+
+    betrag = int(
+        (payload.amount.copy_abs() * 100).quantize(Decimal("1"), rounding=ROUND_HALF_UP)
+    )
+    if betrag == 0:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Betrag ist null")
+
+    # Ein doppelt ausgelöster Kurzbefehl (schlechtes Netz, Doppeltipp) darf
+    # nicht zweimal buchen. Die bestehende Erfassung wird zurückgemeldet.
+    if payload.external_id:
+        schon = (
+            db.query(InboxItem)
+            .filter(InboxItem.owner_id == user.id, InboxItem.source == InboxSource.shortcut,
+                    InboxItem.external_id == payload.external_id)
+            .first()
+        )
+        if schon is not None:
+            return QuickBookingOut(
+                message="Bereits erfasst", item=InboxItemOut.model_validate(schon)
+            )
+
+    # Durch die normale Erkennung schicken, damit Schlagwort- und Betragsregeln
+    # die Kategorie vorschlagen – dieselbe Strecke wie beim CSV-Import.
+    vorzeichen = -betrag if payload.kind == "expense" else betrag
+    erkannt = csv_import.detect_rows(db, user, konto, [{
+        "date": tag.isoformat(),
+        "amount_cents": vorzeichen,
+        "payee": payload.payee,
+        "purpose": payload.note,
+    }])
+    kategorie_id = erkannt[0].get("category_id") if erkannt else None
+
+    txn = Transaction(
+        owner_id=user.id,
+        type=TxnType.expense if payload.kind == "expense" else TxnType.income,
+        date=tag,
+        account_id=konto.id,
+        amount_cents=betrag,
+        amount_eur_cents=currency.compute_amount_eur_cents(db, betrag, konto.currency, tag),
+        category_id=kategorie_id,
+        payee=(payload.payee or None),
+        description=(payload.note or None),
+    )
+    db.add(txn)
+    db.flush()
+
+    eintrag = InboxItem(
+        owner_id=user.id,
+        source=InboxSource.shortcut,
+        status=InboxStatus.booked,
+        account_id=konto.id,
+        date=tag,
+        amount_cents=vorzeichen,
+        currency=konto.currency,
+        payee=(payload.payee or None),
+        note=(payload.note or None),
+        category_id=kategorie_id,
+        transaction_id=txn.id,
+        external_id=(payload.external_id or None),
+    )
+    db.add(eintrag)
+    db.commit()
+    db.refresh(eintrag)
+
+    wohin = f" · {payload.payee}" if payload.payee else ""
+    return QuickBookingOut(
+        message=f"{betrag / 100:.2f} {konto.currency} auf {konto.name}{wohin}",
+        item=InboxItemOut.model_validate(eintrag),
+    )