feat: Zahlungen finden ihren Vertrag von selbst – Preisaenderungen werden gemeldet
Ein Abo stand bisher unverbunden neben seinen Zahlungen. Wer wissen wollte, ob Netflix diesen Monat abgebucht wurde, musste es in der Buchungsliste suchen. Jetzt verknuepft Certain Buchung und Vertrag beim Import selbst. Drei Stufen, bewusst unterschiedlich mutig: - sicher (Betrag und Text passen, Datum im Fenster): wird zugeordnet. - Vorschlag: Betrag passt, Text nicht – oder der Text passt und der Betrag weicht ab. Der zweite Fall ist die Preiserhoehung. - nichts: im Zweifel lieber schweigen. Eine Preiserhoehung wird nie stillschweigend uebernommen. Sie ist eine Nachricht an den Nutzer, kein Wartungsvorgang – er entscheidet, ob der neue Preis der richtige ist. Die Zuordnung ist ein Etikett, keine Umbuchung: die Buchung selbst bleibt unangetastet, und ein geloeschter Vertrag nimmt sie nicht mit. Beim Backup wandern Vertraege nun vor die Buchungen, sonst haenge eine Rueckspielung Zahlungen an die falschen Vertraege. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
41db67f53e
commit
152483707e
@@ -0,0 +1,311 @@
|
||||
"""Welche Buchung gehört zu welchem Vertrag.
|
||||
|
||||
Eine Schicht OBENDRAUF, wie die Übertrags-Verknüpfung: An der Buchung ändert
|
||||
sich nichts. Hier steht nur, dass sie die Abbuchung eines Vertrags ist. Fällt
|
||||
die Zuordnung falsch aus, zieht man ein Etikett ab – keine Buchung ist verbogen.
|
||||
|
||||
Ein Vertrag weiß vier Dinge über seine Abbuchung: Konto, Betrag, ungefähres
|
||||
Datum und einen Text. Daraus ergeben sich drei Stufen:
|
||||
|
||||
**Sicher** Betrag stimmt auf den Cent, und der Text passt. Wird
|
||||
zugeordnet, ohne zu fragen.
|
||||
**Vorschlag** Betrag stimmt, Text nicht – oder der Text passt, aber der
|
||||
Betrag ist ein anderer. Das zweite ist der interessante Fall:
|
||||
So sieht eine Preiserhöhung aus.
|
||||
**Nichts** Alles andere. Lieber nichts sagen als daneben raten.
|
||||
|
||||
Was hier NICHT passiert: den Preis am Vertrag stillschweigend nachziehen. Eine
|
||||
Preiserhöhung ist eine Nachricht an den Nutzer, kein Wartungsvorgang.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from collections import defaultdict
|
||||
from dataclasses import dataclass
|
||||
from datetime import date, timedelta
|
||||
|
||||
from dateutil.relativedelta import relativedelta
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import Account, Subscription, Transaction, TxnType, User
|
||||
from . import currency
|
||||
from .csv_import import normalize_text
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# Wie weit das Buchungsdatum von der erwarteten Fälligkeit abweichen darf und
|
||||
# trotzdem als dieselbe Abbuchung gilt. Grosszügig: Banken buchen über
|
||||
# Wochenenden und Feiertage verschoben, und wer den Vertrag von Hand angelegt
|
||||
# hat, kennt den genauen Tag oft nicht.
|
||||
FENSTER_TAGE = 12
|
||||
|
||||
# Ohne eingetragene Fälligkeit muss ein weiteres Fenster herhalten – dann
|
||||
# entscheidet praktisch allein der Betrag samt Text.
|
||||
FENSTER_OHNE_FAELLIGKEIT = 45
|
||||
|
||||
# Wie weit der Betrag abweichen darf und noch als PREISÄNDERUNG desselben
|
||||
# Vertrags gilt (statt als fremde Zahlung). Halb so viel bis doppelt so viel:
|
||||
# Ein Abo, das sich verdreifacht, ist kein Abo mehr, sondern etwas anderes.
|
||||
PREIS_UNTEN = 0.5
|
||||
PREIS_OBEN = 2.0
|
||||
|
||||
|
||||
@dataclass
|
||||
class Treffer:
|
||||
"""Eine Buchung und der Vertrag, zu dem sie gehören könnte."""
|
||||
|
||||
txn: Transaction
|
||||
vertrag: Subscription
|
||||
sicher: bool
|
||||
# Der Betrag des Vertrags in der Währung der Buchung – zum Vergleichen.
|
||||
erwartet_cents: int | None
|
||||
@property
|
||||
def preis_geaendert(self) -> bool:
|
||||
return self.erwartet_cents is not None and self.txn.amount_cents != self.erwartet_cents
|
||||
|
||||
|
||||
def _texte(t: Transaction) -> str:
|
||||
return normalize_text(f"{t.payee or ''} {t.description or ''}")
|
||||
|
||||
|
||||
def _passt_text(vertrag: Subscription, text: str) -> bool:
|
||||
"""Steht der Erkennungstext des Vertrags in der Buchung?
|
||||
|
||||
Wortweise und nicht als Ganzes: Auf dem Auszug steht „NETFLIX.COM 1234"
|
||||
oder „Salt Mobile SA Rechnung" – der eingetragene Name kommt dort selten
|
||||
am Stück vor. Kurze Wörter bleiben draussen; „SA" oder „AG" trifft sonst
|
||||
die halbe Kontoauszug.
|
||||
"""
|
||||
muster = normalize_text(vertrag.payee_pattern or vertrag.name)
|
||||
if not muster:
|
||||
return False
|
||||
if muster in text:
|
||||
return True
|
||||
woerter = [w for w in muster.split() if len(w) >= 4]
|
||||
return bool(woerter) and any(w in text for w in woerter)
|
||||
|
||||
|
||||
def _erwartet_in(db: Session, vertrag: Subscription, konto: Account,
|
||||
am: date) -> int | None:
|
||||
"""Was der Vertrag in der Währung DES KONTOS kosten sollte.
|
||||
|
||||
Ein Vertrag in Euro, bezahlt von einem Franken-Konto, kommt jeden Monat mit
|
||||
einem anderen Frankenbetrag an. Der exakte Vergleich wäre dort immer
|
||||
falsch – also wird umgerechnet, und der Betrag darf danach etwas
|
||||
abweichen (siehe ``_betrag_passt``).
|
||||
"""
|
||||
if vertrag.currency == konto.currency:
|
||||
return vertrag.amount_cents
|
||||
return currency.convert(db, vertrag.amount_cents, vertrag.currency,
|
||||
konto.currency, am)
|
||||
|
||||
|
||||
def _betrag_passt(ist: int, erwartet: int, gleiche_waehrung: bool) -> bool:
|
||||
"""Ist das derselbe Betrag?
|
||||
|
||||
Bei gleicher Währung auf den Cent – ein Abo kostet, was es kostet. Bei
|
||||
umgerechneter Währung mit Spielraum: Der Kurs von heute ist nicht der vom
|
||||
Buchungstag, und die Bank rechnet mit ihrem eigenen.
|
||||
"""
|
||||
if gleiche_waehrung:
|
||||
return ist == erwartet
|
||||
if erwartet <= 0:
|
||||
return False
|
||||
return abs(ist - erwartet) <= max(50, round(erwartet * 0.05))
|
||||
|
||||
|
||||
def _im_fenster(tag: date, faellig: date | None, intervall: int) -> bool:
|
||||
"""Liegt der Tag nahe genug an einer erwarteten Fälligkeit?
|
||||
|
||||
Gerechnet wird über MEHRERE Intervalle rückwärts und vorwärts: Wer seine
|
||||
Verträge nachträgt, hat Buchungen aus Monaten, die längst vorbei sind, und
|
||||
``next_due`` steht in der Zukunft.
|
||||
"""
|
||||
if faellig is None:
|
||||
return True
|
||||
for n in range(-24, 25):
|
||||
erwartet = faellig + relativedelta(months=intervall * n)
|
||||
if abs((tag - erwartet).days) <= FENSTER_TAGE:
|
||||
return True
|
||||
if erwartet > tag + timedelta(days=FENSTER_TAGE * 2) and n > 0:
|
||||
break
|
||||
return False
|
||||
|
||||
|
||||
def _kandidaten(db: Session, user: User) -> list[Transaction]:
|
||||
"""Buchungen, die noch keinem Vertrag zugeordnet sind.
|
||||
|
||||
Überträge bleiben draussen: Ein Abo wird bezahlt, nicht zwischen eigenen
|
||||
Konten verschoben. Verknüpfte Buchungen ebenfalls – die sind schon als
|
||||
etwas anderes erkannt.
|
||||
"""
|
||||
from .uebertraege import verknuepfte_ids
|
||||
|
||||
verknuepft = verknuepfte_ids(db, user)
|
||||
return [
|
||||
t for t in db.query(Transaction).filter(
|
||||
Transaction.owner_id == user.id,
|
||||
Transaction.type == TxnType.expense,
|
||||
Transaction.subscription_id.is_(None),
|
||||
)
|
||||
if t.id not in verknuepft
|
||||
]
|
||||
|
||||
|
||||
def _pruefe(db: Session, t: Transaction, vertrag: Subscription,
|
||||
konto: Account) -> Treffer | None:
|
||||
"""Passt diese eine Buchung zu diesem einen Vertrag?"""
|
||||
if vertrag.account_id is not None and vertrag.account_id != t.account_id:
|
||||
return None
|
||||
erwartet = _erwartet_in(db, vertrag, konto, t.date)
|
||||
if erwartet is None:
|
||||
return None
|
||||
gleiche = vertrag.currency == konto.currency
|
||||
betrag_ok = _betrag_passt(t.amount_cents, erwartet, gleiche)
|
||||
text_ok = _passt_text(vertrag, _texte(t))
|
||||
|
||||
if betrag_ok and text_ok and _im_fenster(t.date, vertrag.next_due,
|
||||
vertrag.interval_months):
|
||||
return Treffer(t, vertrag, True, erwartet)
|
||||
|
||||
# Betrag stimmt, Text nicht: Auf dem Auszug steht oft der Abwickler
|
||||
# ("STRIPE") und nicht die Marke. Fragen statt raten.
|
||||
if betrag_ok and _im_fenster(t.date, vertrag.next_due, vertrag.interval_months):
|
||||
return Treffer(t, vertrag, False, erwartet)
|
||||
|
||||
# Text stimmt, Betrag nicht – SO SIEHT EINE PREISERHOEHUNG AUS. Der
|
||||
# wertvollste Fall, und einer, den man nie automatisch verbuchen darf.
|
||||
if text_ok and erwartet > 0:
|
||||
verhaeltnis = t.amount_cents / erwartet
|
||||
if PREIS_UNTEN <= verhaeltnis <= PREIS_OBEN:
|
||||
fenster = (vertrag.next_due is not None
|
||||
and _im_fenster(t.date, vertrag.next_due, vertrag.interval_months))
|
||||
ohne = vertrag.next_due is None
|
||||
if fenster or ohne:
|
||||
return Treffer(t, vertrag, False, erwartet)
|
||||
return None
|
||||
|
||||
|
||||
def finde(db: Session, user: User, nur_vorschlaege: bool = False) -> dict:
|
||||
"""Buchungen ihren Verträgen zuordnen.
|
||||
|
||||
Eindeutig Sicheres wird zugeordnet, der Rest kommt als Vorschlag zurück.
|
||||
|
||||
Mit ``nur_vorschlaege`` wird NICHTS zugeordnet – das braucht jede Ansicht,
|
||||
die bloss fragen will, ohne beim Hinsehen schon etwas zu verändern.
|
||||
"""
|
||||
vertraege = (
|
||||
db.query(Subscription)
|
||||
.filter(Subscription.owner_id == user.id, Subscription.is_active.is_(True))
|
||||
.all()
|
||||
)
|
||||
if not vertraege:
|
||||
return {"zugeordnet": 0, "vorschlaege": [], "preisaenderungen": []}
|
||||
|
||||
konten = {a.id: a for a in db.query(Account).filter(Account.owner_id == user.id)}
|
||||
zugeordnet = 0
|
||||
vorschlaege: list[Treffer] = []
|
||||
|
||||
for t in _kandidaten(db, user):
|
||||
konto = konten.get(t.account_id)
|
||||
if konto is None:
|
||||
continue
|
||||
treffer = [x for x in (_pruefe(db, t, v, konto) for v in vertraege) if x]
|
||||
if not treffer:
|
||||
continue
|
||||
|
||||
sichere = [x for x in treffer if x.sicher]
|
||||
# Nur wenn GENAU EINER sicher passt. Zwei Abos zum selben Preis am
|
||||
# selben Tag gibt es, und dann soll der Nutzer entscheiden.
|
||||
if len(sichere) == 1 and not nur_vorschlaege:
|
||||
t.subscription_id = sichere[0].vertrag.id
|
||||
_ruecke_faelligkeit(sichere[0].vertrag, t.date)
|
||||
zugeordnet += 1
|
||||
continue
|
||||
if len(sichere) == 1:
|
||||
vorschlaege.append(sichere[0])
|
||||
continue
|
||||
# Mehrdeutig oder unsicher: der beste Vorschlag je Buchung genuegt.
|
||||
vorschlaege.append(sichere[0] if sichere else treffer[0])
|
||||
|
||||
if zugeordnet:
|
||||
db.commit()
|
||||
|
||||
return {
|
||||
"zugeordnet": zugeordnet,
|
||||
"vorschlaege": [_kurz(db, x) for x in vorschlaege],
|
||||
"preisaenderungen": [_kurz(db, x) for x in vorschlaege if x.preis_geaendert],
|
||||
}
|
||||
|
||||
|
||||
def _ruecke_faelligkeit(vertrag: Subscription, gebucht_am: date) -> None:
|
||||
"""Die nächste Fälligkeit hinter die gerade erkannte Abbuchung schieben.
|
||||
|
||||
Nur vorwärts: Wer alte Buchungen nachträgt, soll die Fälligkeit nicht in
|
||||
die Vergangenheit ziehen.
|
||||
"""
|
||||
naechste = gebucht_am + relativedelta(months=vertrag.interval_months)
|
||||
if vertrag.next_due is None or naechste > vertrag.next_due:
|
||||
vertrag.next_due = naechste
|
||||
|
||||
|
||||
def _kurz(db: Session, x: Treffer) -> dict:
|
||||
konto = db.get(Account, x.txn.account_id)
|
||||
return {
|
||||
"txn_id": x.txn.id,
|
||||
"date": x.txn.date.isoformat(),
|
||||
"amount_cents": x.txn.amount_cents,
|
||||
"currency": konto.currency if konto else "",
|
||||
"payee": x.txn.payee,
|
||||
"description": x.txn.description,
|
||||
"account_name": konto.name if konto else "",
|
||||
"subscription_id": x.vertrag.id,
|
||||
"subscription_name": x.vertrag.name,
|
||||
"erwartet_cents": x.erwartet_cents,
|
||||
"preis_geaendert": x.preis_geaendert,
|
||||
}
|
||||
|
||||
|
||||
def verlauf(db: Session, user: User, vertrag: Subscription) -> list[dict]:
|
||||
"""Die erkannten Abbuchungen eines Vertrags, neueste zuerst.
|
||||
|
||||
Damit beantwortet sich „was habe ich dafür insgesamt bezahlt" – und man
|
||||
sieht, wann der Preis gestiegen ist.
|
||||
"""
|
||||
konten = {a.id: a for a in db.query(Account).filter(Account.owner_id == user.id)}
|
||||
zeilen = []
|
||||
for t in (
|
||||
db.query(Transaction)
|
||||
.filter(Transaction.owner_id == user.id,
|
||||
Transaction.subscription_id == vertrag.id)
|
||||
.order_by(Transaction.date.desc(), Transaction.id.desc())
|
||||
):
|
||||
konto = konten.get(t.account_id)
|
||||
zeilen.append({
|
||||
"txn_id": t.id,
|
||||
"date": t.date.isoformat(),
|
||||
"amount_cents": t.amount_cents,
|
||||
"currency": konto.currency if konto else "",
|
||||
"payee": t.payee,
|
||||
"account_name": konto.name if konto else "",
|
||||
})
|
||||
return zeilen
|
||||
|
||||
|
||||
def summe_je_vertrag(db: Session, user: User) -> dict[int, dict]:
|
||||
"""Je Vertrag: wie viele Abbuchungen erkannt sind und was sie zusammen
|
||||
gekostet haben. Fuer die Liste, ohne je Zeile einzeln nachzufragen."""
|
||||
ergebnis: dict[int, dict] = defaultdict(lambda: {"anzahl": 0, "summe_cents": 0,
|
||||
"letzte": None})
|
||||
for t in db.query(Transaction).filter(
|
||||
Transaction.owner_id == user.id,
|
||||
Transaction.subscription_id.isnot(None),
|
||||
):
|
||||
eintrag = ergebnis[t.subscription_id]
|
||||
eintrag["anzahl"] += 1
|
||||
eintrag["summe_cents"] += t.amount_cents
|
||||
iso = t.date.isoformat()
|
||||
if eintrag["letzte"] is None or iso > eintrag["letzte"]:
|
||||
eintrag["letzte"] = iso
|
||||
return dict(ergebnis)
|
||||
@@ -104,12 +104,26 @@ USER_TABLES: list[TableSpec] = [
|
||||
TableSpec("import_batches", ImportBatch, "owner",
|
||||
{"account_id": "accounts", "template_id": "import_templates"},
|
||||
label="Import-Läufe"),
|
||||
# Abos & Vertraege VOR den Buchungen: Eine Buchung traegt das Etikett ihres
|
||||
# Vertrags, und ein Verweis darf nur auf eine schon eingefuegte Tabelle
|
||||
# zeigen. Umgekehrt verweist kein Vertrag auf eine Buchung.
|
||||
TableSpec("subscriptions", Subscription, "owner", {
|
||||
"account_id": "accounts",
|
||||
"savings_account_id": "accounts",
|
||||
"category_id": "categories",
|
||||
}, label="Abos & Vertraege"),
|
||||
# Das Logo gehoert zum Vertrag. Klein gerechnet ist es ein paar Kilobyte –
|
||||
# muehsam nachzutragen waere es trotzdem.
|
||||
TableSpec("subscription_logos", SubscriptionLogo, "subscription",
|
||||
{"subscription_id": "subscriptions"}, has_id=False,
|
||||
label="Vertrags-Logos"),
|
||||
TableSpec("transactions", Transaction, "owner", {
|
||||
"account_id": "accounts",
|
||||
"to_account_id": "accounts",
|
||||
"category_id": "categories",
|
||||
"budget_category_id": "categories",
|
||||
"import_batch_id": "import_batches",
|
||||
"subscription_id": "subscriptions",
|
||||
}, label="Buchungen"),
|
||||
TableSpec("budget_template_lines", BudgetTemplateLine, "owner",
|
||||
{"category_id": "categories"}, label="Budget-Vorlage"),
|
||||
@@ -134,18 +148,6 @@ USER_TABLES: list[TableSpec] = [
|
||||
"category_id": "categories",
|
||||
"transaction_id": "transactions",
|
||||
}, label="Eingang"),
|
||||
# Abos & Vertraege: reine Stammdaten, aber muehsam nachzutragen – und sie
|
||||
# verweisen auf Konten und Kategorien, stehen deshalb nach beiden.
|
||||
TableSpec("subscriptions", Subscription, "owner", {
|
||||
"account_id": "accounts",
|
||||
"savings_account_id": "accounts",
|
||||
"category_id": "categories",
|
||||
}, label="Abos & Vertraege"),
|
||||
# Das Logo gehoert zum Vertrag. Klein gerechnet ist es ein paar Kilobyte –
|
||||
# muehsam nachzutragen waere es trotzdem.
|
||||
TableSpec("subscription_logos", SubscriptionLogo, "subscription",
|
||||
{"subscription_id": "subscriptions"}, has_id=False,
|
||||
label="Vertrags-Logos"),
|
||||
TableSpec("transfer_links", TransferLink, "owner",
|
||||
{"from_txn_id": "transactions", "to_txn_id": "transactions"},
|
||||
label="Übertrags-Verknüpfungen"),
|
||||
|
||||
@@ -1030,6 +1030,15 @@ def commit_import(db: Session, user: User, account: Account, template_id: int |
|
||||
except Exception: # Nie den Import daran scheitern lassen
|
||||
log.exception("Übertrags-Suche nach dem Import fehlgeschlagen")
|
||||
|
||||
# Und nach den Verträgen sehen – aus demselben Grund und mit derselben
|
||||
# Vorsicht: Was hier entsteht, ist ein Etikett. Geht es schief, ist der
|
||||
# Import trotzdem gelaufen.
|
||||
try:
|
||||
from . import abo_erkennung
|
||||
abo_erkennung.finde(db, user)
|
||||
except Exception:
|
||||
log.exception("Vertrags-Zuordnung nach dem Import fehlgeschlagen")
|
||||
|
||||
db.refresh(batch)
|
||||
return batch
|
||||
|
||||
|
||||
@@ -111,11 +111,21 @@ def suche_uebertraege(db: Session, user: User) -> int:
|
||||
Ein Fehler hier darf das Buchen nicht kippen: Die Buchung ist schon
|
||||
festgeschrieben, die Verknuepfung ist nur eine Schicht darueber.
|
||||
"""
|
||||
from . import uebertraege
|
||||
from . import abo_erkennung, uebertraege
|
||||
|
||||
verknuepft = 0
|
||||
try:
|
||||
return uebertraege.finde(db, user).get("verknuepft", 0)
|
||||
verknuepft = uebertraege.finde(db, user).get("verknuepft", 0)
|
||||
except Exception: # pragma: no cover - Sicherheitsnetz
|
||||
log.exception("Uebertragssuche nach dem Buchen fehlgeschlagen")
|
||||
db.rollback()
|
||||
return 0
|
||||
|
||||
# Danach nach Vertraegen sehen. Ein Abo, das ueber die Bank hereinkommt,
|
||||
# soll sich von selbst seinem Vertrag zuordnen – sonst muesste man nach
|
||||
# jedem Abruf von Hand nachsehen.
|
||||
try:
|
||||
abo_erkennung.finde(db, user)
|
||||
except Exception: # pragma: no cover - Sicherheitsnetz
|
||||
log.exception("Vertrags-Zuordnung nach dem Buchen fehlgeschlagen")
|
||||
db.rollback()
|
||||
return verknuepft
|
||||
|
||||
Reference in New Issue
Block a user