Dauerzahlungen zu einem Vertrag gelten als belegt

Bei einer monatlichen Praemie gibt es keinen Beleg - es gibt einen Vertrag, und der wird einmal abgeschlossen, nicht monatlich quittiert. Bisher blieb nur ein Freitextfeld pro Buchung: zwoelfmal im Jahr derselbe Satz, mal Anzahl der Vertraege. Buchung.vertragId mit onDelete: SetNull. Der Belegzustand kennt jetzt drei Faelle statt zwei, getrennt ausgewiesen - ein Vertrag belegt, eine Begruendung erklaert nur; zusammengeworfen verliert die Belegquote ihre Aussage gegenueber dem Rechtspfleger. Dazu: automatische Zuordnung beim Import bei eindeutiger Gegenstelle, Sammelzuordnung ueber die Gruppen aus Issue #3, und die Rechnungslegung nennt den Vertrag samt Nummer statt "ohne Beleg". Die Sicherung dagegen: Weicht der Betrag um mehr als ein Fuenftel vom hinterlegten Beitrag ab, faellt die Anerkennung weg und die Buchung wird als "Betrag pruefen" markiert. Sonst waere die Zuordnung eine Hintertuer. Zur Toleranz - ein Entwurf und seine Korrektur: Zuerst verglich ich den Betrag gegen alle ueblichen Zahlweisen, damit es auch passt, wenn die Bank anders abbucht als der Vertrag es fuehrt. Der eigene Test hat das widerlegt: Bei 42,50 monatlich liegen 420 innerhalb von 20 Prozent des Jahresbetrags von 510 - ausgerechnet der Fall aus der Aufgabenstellung waere durchgerutscht. Jetzt wird stur gegen den hinterlegten Beitrag verglichen. Bucht die Bank anders ab, stimmen die Vertragsdaten nicht, und das soll auffallen. Behoben: Die Buchungsliste hatte eine eigene, fast gleiche Datenabfrage neben der aus berichte/gemeinsam.ts. Nur eine von beiden wurde nachgezogen, in der Liste stand weiter "Beleg fehlt". Beide benutzen jetzt BUCHUNG_EINBEZUG und zuBuchungEingabe - das kann nicht halb vergessen werden. Gefunden hat es der Browsertest. Nebenbei: Die Roadmap trug noch "Aktuelle Fassung 1.1.2" - Nachwirkung der parallelen Bearbeitung von #3 und #10. Nachgezogen wie zugesagt. Geprueft: 23 neue Einheitstests, die Haelfte davon darauf gerichtet, dass die Anerkennung auch wirklich wegfaellt. Fuenf End-to-End-Tests auf beiden Geraeteprofilen. 560 Unit-Tests, 63 e2e, null Typfehler. Refs #11
2026-08-23 09:00:46 +02:00
parent 8779cc6a25
commit fa994350d6
28 changed files with 1105 additions and 96 deletions
@@ -1,4 +1,5 @@
 import 'server-only'
+import type { Prisma } from '@prisma/client'
 import type { Betreute, User } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
 import { protokollieren } from '@/lib/audit'
