Scarriffle/certain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: Uebertrag pruefen, ob die Gegenseite schon gebucht ist

Browse Source 
Ein Franken-in-Euro-Tausch stand zweimal da: die CHF-Seite als Uebertrag nach
Revolut Euro, die EUR-Seite weiterhin als eigene Einnahme. Revolut Euro war
damit doppelt gutgeschrieben. Drei Fehler auf einmal.

Erstens prueft "zum Uebertrag machen" jetzt, ob die Buchung bereits mit ihrer
Gegenseite VERBUNDEN ist. Dann sind beide Seiten gebucht und zaehlen schon in
keiner Auswertung; ein Uebertrag bewegt das Geld auf dem Zielkonto ein zweites
Mal. Das laesst sich auch nicht mit "trotzdem" wegdruecken – es ist nicht
Ansichtssache.

Zweitens wird auf dem Zielkonto nach einer passenden gebuchten Gegenseite
gesehen, auch ohne Verknuepfung: gleiche Tage, passender Betrag, ueber
Waehrungen hinweg mit Spielraum. Findet sich eine, kommt die Warnung samt dem
richtigen Weg – die beiden verbinden statt einen Uebertrag anzulegen. Der
Treffer ist unscharf, deshalb hier mit "trotzdem" uebergehbar.

Drittens der beobachtete Punkt: Der nachtraegliche Weg reichte den
Eingangs-Eintrag nicht durch und rechnete deshalb IMMER mit dem EZB-Kurs, auch
wenn die Bank ihren eigenen genannt hatte. Jetzt wird er nachgeschlagen, und
der Kurs der Bank landet an der Buchung.

Und Loeschen raeumt die Eingangs-Eintraege mit. Der Fremdschluessel setzt sonst
nur ihre Verweisspalte auf NULL, und sie blieben als "gebucht" ohne Buchung
stehen – bei einem Uebertrag sind das zwei.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Guido
2026-08-27 11:22:13 +02:00
co-authored by Claude Opus 5
parent 8cb82da63c
commit 6cd1c100c0
3 changed files with 198 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app/routers/transactions.py
+17 -1
View File
@@ -13,7 +13,15 @@ from sqlalchemy.orm import Session
from ..database import get_db
from ..deps import get_current_user, get_owned
from ..models import Account, Category, Transaction, TxnType, User
from ..models import (
Account,
Category,
InboxItem,
InboxStatus,
Transaction,
TxnType,
User,
)
from ..schemas import TransactionCreate, TransactionOut, TransactionUpdate
from ..services import buchung, currency, uebertrag_buchen
from ..services.uebertrag_buchen import UebertragFehler
@@ -246,5 +254,13 @@ def delete_transaction(
txn_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)
):
txn = get_owned(db, Transaction, txn_id, user)
# Eingangs-Eintraege, die auf diese Buchung zeigen, mit verwerfen. Der
# Fremdschluessel setzt sonst nur ihre Verweisspalte auf NULL, und sie
# blieben als "gebucht" ohne Buchung stehen – bei einem Uebertrag sind das
# zwei, die Quelle und die Gegenseite.
for eintrag in db.query(InboxItem).filter(InboxItem.owner_id == user.id,
InboxItem.transaction_id == txn.id):
eintrag.status = InboxStatus.discarded
eintrag.transaction_id = None
db.delete(txn)
db.commit()
backend/app/services/uebertrag_buchen.py
+99 -1
View File
@@ -27,6 +27,8 @@ anlegt, waehlt beide Konten bewusst und hat keine Gegenseite, die noch kommt.
from __future__ import annotations
from datetime import timedelta
from sqlalchemy.orm import Session
from ..models import (
@@ -36,10 +38,13 @@ from ..models import (
InboxSource,
InboxStatus,
Transaction,
TransferLink,
TxnType,
User,
)
from . import buchung, csv_import, currency
from .csv_import import INBOX_TAGE
from .uebertraege import FX_TOLERANZ
class UebertragFehler(RuntimeError):
@@ -64,6 +69,74 @@ def ist_angebunden(db: Session, user: User, konto: Account) -> bool:
).first() is not None
def _eingang_zu(db: Session, user: User, txn: Transaction) -> InboxItem | None:
"""Der Eingangs-Eintrag, aus dem diese Buchung entstand.
Er traegt, was die Bank ueber die Umrechnung gesagt hat. Ohne ihn bliebe
nur der EZB-Kurs – auch dann, wenn die Bank ihren eigenen genannt hat.
"""
return db.query(InboxItem).filter(
InboxItem.owner_id == user.id,
InboxItem.transaction_id == txn.id,
InboxItem.account_id == txn.account_id,
).first()
def _schon_verknuepft(db: Session, user: User, txn: Transaction) -> bool:
"""Haengt diese Buchung schon als Paar an ihrer Gegenseite?"""
return db.query(TransferLink.id).filter(
TransferLink.owner_id == user.id,
(TransferLink.from_txn_id == txn.id) | (TransferLink.to_txn_id == txn.id),
).first() is not None
def _gebuchte_gegenseite(db: Session, user: User, konto: Account, ziel: Account,
eigener_typ: TxnType, erwartet: int | None, datum,
exakt: bool) -> Transaction | None:
"""Steht auf dem Zielkonto schon eine passende Buchung?
Dann waere ein Uebertrag falsch: Er wuerde das Geld dort ein zweites Mal
bewegen. Richtig ist in dem Fall, die beiden zu VERKNUEPFEN – beide
Buchungen bleiben stehen und zaehlen nur nicht mehr in der Auswertung.
Ueber Waehrungen hinweg wird mit Spielraum verglichen: Der erwartete Betrag
ist dann gerechnet, der echte kommt von der Bank.
"""
if not erwartet:
return None
gegen_typ = TxnType.income if eigener_typ == TxnType.expense else TxnType.expense
spielraum = 0 if exakt else max(1, round(erwartet * FX_TOLERANZ))
return next(
(k for k in db.query(Transaction).filter(
Transaction.owner_id == user.id,
Transaction.account_id == ziel.id,
Transaction.type == gegen_typ,
Transaction.date >= datum - timedelta(days=INBOX_TAGE),
Transaction.date <= datum + timedelta(days=INBOX_TAGE),
) if abs(k.amount_cents - erwartet) <= spielraum),
None,
)
def _pruefe_gegenseite(db: Session, user: User, konto: Account, ziel: Account,
eigener_typ: TxnType, erwartet: int | None, datum,
exakt: bool, trotzdem: bool) -> None:
if trotzdem:
return
schon = _gebuchte_gegenseite(db, user, konto, ziel, eigener_typ, erwartet,
datum, exakt)
if schon is None:
return
raise UebertragFehler(
f"Auf '{ziel.name}' steht schon eine passende Buchung vom "
f"{schon.date.strftime('%d.%m.%Y')}. Beide Seiten sind also bereits "
f"gebucht – ein Übertrag würde das Geld dort ein zweites Mal bewegen. "
f"Richtig ist hier, die beiden zu verbinden: Sie bleiben stehen und "
f"zählen nur nicht mehr als Ausgabe und Einnahme.",
nachfragen=True,
)
def _gegenbetrag(db: Session, konto: Account, ziel: Account, betrag: int,
datum, eintrag: InboxItem | None = None,
) -> tuple[int | None, float | None, bool]:
@@ -203,6 +276,10 @@ def aus_eingang(db: Session, user: User, eintrag: InboxItem, ziel: Account,
betrag = abs(eintrag.amount_cents)
ziel_betrag, kurs, exakt = _gegenbetrag(db, konto, ziel, betrag, eintrag.date, eintrag)
_pruefe(db, user, konto, ziel, exakt, trotzdem)
_pruefe_gegenseite(
db, user, konto, ziel,
TxnType.expense if eintrag.amount_cents < 0 else TxnType.income,
ziel_betrag, eintrag.date, exakt, trotzdem)
txn = _lege_an(db, user, konto, ziel, eintrag.amount_cents, ziel_betrag,
eintrag.date, eintrag.payee, eintrag.note, kurs)
@@ -227,9 +304,28 @@ def aus_buchung(db: Session, user: User, txn: Transaction, ziel: Account,
if konto is None or konto.owner_id != user.id:
raise UebertragFehler("Buchung ohne Konto")
# Ist sie schon mit ihrer Gegenseite verknuepft, sind BEIDE gebucht. Ein
# Uebertrag wuerde das Geld auf dem Zielkonto ein zweites Mal bewegen –
# und das laesst sich nicht mit "trotzdem" wegdruecken, es ist einfach
# falsch.
if _schon_verknuepft(db, user, txn):
raise UebertragFehler(
"Diese Buchung ist bereits mit ihrer Gegenseite verbunden – beide "
"Seiten sind gebucht und zählen schon jetzt in keiner Auswertung. "
"Ein Übertrag würde das Geld auf dem Zielkonto ein zweites Mal "
"bewegen. Wenn du es wirklich anders willst, löse zuerst die "
"Verknüpfung."
)
signiert = txn.amount_cents if txn.type == TxnType.income else -txn.amount_cents
ziel_betrag, _kurs, exakt = _gegenbetrag(db, konto, ziel, abs(signiert), txn.date)
# Der Eingangs-Eintrag traegt den Kurs der Bank – ohne ihn bliebe hier nur
# die EZB-Naeherung, auch wenn die Bank ihren eigenen genannt hat.
eintrag = _eingang_zu(db, user, txn)
ziel_betrag, kurs, exakt = _gegenbetrag(db, konto, ziel, abs(signiert),
txn.date, eintrag)
_pruefe(db, user, konto, ziel, exakt, trotzdem)
_pruefe_gegenseite(db, user, konto, ziel, txn.type, ziel_betrag, txn.date,
exakt, trotzdem)
# Die vorhandene Buchung umschreiben statt eine zweite anzulegen: Alles, was
# auf sie zeigt – Eingangs-Eintrag, Verknuepfungen – bleibt damit gueltig.
@@ -244,6 +340,8 @@ def aus_buchung(db: Session, user: User, txn: Transaction, ziel: Account,
txn.account_id = von.id
txn.to_account_id = nach.id
txn.category_id = None
if kurs:
txn.fx_rate = kurs # der Kurs der Bank schlaegt die EZB
buchung.setze_betraege(db, txn, von, nach)
db.flush()
backend/tests/test_inbox.py
+82
View File
@@ -351,3 +351,85 @@ def test_api_antworten_werden_nicht_zwischengespeichert(admin):
assert r.headers.get("cache-control") == "no-store"
r = admin.get("/api/accounts")
assert r.headers.get("cache-control") == "no-store"
def test_verknuepfte_buchung_wird_nicht_zum_uebertrag(admin):
"""Sind beide Seiten gebucht und verbunden, waere ein Uebertrag falsch: Er
bewegt das Geld auf dem Zielkonto ein zweites Mal."""
a = _konto(admin, name=f"Verk-A {secrets.token_hex(3)}", currency="CHF")
b = _konto(admin, name=f"Verk-B {secrets.token_hex(3)}", currency="CHF")
betrag = 11000 + secrets.randbelow(900)
raus = admin.post("/api/transactions", json={
"type": "expense", "date": "2026-08-15", "account_id": a["id"],
"amount_cents": betrag, "payee": "Umbuchung"}).json()
rein = admin.post("/api/transactions", json={
"type": "income", "date": "2026-08-15", "account_id": b["id"],
"amount_cents": betrag, "payee": "Umbuchung"}).json()
assert admin.post("/api/uebertraege/verbinden",
json={"a_id": raus["id"], "b_id": rein["id"]}).status_code == 200
r = admin.post(f"/api/transactions/{raus['id']}/transfer",
json={"to_account_id": b["id"]})
assert r.status_code == 400, r.text
assert "verbunden" in r.json()["detail"]
# Auch mit "trotzdem" nicht – es ist nachweislich falsch, keine Ansichtssache.
r = admin.post(f"/api/transactions/{raus['id']}/transfer",
json={"to_account_id": b["id"], "trotzdem": True})
assert r.status_code == 400
def test_schon_gebuchte_gegenseite_wird_gemeldet(admin):
"""Ohne diese Warnung stuende das Geld auf dem Zielkonto zweimal."""
a = _konto(admin, name=f"Doppel-A {secrets.token_hex(3)}", currency="CHF")
b = _konto(admin, name=f"Doppel-B {secrets.token_hex(3)}", currency="CHF")
betrag = 12000 + secrets.randbelow(900)
raus = admin.post("/api/transactions", json={
"type": "expense", "date": "2026-08-16", "account_id": a["id"],
"amount_cents": betrag}).json()
# Die Gegenseite liegt schon gebucht auf B – nur eben unverbunden.
admin.post("/api/transactions", json={
"type": "income", "date": "2026-08-17", "account_id": b["id"],
"amount_cents": betrag})
r = admin.post(f"/api/transactions/{raus['id']}/transfer",
json={"to_account_id": b["id"]})
assert r.status_code == 409, r.text
assert "verbinden" in r.json()["detail"]
assert admin.get(f"/api/accounts/{b['id']}").json()["balance_cents"] == betrag
# Der Treffer ist unscharf (Datum, Betrag) – wer es besser weiss, kommt durch.
r = admin.post(f"/api/transactions/{raus['id']}/transfer",
json={"to_account_id": b["id"], "trotzdem": True})
assert r.status_code == 200, r.text
def test_uebertrag_nimmt_den_kurs_der_bank_auch_nachtraeglich(admin):
"""Der Eingangs-Eintrag traegt den Kurs. Ohne ihn bliebe hier nur die
EZB-Naeherung – und die passt nicht auf den Rappen."""
from app.database import SessionLocal
from app.models import InboxItem
chf = _konto(admin, name=f"Kurs-CHF {secrets.token_hex(3)}", currency="CHF")
eur = _konto(admin, name=f"Kurs-EUR {secrets.token_hex(3)}", currency="EUR")
txn = admin.post("/api/transactions", json={
"type": "expense", "date": "2026-08-18", "account_id": chf["id"],
"amount_cents": 40000, "payee": "Exchanged to EUR"}).json()
# So sieht es aus, wenn die Bank ihren Kurs mitgeliefert hat.
db = SessionLocal()
try:
db.add(InboxItem(
owner_id=admin.get("/api/auth/me").json()["id"],
source="bank", status="booked", account_id=chf["id"],
date=__import__("datetime").date(2026, 8, 18), amount_cents=-40000,
currency="CHF", payee="Exchanged to EUR", transaction_id=txn["id"],
counter_amount_cents=42532, counter_currency="EUR"))
db.commit()
finally:
db.close()
r = admin.post(f"/api/transactions/{txn['id']}/transfer",
json={"to_account_id": eur["id"]})
assert r.status_code == 200, r.text
assert r.json()["to_amount_cents"] == 42532, "der Betrag der Bank, nicht der gerechnete"
assert admin.get(f"/api/accounts/{eur['id']}").json()["balance_cents"] == 42532