certain/backend/app/routers/quick.py

"""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),
    )