@@ -85,6 +86,62 @@ export function berichtskopf(eingabe: {
 // Laden
 // -----------------------------------------------------------------------------

+/**
+ * Was eine Buchung mitbringen muss, damit sich daraus eine BuchungEingabe
+ * bauen laesst.
+ *
+ * Steht hier und nicht in jeder Seite einzeln: Die Buchungsliste hatte
+ * lange eine eigene, fast gleiche Abfrage. Als die Dauerzahlungen
+ * dazukamen, wurde nur eine der beiden nachgezogen - und in der Liste
+ * stand weiter "Beleg fehlt", obwohl der Vertrag hinterlegt war. Ein
+ * gemeinsamer Einbezug kann nicht halb vergessen werden.
+ */
+export const BUCHUNG_EINBEZUG = {
+  konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
+  beleg: { select: { id: true, titel: true } },
+  // Bei einer Dauerzahlung ist der Vertrag der Beleg, und sein Beitrag ist
+  // der Massstab fuer die Betragspruefung.
+  vertrag: {
+    select: {
+      id: true,
+      bezeichnung: true,
+      beitragCent: true,
+      rhythmus: true,
+      vertragsnummerVerschluesselt: true,
+    },
+  },
+} as const
+
+type BuchungMitBezug = Prisma.BuchungGetPayload<{ include: typeof BUCHUNG_EINBEZUG }>
+
+/** Wandelt eine geladene Zeile in die Form um, mit der die Auswertung rechnet. */
+export function zuBuchungEingabe(zeile: BuchungMitBezug): BuchungEingabe {
+  const offen = oeffnen('Buchung', zeile)
+  return {
+    id: zeile.id,
+    datum: zeile.datum,
+    betragCent: zeile.betragCent,
+    richtung: zeile.richtung,
+    kategorie: zeile.kategorie,
+    gegenstelle: zeile.gegenstelle,
+    verwendungszweck: offen.verwendungszweck,
+    kontoId: zeile.kontoId,
+    kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
+    belegId: zeile.belegId,
+    belegTitel: zeile.beleg?.titel ?? null,
+    belegFehltBegruendung: zeile.belegFehltBegruendung,
+    vertragId: zeile.vertragId,
+    vertragBezeichnung: zeile.vertrag?.bezeichnung ?? null,
+    vertragsnummer: zeile.vertrag ? oeffnen('Vertrag', zeile.vertrag).vertragsnummer : null,
+    vertragBeitragCent: zeile.vertrag?.beitragCent ?? null,
+    vertragRhythmus: zeile.vertrag?.rhythmus ?? null,
+    vertragAutomatisch: zeile.vertragAutomatisch,
+    betrifftBetreute: zeile.betrifftBetreute,
+    vermoegenswirksam: zeile.vermoegenswirksam,
+    aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
+  }
+}
+
 /**
 * Alle Buchungen einer betreuten Person, entschluesselt und um die
 * Angaben ergaenzt, die die Auswertung braucht (Kontoname, Belegtitel,
@@ -102,33 +159,11 @@ export async function buchungenLaden(
        ? { datum: { gte: alsTag(zeitraum.von), lte: alsTag(zeitraum.bis) } }
        : {}),
    },
-    include: {
-      konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
-      beleg: { select: { id: true, titel: true } },
-    },
+    include: BUCHUNG_EINBEZUG,
    orderBy: [{ datum: 'asc' }, { erstelltAm: 'asc' }],
  })

-  return zeilen.map((zeile) => {
-    const offen = oeffnen('Buchung', zeile)
-    return {
-      id: zeile.id,
-      datum: zeile.datum,
-      betragCent: zeile.betragCent,
-      richtung: zeile.richtung,
-      kategorie: zeile.kategorie,
-      gegenstelle: zeile.gegenstelle,
-      verwendungszweck: offen.verwendungszweck,
-      kontoId: zeile.kontoId,
-      kontoBezeichnung: zeile.konto?.bezeichnung ?? null,
-      belegId: zeile.belegId,
-      belegTitel: zeile.beleg?.titel ?? null,
-      belegFehltBegruendung: zeile.belegFehltBegruendung,
-      betrifftBetreute: zeile.betrifftBetreute,
-      vermoegenswirksam: zeile.vermoegenswirksam,
-      aufBetreuerkonto: zeile.konto?.istBetreuerkonto ?? false,
-    }
-  })
+  return zeilen.map(zuBuchungEingabe)
 }

 /** Konten mit ihrer vollstaendigen Saldostand-Historie. */
@@ -444,6 +444,15 @@ export function RechnungslegungDokument({
                <View style={stile.mittel}>
                  {beleg.belegTitel ? (
                    <Text style={stile.klein}>{beleg.belegTitel}</Text>
+                  ) : beleg.vertragBezeichnung ? (
+                    <Text style={stile.klein}>
+                      Dauerzahlung zu Vertrag „{beleg.vertragBezeichnung}“
+                      {beleg.vertragsnummer ? `, Nr. ${beleg.vertragsnummer}` : ''}
+                    </Text>
+                  ) : beleg.betragZuPruefen ? (
+                    <Text style={[stile.klein, stile.fett]}>
+                      Beleg fehlt – Betrag weicht vom Vertrag ab
+                    </Text>
                  ) : beleg.belegFehltBegruendung ? (
                    <Text style={stile.klein}>
                      ohne Beleg – {beleg.belegFehltBegruendung}
@@ -167,7 +167,17 @@ export async function dashboardLaden(
    // 5b. Buchungen ohne Beleg und ohne Begruendung - Belegzwang.
    darfFinanzen
      ? db.buchung.findMany({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
          orderBy: { datum: 'desc' },
          take: KACHEL_ZEILEN,
          select: {
@@ -182,7 +192,17 @@ export async function dashboardLaden(
      : null,
    darfFinanzen
      ? db.buchung.count({
-          where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
+          where: {
+            betreuteId,
+            belegId: null,
+            belegFehltBegruendung: null,
+            // Dauerzahlungen sind durch ihren Vertrag belegt - sie gehoeren
+            // nicht in die Liste der offenen Belege. Die Betragspruefung
+            // laeuft erst spaeter auf den geladenen Zeilen; hier wird nur
+            // grob vorgefiltert.
+            vertragId: null,
+            ...nichtGeloescht,
+          },
        })
      : null,

@@ -1,4 +1,4 @@
-import type { BuchungKategorie, BuchungRichtung } from '@prisma/client'
+import type { BuchungKategorie, BuchungRichtung, ZahlRhythmus } from '@prisma/client'
 import { summe, teileGerundet } from '@/lib/finanzen/betrag'
 import { alsTag, imZeitraum, nachTagSortieren } from '@/lib/finanzen/datum'
 import {
@@ -39,6 +39,15 @@ export type BuchungEingabe = {
  belegId: string | null
  belegTitel?: string | null
  belegFehltBegruendung: string | null
+  /** Dauerzahlung zu einem Vertrag - dann ist der Vertrag der Beleg. */
+  vertragId?: string | null
+  vertragBezeichnung?: string | null
+  vertragsnummer?: string | null
+  /** Hinterlegter Beitrag samt Zahlweise - Grundlage der Betragspruefung. */
+  vertragBeitragCent?: bigint | null
+  vertragRhythmus?: ZahlRhythmus | null
+  /** Wurde die Zuordnung beim Import automatisch gesetzt? */
+  vertragAutomatisch?: boolean
  betrifftBetreute: boolean
  vermoegenswirksam: boolean
  /** Laeuft die Buchung ueber ein Konto des Betreuers? */
@@ -54,24 +63,134 @@ export function istVermoegensbuchung(buchung: BuchungEingabe): boolean {
 // Belegzwang
 // -----------------------------------------------------------------------------

+/**
+ * Wie weit darf die Zahlung vom hinterlegten Beitrag abweichen?
+ *
+ * Ein Fuenftel. Das ist grosszuegig und mit Absicht: Beitragsanpassungen,
+ * Versicherungsteuer und ein nachtraeglich geaenderter Selbstbehalt bewegen
+ * sich in dieser Groessenordnung, und bei jeder davon soll die Anwendung
+ * nicht meckern.
+ *
+ * Was sie fangen soll, ist die andere Groessenordnung: die Praemie, die von
+ * 42 auf 420 Euro springt, oder die Lastschrift, die versehentlich zweimal
+ * lief. Wer die Grenze enger zieht, bekommt taeglich Warnungen und sieht
+ * die eine wichtige nicht mehr.
+ */
+export const BETRAGS_TOLERANZ_PROZENT = 20n
+
+/**
+ * Passt der Betrag zu dem, was am Vertrag steht?
+ *
+ * Verglichen wird gegen den hinterlegten Beitrag, unveraendert. Kein
+ * Umrechnen auf andere Zahlweisen.
+ *
+ * Der erste Entwurf tat genau das - Jahresbetrag bilden und gegen
+ * jaehrlich, halbjaehrlich, vierteljaehrlich und monatlich pruefen, damit
+ * es auch passt, wenn die Bank anders abbucht als der Vertrag es fuehrt.
+ * Das Ergebnis war ein Toleranzband mit vier Loechern: Bei einem
+ * Monatsbeitrag von 42,50 EUR liegen 420 EUR innerhalb von 20 Prozent des
+ * Jahresbetrags von 510 EUR. Ausgerechnet der Fall, vor dem diese Pruefung
+ * schuetzen soll, waere durchgerutscht.
+ *
+ * Bucht die Bank tatsaechlich jaehrlich ab, waehrend am Vertrag "monatlich"
+ * steht, dann stimmen die Vertragsdaten nicht - und dann soll die
+ * Buchung als "zu pruefen" auffallen, statt stillschweigend akzeptiert zu
+ * werden. Die Zahlweise am Vertrag zu berichtigen dauert zehn Sekunden und
+ * macht die Akte richtiger.
+ *
+ * Ohne hinterlegten Beitrag gibt es nichts zu vergleichen - dann lautet die
+ * Antwort "unbekannt" (null), nicht "in Ordnung". Der Unterschied zaehlt:
+ * Es soll nicht so aussehen, als waere geprueft worden.
+ */
+export function betragPasstZumVertrag(
+  betragCent: bigint,
+  beitragCent: bigint | null | undefined,
+  rhythmus: ZahlRhythmus | null | undefined,
+): boolean | null {
+  if (beitragCent === null || beitragCent === undefined || beitragCent <= 0n) return null
+  // Zu einer Einmalzahlung gibt es keine wiederkehrende Rate, gegen die
+  // sich vergleichen liesse.
+  if (!rhythmus || rhythmus === 'EINMALIG') return null
+
+  const betrag = betragCent < 0n ? -betragCent : betragCent
+  const abweichung = betrag > beitragCent ? betrag - beitragCent : beitragCent - betrag
+
+  return abweichung * 100n <= beitragCent * BETRAGS_TOLERANZ_PROZENT
+}
+
+/**
+ * Ist die Buchung durch einen Vertrag belegt?
+ *
+ * Bei einem Dauerschuldverhaeltnis ist der Vertrag der Beleg - fuer zwoelf
+ * gleiche Lastschriften gibt es keine zwoelf Quittungen, sondern eine
+ * Police.
+ *
+ * Die Anerkennung faellt weg, sobald der Betrag deutlich abweicht. Sonst
+ * waere die Zuordnung eine Hintertuer, durch die auch eine verdreifachte
+ * Praemie unbemerkt als "belegt" durchginge.
+ */
+export function belegDurchVertrag(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) !== false
+  )
+}
+
+/**
+ * Zugeordnet, aber der Betrag passt nicht - das will jemand ansehen.
+ *
+ * Kein Fehler und kein Vorwurf: Meistens ist es eine Beitragsanpassung, die
+ * am Vertrag noch nicht nachgetragen wurde. Genau deshalb steht sie hier
+ * und nicht wortlos unter "Beleg fehlt".
+ */
+export function betragPruefen(buchung: BuchungEingabe): boolean {
+  if (buchung.belegId) return false
+  if (!buchung.vertragId) return false
+  return (
+    betragPasstZumVertrag(
+      buchung.betragCent,
+      buchung.vertragBeitragCent,
+      buchung.vertragRhythmus,
+    ) === false
+  )
+}
+
 /**
 * Fehlt der Beleg? Eine Begruendung heilt das Fehlen fuer die Statistik,
 * nicht fuer den Aktenordner - aber sie beantwortet die Frage des
 * Rechtspflegers "und wo ist der Beleg?" schon vorab.
 */
 export function belegFehlt(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && !(buchung.belegFehltBegruendung ?? '').trim()
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return !(buchung.belegFehltBegruendung ?? '').trim()
 }

 export function belegBegruendet(buchung: BuchungEingabe): boolean {
-  return !buchung.belegId && (buchung.belegFehltBegruendung ?? '').trim() !== ''
+  if (buchung.belegId) return false
+  if (belegDurchVertrag(buchung)) return false
+  return (buchung.belegFehltBegruendung ?? '').trim() !== ''
 }

 export type Belegquote = {
  gesamt: number
  mitBeleg: number
+  /**
+   * Dauerzahlung zu einem Vertrag - eigene Kategorie, NICHT eingerechnet in
+   * "begruendet". Ein Vertrag belegt, eine Begruendung erklaert nur; das
+   * zusammenzuwerfen nimmt der Zahl ihre Aussage gegenueber dem
+   * Rechtspfleger.
+   */
+  durchVertrag: number
  begruendet: number
  ohneNachweis: number
+  /** Zugeordnet, aber der Betrag weicht ab. Teilmenge von ohneNachweis. */
+  zuPruefen: number
  /** 0 bis 100, ganzzahlig. Bei null Buchungen: 100 - es fehlt ja nichts. */
  quoteProzent: number
 }
@@ -79,11 +198,13 @@ export type Belegquote = {
 export function belegquote(buchungen: BuchungEingabe[]): Belegquote {
  const gesamt = buchungen.length
  const mitBeleg = buchungen.filter((b) => Boolean(b.belegId)).length
+  const durchVertrag = buchungen.filter((b) => belegDurchVertrag(b)).length
  const begruendet = buchungen.filter((b) => belegBegruendet(b)).length
  const ohneNachweis = buchungen.filter((b) => belegFehlt(b)).length
+  const zuPruefen = buchungen.filter((b) => betragPruefen(b)).length
  const quoteProzent =
-    gesamt === 0 ? 100 : Math.round(((mitBeleg + begruendet) / gesamt) * 100)
-  return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
+    gesamt === 0 ? 100 : Math.round(((mitBeleg + durchVertrag + begruendet) / gesamt) * 100)
+  return { gesamt, mitBeleg, durchVertrag, begruendet, ohneNachweis, zuPruefen, quoteProzent }
 }

 /**
@@ -3,7 +3,9 @@ import { alsTag, imZeitraum, nachTagSortieren, tagePlus, vorOderGleich } from '@
 import type { Betreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
 import {
  ausgabenGruppiert,
+  belegDurchVertrag,
  belegFehlt,
+  betragPruefen,
  einnahmenGruppiert,
  istVermoegensbuchung,
  belegquote,
@@ -158,6 +160,16 @@ export type Belegzeile = {
  belegId: string | null
  belegTitel: string | null
  belegFehltBegruendung: string | null
+  /**
+   * Dauerzahlung zu einem Vertrag. Steht im Bericht anstelle von
+   * "Beleg fehlt" - die Luecke wird damit nicht versteckt, sondern
+   * erklaert: Wer nachpruefen will, weiss, welches Papier er aus dem
+   * Ordner holt.
+   */
+  vertragBezeichnung: string | null
+  vertragsnummer: string | null
+  /** Zugeordnet, aber der Betrag weicht ab - im Bericht ausgewiesen. */
+  betragZuPruefen: boolean
  fehlt: boolean
 }

@@ -179,6 +191,9 @@ export function beleglisteErstellen(buchungen: BuchungEingabe[]): Belegzeile[] {
    belegId: buchung.belegId,
    belegTitel: buchung.belegTitel ?? null,
    belegFehltBegruendung: buchung.belegFehltBegruendung,
+    vertragBezeichnung: belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null,
+    vertragsnummer: belegDurchVertrag(buchung) ? (buchung.vertragsnummer ?? null) : null,
+    betragZuPruefen: betragPruefen(buchung),
    fehlt: belegFehlt(buchung),
  }))
 }
@@ -40,7 +40,13 @@ export async function wiederkehrendLaden(betreuteId: string): Promise<Wiederkehr
        betrifftBetreute: true,
        ...nichtGeloescht,
      },
-      select: { id: true, datum: true, betragCent: true, gegenstelle: true },
+      select: {
+        id: true,
+        datum: true,
+        betragCent: true,
+        gegenstelle: true,
+        vertragId: true,
+      },
      orderBy: { datum: 'asc' },
    }),
    db.vertrag.findMany({
@@ -32,6 +32,8 @@ export type ZahlungEingabe = {
  datum: Date
  betragCent: bigint
  gegenstelle: string | null
+  /** Haengt die Buchung schon an einem Vertrag? (Issue #11) */
+  vertragId?: string | null
 }

 /** Ein hinterlegter Vertrag - zum Abgleich, ob die Zahlung schon erklaert ist. */
@@ -94,6 +96,14 @@ export type Zahlungsgruppe = {
  vertragId: string | null
  vertragBezeichnung: string | null
  buchungIds: string[]
+  /**
+   * Wie viele Buchungen der Gruppe haengen bereits an einem Vertrag?
+   * Grundlage fuer die Sammelzuordnung: Nur der Rest muss noch verknuepft
+   * werden.
+   */
+  bereitsZugeordnet: number
+  /** Buchungen der Gruppe ohne Vertragsbezug. */
+  offeneBuchungIds: string[]
 }

 // -----------------------------------------------------------------------------
@@ -366,6 +376,8 @@ export function gruppieren(
      vertragId: vertrag?.id ?? null,
      vertragBezeichnung: vertrag?.bezeichnung ?? null,
      buchungIds: sortiert.map((p) => p.id),
+      bereitsZugeordnet: posten.filter((p) => Boolean(p.vertragId)).length,
+      offeneBuchungIds: sortiert.filter((p) => !p.vertragId).map((p) => p.id),
    })
  }

@@ -506,6 +518,28 @@ export function alsZahlRhythmus(rhythmus: Rhythmus): string | null {
  }
 }

+/**
+ * Sucht den Vertrag, zu dem eine Gegenstelle EINDEUTIG passt.
+ *
+ * Gedacht fuer die automatische Zuordnung beim Import. Die Betonung liegt
+ * auf eindeutig: Passen zwei Vertraege (Hausrat und Haftpflicht bei
+ * derselben Gesellschaft), wird nichts zugeordnet. Eine falsche Zuordnung
+ * waere schlimmer als gar keine - sie behauptet einen Beleg, den es nicht
+ * gibt, und niemand sieht noch einmal hin.
+ *
+ * Gibt null zurueck, wenn nichts oder mehr als eines passt.
+ */
+export function eindeutigerVertrag(
+  gegenstelle: string | null | undefined,
+  vertraege: VertragAbgleich[],
+): VertragAbgleich | null {
+  const schluessel = normalisieren(gegenstelle)
+  if (!schluessel) return null
+
+  const treffer = vertraege.filter((vertrag) => normalisieren(vertrag.gesellschaft) === schluessel)
+  return treffer.length === 1 ? treffer[0]! : null
+}
+
 /** Wie viele Gruppen warten noch auf eine Entscheidung? Fuer das Dashboard. */
 export function offeneKandidaten(gruppen: Zahlungsgruppe[]): number {
  return gruppen.filter((gruppe) => gruppe.vertragId === null).length
@@ -229,6 +229,7 @@ export const buchungSchema = z
    verwendungszweck: optionalerText(500),
    belegId: optionaleId,
    belegFehltBegruendung: optionalerText(300),
+    vertragId: optionaleId,
    betrifftBetreute: schalter,
    vermoegenswirksam: schalter,
  })
@@ -17,7 +17,7 @@
 */

 /** Muss zur "version" in der package.json passen. */
-export const VERSION = '1.2.0'
+export const VERSION = '1.3.0'

 /**
 * Kurzer Git-Stand, beim Bauen hineingereicht: