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/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