fix: Die Kennung der Bank steht jetzt an der Buchung selbst

Bisher lag sie nur am Eingangs-Eintrag. Das reicht nicht: Der Eintrag ist eine
Zwischenstation und faellt weg, wenn ein Konto geloescht wird oder ein aelteres
Backup ihn nicht kannte. Dann war die Zahlung fuer den naechsten Abruf neu,
obwohl sie laengst gebucht war.

Am schlimmsten bei einem als Uebertrag gebuchten Umsatz: Der ist von der
Aehnlichkeitspruefung ausgenommen, dort griff also gar nichts mehr.

Die Kennung gehoert deshalb an die Buchung (transactions.source_uid, mit der
Quelle davor). Dort ueberlebt sie alles, was mit dem Eingang passiert, und die
Eindeutigkeit haelt die Datenbank selbst durch – nicht erst der pruefende Code
davor. Gestempelt wird an allen drei Buchungswegen: Eingang, Kurzbefehl und
Uebertrag.

Vorhandene Buchungen bekommen die Kennung nachgetragen, solange ihr
Eingangs-Eintrag noch da ist.

Ohne Kennung – von Hand erfasst, aus einer CSV-Datei – bleibt es beim
bisherigen Schutz ueber die Aehnlichkeit.

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

backend/app/models.py

@@ -23,6 +23,7 @@ from sqlalchemy import (
     DateTime,
     Enum as SAEnum,
     ForeignKey,
+    Index,
     Integer,
     LargeBinary,
     Numeric,
@@ -370,9 +371,44 @@ class Transaction(Base):
     )
     import_hash: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
 
+    # Die Kennung, unter der die Quelle diese Zahlung fuehrt – bei der Bank die
+    # des Umsatzes, mit der Quelle davor ("bank:…", "mail:…", "shortcut:…").
+    #
+    # Sie steht bewusst HIER und nicht nur am Eingangs-Eintrag. Der Eintrag ist
+    # eine Zwischenstation: Er kann verschwinden, weil ein Konto neu verbunden
+    # wurde, weil ein aelteres Backup ihn nicht kannte, weil jemand aufgeraeumt
+    # hat. Die Buchung bleibt. Solange die Kennung an der Buchung haengt, kann
+    # dieselbe Zahlung kein zweites Mal hereinkommen – und zwar unabhaengig
+    # davon, ob der pruefende Code davor daran gedacht hat: Die Eindeutigkeit
+    # weiter unten laesst es gar nicht zu.
+    #
+    # Leer bleibt sie bei allem, was keine Kennung mitbringt: von Hand erfasst,
+    # aus einer CSV-Datei. Dort schuetzt weiterhin nur ``import_hash``, und das
+    # ist eine Aehnlichkeit, keine Kennung.
+    #
+    # 320 statt 255: Die Kennung der Quelle darf selbst schon 255 lang sein,
+    # der Name der Quelle davor kostet ein paar Zeichen mehr. Abschneiden waere
+    # hier die falsche Sparsamkeit – zwei abgeschnittene Kennungen saehen
+    # gleich aus, und dann verschluckt eine Zahlung die andere.
+    source_uid: Mapped[str | None] = mapped_column(String(320), nullable=True)
+
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
     updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now, onupdate=_now)
 
+    __table_args__ = (
+        # Ein eindeutiger INDEX, keine UNIQUE-Spaltenregel: Letztere zwingt
+        # SQLite dazu, die Tabelle neu zu bauen – und dabei reisst das
+        # implizite DELETE die abhaengigen Zeilen ueber ON DELETE CASCADE mit
+        # (Uebertrags-Verknuepfungen, abgelehnte Vorschlaege). Siehe
+        # tests/test_migrations.py. Der Index haelt dasselbe durch, ohne die
+        # Tabelle anzufassen.
+        #
+        # NULL zaehlt in SQL nicht als gleich – Buchungen ohne Kennung stehen
+        # sich also nicht gegenseitig im Weg. Genau das ist gewollt: Die Regel
+        # greift nur dort, wo es wirklich eine Kennung gibt.
+        Index("uq_txn_owner_source_uid", "owner_id", "source_uid", unique=True),
+    )
+
 
 class ExchangeRate(Base):
     """EZB-Referenzkurs: wie viele Einheiten der Währung ein Euro wert war.

backend/app/routers/quick.py

@@ -30,7 +30,7 @@ from ..models import (
     User,
 )
 from ..schemas import InboxItemOut, QuickBookingIn, QuickBookingOut
-from ..services import csv_import, currency
+from ..services import csv_import, currency, eingang
 
 router = APIRouter(prefix="/quick", tags=["quick"])
 
@@ -118,6 +118,10 @@ def quick_booking(
         category_id=kategorie_id,
         payee=(payload.payee or None),
         description=(payload.note or None),
+        # Die Kennung des Kurzbefehls gehoert auch an die Buchung, nicht nur an
+        # den Eingangs-Eintrag darueber: Nur dort ueberlebt sie, wenn der
+        # Eintrag einmal wegfaellt.
+        source_uid=eingang.quell_kennung(InboxSource.shortcut, payload.external_id),
     )
     db.add(txn)
     db.flush()

backend/app/services/backup_data.py

@@ -362,8 +362,13 @@ _MERGE_KEYS: dict[str, Callable[[dict], tuple | None]] = {
     "import_templates": lambda r: ("name", (r.get("name") or "").strip().lower()),
     "import_batches": lambda r: ("batch", r.get("account_id"), r.get("filename"),
                                  r.get("created_at")),
+    # Die Kennung der Quelle zuerst: Sie ist die einzige EXAKTE Aussage, dass
+    # zwei Zeilen dieselbe Zahlung sind – und ohne sie liefe „Ergaenzen" gegen
+    # die Eindeutigkeit von (owner_id, source_uid), statt die Zeile zu
+    # erkennen. Erst danach der Aehnlichkeits-Schluessel.
     "transactions": lambda r: (
-        ("hash", r["import_hash"]) if r.get("import_hash")
+        ("uid", r["source_uid"]) if r.get("source_uid")
+        else ("hash", r["import_hash"]) if r.get("import_hash")
         else ("nat", r.get("date"), r.get("account_id"), r.get("amount_cents"),
               (r.get("payee") or "").strip().lower())
     ),

backend/app/services/bank_sync.py

@@ -673,6 +673,15 @@ def hole_umsaetze(db: Session, user: User, verbindung: BankConnection,
                         InboxItem.external_id.in_(kennungen))
                 .first()
             )
+            if schon is None:
+                # Und dann noch an den BUCHUNGEN selbst. Der Eingangs-Eintrag
+                # ist eine Zwischenstation: Er faellt weg, wenn ein Konto
+                # geloescht wird, und aeltere Backups kannten ihn nicht. Die
+                # Buchung bleibt – und traegt die Kennung seit 0027 selbst.
+                schon = eingang.gebuchte_mit_kennung(
+                    db, user,
+                    [eingang.quell_kennung(InboxSource.bank, k) for k in kennungen],
+                )
             if schon is not None:
                 continue
             kennung = kennungen[0]

backend/app/services/eingang.py

@@ -15,6 +15,7 @@ from sqlalchemy.orm import Session
 from ..models import (
     Account,
     InboxItem,
+    InboxSource,
     InboxStatus,
     Transaction,
     TxnType,
@@ -25,6 +26,35 @@ from . import currency
 log = logging.getLogger(__name__)
 
 
+def quell_kennung(source: InboxSource, external_id: str | None) -> str | None:
+    """Die Kennung, wie sie an der Buchung steht – oder None ohne Kennung.
+
+    Der Name der Quelle gehoert davor: Eine Nachrichten-Kennung aus dem
+    Postfach und eine Umsatzkennung der Bank duerfen nie zufaellig gleich
+    lauten, sonst verschluckt die eine Zahlung die andere.
+    """
+    if not external_id:
+        return None
+    return f"{source.value}:{external_id}"[:320]
+
+
+def gebuchte_mit_kennung(db: Session, user: User,
+                         kennungen: list[str | None]) -> Transaction | None:
+    """Die Buchung zu einer dieser Kennungen, falls es sie schon gibt.
+
+    Der Weg an ``inbox_items`` vorbei ist der Punkt: Der Eingangs-Eintrag ist
+    eine Zwischenstation und kann fehlen, die Buchung bleibt.
+    """
+    werte = [k for k in kennungen if k]
+    if not werte:
+        return None
+    return (
+        db.query(Transaction)
+        .filter(Transaction.owner_id == user.id, Transaction.source_uid.in_(werte))
+        .first()
+    )
+
+
 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:
@@ -34,6 +64,22 @@ def buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None:
     konto = db.get(Account, eintrag.account_id)
     if konto is None or konto.owner_id != user.id:
         return None
+
+    kennung = quell_kennung(eintrag.source, eintrag.external_id)
+    if kennung is not None:
+        vorhanden = gebuchte_mit_kennung(db, user, [kennung])
+        if vorhanden is not None:
+            # Diese Zahlung ist schon gebucht – unter einem frueheren
+            # Eingangs-Eintrag, den es nicht mehr gibt. Der Eintrag wird
+            # trotzdem auf die vorhandene Buchung gezeigt und geschlossen:
+            # Bliebe er offen, luede er beim naechsten Ansehen zum zweiten
+            # Buchen ein, und genau das soll die Kennung verhindern.
+            eintrag.transaction_id = vorhanden.id
+            eintrag.status = InboxStatus.booked
+            log.info("Eingang %s zeigt auf die vorhandene Buchung %s (%s)",
+                     eintrag.id, vorhanden.id, kennung)
+            return None
+
     betrag = abs(eintrag.amount_cents)
     txn = Transaction(
         owner_id=user.id,
@@ -46,6 +92,7 @@ def buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None:
         category_id=eintrag.category_id,
         payee=eintrag.payee,
         description=eintrag.note,
+        source_uid=kennung,
     )
     db.add(txn)
     db.flush()

backend/app/services/uebertrag_buchen.py

@@ -42,7 +42,7 @@ from ..models import (
     TxnType,
     User,
 )
-from . import buchung, csv_import, currency
+from . import buchung, csv_import, currency, eingang
 from .csv_import import INBOX_TAGE
 from .uebertraege import FX_TOLERANZ
 
@@ -320,8 +320,15 @@ def aus_eingang(db: Session, user: User, eintrag: InboxItem, ziel: Account,
         TxnType.expense if eintrag.amount_cents < 0 else TxnType.income,
         ziel_betrag, eintrag.date, exakt, trotzdem)
 
+    # Auch als Uebertrag gebucht bleibt es DIESELBE Zahlung der Bank. Ohne die
+    # Kennung an der Buchung waere sie beim naechsten Abruf wieder neu.
+    kennung = eingang.quell_kennung(eintrag.source, eintrag.external_id)
+    if kennung is not None and eingang.gebuchte_mit_kennung(db, user, [kennung]):
+        raise UebertragFehler("Diese Zahlung ist schon gebucht")
+
     txn = _lege_an(db, user, konto, ziel, eintrag.amount_cents, ziel_betrag,
                    eintrag.date, eintrag.payee, eintrag.note, kurs)
+    txn.source_uid = kennung
     eintrag.transaction_id = txn.id
     eintrag.status = InboxStatus.booked
     eintrag.category_id = None