Wiederkehrende Zahlungen aufspueren
Am Anfang einer Betreuung weiss niemand, welche Vertraege es gibt. Die Antwort steht aber im Kontoauszug: Wer regelmaessig abbucht, hat einen Vertrag. Neu unter Vermoegen & Kasse wird aus hunderten Buchungszeilen eine Arbeitsliste. Aufbau: - Die Erkennung liegt als reine Funktionen in src/lib/finanzen/wiederkehrend.ts, ohne Datenbank. Nur so laesst sich jede Einordnung einzeln nachrechnen. - Der Datenzugriff steht getrennt in wiederkehrend-laden.ts. - Ein kleines Modell haelt fest, was bewusst KEIN Vertrag ist. Es haengt am normalisierten Empfaengernamen, nicht an Buchungen - nur so ueberlebt die Entscheidung den naechsten Import. Zwei Haltungen liegen der Erkennung zugrunde: Im Zweifel getrennt lassen. Zusammengefasst wird nur das Unstrittige: Gross- und Kleinschreibung, Satzzeichen, Umlaute, Rechtsform am Ende. Keine Aehnlichkeitssuche - "Stadtwerke Bamberg" und "Stadtwerke Bayreuth" trennen drei Zeichen und zwei Rechnungssteller. Zwei Zeilen zu viel sind harmlos; eine falsche Gruppe verbirgt einen Vertrag. Nichts behaupten, was nicht belegt ist. Statt "monatlich" steht dort "6 Zahlungen, etwa monatlich". Schwankt der Betrag, wird die Spanne genannt. Ohne erkennbaren Abstand wird nicht hochgerechnet, sondern gezeigt, was geflossen ist. Dazu eine zweite Liste fuer einzelne groessere Zahlungen: Die Gruppierung braucht zwei Zahlungen, ein Jahresbeitrag erscheint bei einem importierten Jahr aber nur einmal - und ausgerechnet Versicherungen zahlt man oft jaehrlich. Geprueft: 37 Einheitstests, die Haelfte davon in der Gegenrichtung, plus vier End-to-End-Tests auf beiden Geraeteprofilen. Der Browsertest hat zwei Fehler gefunden, die Typpruefung und Einheitstests durchgelassen haben - darunter ein verlorener Backslash, der die Vorbelegung des Beitrags stillschweigend verschluckte. Nebenbei: .claude/ ins .gitignore. Dort legen parallel arbeitende Agenten ihre Worktrees ab; ein "git add -A" haette einen kompletten zweiten Checkout eingecheckt. Refs #3
This commit is contained in:
Florian Wilde
@@ -1,5 +1,6 @@
|
||||
import Link from 'next/link'
|
||||
import { ArrowRight, Banknote, FileDown, Landmark, Plus, Upload } from 'lucide-react'
|
||||
import { ArrowRight, Banknote, FileDown, Landmark, Plus, Repeat, Upload } from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
|
||||
@@ -20,6 +21,7 @@ import { kennzahlen, vermischungsWarnung } from '@/lib/finanzen/kassenbuch'
|
||||
import { KATEGORIE_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
|
||||
import { laufendesBetreuungsjahr } from '@/lib/finanzen/betreuungsjahr'
|
||||
import { buchungenLaden, kontenLaden, kontostaendeZumStichtag, vermoegenLaden } from '@/lib/berichte/gemeinsam'
|
||||
import { offeneZahlungsgruppen } from '@/lib/finanzen/wiederkehrend-laden'
|
||||
|
||||
export const metadata = { title: 'Vermögen & Kasse' }
|
||||
|
||||
@@ -48,6 +50,7 @@ export default async function FinanzenSeite() {
|
||||
const zwoelfMonate = tagePlus(monatePlus(stichtag, -12), 1)
|
||||
const letzteZwoelf = buchungen.filter((b) => b.datum >= zwoelfMonate)
|
||||
const zahlen = kennzahlen(letzteZwoelf)
|
||||
const offeneGruppen = await offeneZahlungsgruppen(betreute.id)
|
||||
|
||||
const letzte = [...buchungen].sort((a, b) => b.datum.getTime() - a.datum.getTime()).slice(0, 8)
|
||||
|
||||
@@ -134,6 +137,22 @@ export default async function FinanzenSeite() {
|
||||
/>
|
||||
</div>
|
||||
|
||||
{offeneGruppen > 0 && (
|
||||
<Alert variant="hinweis">
|
||||
<Repeat aria-hidden="true" />
|
||||
<AlertDescription className="flex flex-wrap items-center justify-between gap-3">
|
||||
<span>
|
||||
<strong>{offeneGruppen}</strong> regelmäßige Abbuchung
|
||||
{offeneGruppen === 1 ? '' : 'en'} ohne hinterlegten Vertrag. Wer regelmäßig
|
||||
abbucht, hat einen — und der fehlt dann im Vermögensverzeichnis.
|
||||
</span>
|
||||
<Button asChild size="sm" variant="outline">
|
||||
<Link href="/finanzen/wiederkehrend">Ansehen</Link>
|
||||
</Button>
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{zahlen.vermischungen > 0 && <Vermischungswarnung />}
|
||||
|
||||
<Hinweisliste hinweise={hinweise} titel="Das solltest du nachtragen" />
|
||||
|
||||
@@ -0,0 +1,318 @@
|
||||
import Link from 'next/link'
|
||||
import { AlertCircle, FileSearch, Plus, Repeat } from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Badge } from '@/components/ui/badge'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
|
||||
import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { Betrag } from '@/components/finanzen/bausteine'
|
||||
import {
|
||||
AlsGeklaertAbhaken,
|
||||
Zurueckholen,
|
||||
} from '@/components/finanzen/wiederkehrend-aktionen'
|
||||
import { finanzKontext } from '@/lib/finanzen/seite'
|
||||
import { wiederkehrendLaden } from '@/lib/finanzen/wiederkehrend-laden'
|
||||
import {
|
||||
EINZELZAHLUNG_AB_CENT,
|
||||
RHYTHMUS_BESCHRIFTUNG,
|
||||
rhythmusErklaerung,
|
||||
} from '@/lib/finanzen/wiederkehrend'
|
||||
import { centZuZahl } from '@/lib/db'
|
||||
import { formatCent, formatDatum } from '@/lib/utils'
|
||||
|
||||
export const metadata = { title: 'Wiederkehrende Zahlungen' }
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
/**
|
||||
* Wiederkehrende Zahlungen — die Suche nach unbekannten Verträgen.
|
||||
*
|
||||
* Am Anfang einer Betreuung weiß niemand, welche Verträge es gibt. Die
|
||||
* Antwort steht im Kontoauszug: Wer regelmäßig abbucht, hat einen Vertrag.
|
||||
* Diese Seite macht aus hunderten Buchungszeilen eine Arbeitsliste.
|
||||
*
|
||||
* Sie legt von sich aus nichts an. Jede Zeile endet in einer Entscheidung,
|
||||
* die ein Mensch trifft — Vertrag anlegen oder abhaken.
|
||||
*/
|
||||
export default async function WiederkehrendSeite() {
|
||||
const { betreute, darfSchreiben } = await finanzKontext()
|
||||
const schreiben = darfSchreiben('FINANZEN')
|
||||
const bild = await wiederkehrendLaden(betreute.id)
|
||||
|
||||
const ohneVertrag = bild.gruppen.filter((gruppe) => gruppe.vertragId === null)
|
||||
const mitVertrag = bild.gruppen.filter((gruppe) => gruppe.vertragId !== null)
|
||||
|
||||
return (
|
||||
<div className="space-y-6">
|
||||
<SeitenKopf
|
||||
titel="Wiederkehrende Zahlungen"
|
||||
beschreibung="Wer regelmäßig abbucht, hat einen Vertrag. Hier stehen die Kandidaten, zu denen noch keiner in der Akte liegt."
|
||||
aktionen={
|
||||
<Button asChild variant="outline">
|
||||
<Link href="/finanzen/buchungen">Zu den Buchungen</Link>
|
||||
</Button>
|
||||
}
|
||||
/>
|
||||
|
||||
{bild.ausgabenGesamt === 0 ? (
|
||||
<Leerzustand
|
||||
icon={FileSearch}
|
||||
titel="Noch keine Ausgaben erfasst"
|
||||
beschreibung="Diese Auswertung liest die Kontobewegungen. Importiere zuerst einen Kontoauszug, dann findest du hier die regelmäßigen Abbuchungen."
|
||||
aktion={
|
||||
<Button asChild>
|
||||
<Link href="/finanzen/buchungen/import">Kontoauszug einlesen</Link>
|
||||
</Button>
|
||||
}
|
||||
/>
|
||||
) : (
|
||||
<>
|
||||
{/* --- Kandidaten ohne Vertrag ----------------------------------- */}
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle className="flex items-center gap-2 text-base">
|
||||
<Repeat className="size-5" aria-hidden="true" />
|
||||
Ohne hinterlegten Vertrag
|
||||
{ohneVertrag.length > 0 && (
|
||||
<Badge variant="secondary">{ohneVertrag.length}</Badge>
|
||||
)}
|
||||
</CardTitle>
|
||||
<CardDescription>
|
||||
Nach Jahresbetrag sortiert — was am meisten kostet, will man zuerst geklärt haben.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
{ohneVertrag.length === 0 ? (
|
||||
<p className="text-sm text-muted-foreground">
|
||||
Zu jeder regelmäßigen Abbuchung liegt ein Vertrag in der Akte. Das ist der
|
||||
Zustand, den man haben will.
|
||||
</p>
|
||||
) : (
|
||||
<div className="overflow-x-auto">
|
||||
<Table>
|
||||
<TableHeader>
|
||||
<TableRow>
|
||||
<TableHead>Empfänger</TableHead>
|
||||
<TableHead>Rhythmus</TableHead>
|
||||
<TableHead className="text-right">je Zahlung</TableHead>
|
||||
<TableHead className="text-right">im Jahr</TableHead>
|
||||
<TableHead>Zeitraum</TableHead>
|
||||
{schreiben && <TableHead className="text-right">Und jetzt?</TableHead>}
|
||||
</TableRow>
|
||||
</TableHeader>
|
||||
<TableBody>
|
||||
{ohneVertrag.map((gruppe) => (
|
||||
<TableRow key={gruppe.schluessel}>
|
||||
<TableCell className="align-top">
|
||||
<p className="font-medium">{gruppe.anzeigename}</p>
|
||||
{gruppe.schreibweisen.length > 1 && (
|
||||
<p className="mt-0.5 text-xs text-muted-foreground">
|
||||
{gruppe.schreibweisen.length} Schreibweisen zusammengefasst
|
||||
</p>
|
||||
)}
|
||||
</TableCell>
|
||||
|
||||
<TableCell className="align-top">
|
||||
<span
|
||||
className={
|
||||
gruppe.rhythmus === 'UNREGELMAESSIG'
|
||||
? 'text-muted-foreground'
|
||||
: undefined
|
||||
}
|
||||
>
|
||||
{RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]}
|
||||
</span>
|
||||
<p className="mt-0.5 text-xs text-muted-foreground">
|
||||
{rhythmusErklaerung(gruppe)}
|
||||
</p>
|
||||
</TableCell>
|
||||
|
||||
<TableCell className="text-right align-top">
|
||||
<Betrag cent={centZuZahl(gruppe.betragCent)} />
|
||||
{gruppe.betragSchwankt && (
|
||||
<p className="mt-0.5 text-xs text-ampel-orange">
|
||||
schwankt: {formatCent(centZuZahl(gruppe.kleinsterBetragCent))} bis{' '}
|
||||
{formatCent(centZuZahl(gruppe.groessterBetragCent))}
|
||||
</p>
|
||||
)}
|
||||
</TableCell>
|
||||
|
||||
<TableCell className="text-right align-top">
|
||||
<Betrag cent={centZuZahl(gruppe.jahresbetragCent)} />
|
||||
{gruppe.rhythmus === 'UNREGELMAESSIG' && (
|
||||
<p className="mt-0.5 text-xs text-muted-foreground">
|
||||
tatsächlich gezahlt
|
||||
</p>
|
||||
)}
|
||||
</TableCell>
|
||||
|
||||
<TableCell className="align-top text-sm text-muted-foreground">
|
||||
{formatDatum(gruppe.ersteZahlung)}
|
||||
<br />
|
||||
bis {formatDatum(gruppe.letzteZahlung)}
|
||||
</TableCell>
|
||||
|
||||
{schreiben && (
|
||||
<TableCell className="align-top">
|
||||
<div className="flex flex-col items-end gap-2">
|
||||
<Button asChild size="sm" variant="outline">
|
||||
<Link
|
||||
href={`/vertraege/neu?gesellschaft=${encodeURIComponent(
|
||||
gruppe.anzeigename,
|
||||
)}&beitragCent=${gruppe.betragCent}&rhythmus=${gruppe.rhythmus}`}
|
||||
>
|
||||
<Plus aria-hidden="true" />
|
||||
Vertrag anlegen
|
||||
</Link>
|
||||
</Button>
|
||||
<AlsGeklaertAbhaken
|
||||
betreuteId={betreute.id}
|
||||
schluessel={gruppe.schluessel}
|
||||
anzeigename={gruppe.anzeigename}
|
||||
/>
|
||||
</div>
|
||||
</TableCell>
|
||||
)}
|
||||
</TableRow>
|
||||
))}
|
||||
</TableBody>
|
||||
</Table>
|
||||
</div>
|
||||
)}
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
{/* --- Einzelne groessere Zahlungen ------------------------------ */}
|
||||
{bild.einzelne.length > 0 && (
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle className="text-base">Einzelne größere Zahlungen</CardTitle>
|
||||
<CardDescription>
|
||||
Kein Vertragsverdacht, sondern eine Merkliste. Die Gruppierung oben braucht
|
||||
mindestens zwei Zahlungen — eine jährlich abgebuchte Prämie erscheint bei
|
||||
einem importierten Jahr aber nur einmal. Ausgerechnet Versicherungen werden
|
||||
oft jährlich gezahlt, deshalb steht hier alles ab{' '}
|
||||
{formatCent(centZuZahl(EINZELZAHLUNG_AB_CENT))}.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<div className="overflow-x-auto">
|
||||
<Table>
|
||||
<TableHeader>
|
||||
<TableRow>
|
||||
<TableHead>Empfänger</TableHead>
|
||||
<TableHead>Datum</TableHead>
|
||||
<TableHead className="text-right">Betrag</TableHead>
|
||||
<TableHead>Vertrag</TableHead>
|
||||
</TableRow>
|
||||
</TableHeader>
|
||||
<TableBody>
|
||||
{bild.einzelne.map((zahlung) => (
|
||||
<TableRow key={zahlung.buchungId}>
|
||||
<TableCell className="font-medium">{zahlung.anzeigename}</TableCell>
|
||||
<TableCell className="text-sm text-muted-foreground">
|
||||
{formatDatum(zahlung.datum)}
|
||||
</TableCell>
|
||||
<TableCell className="text-right">
|
||||
<Betrag cent={centZuZahl(zahlung.betragCent)} />
|
||||
</TableCell>
|
||||
<TableCell className="text-sm">
|
||||
{zahlung.vertragBezeichnung ? (
|
||||
<Badge variant="secondary">{zahlung.vertragBezeichnung}</Badge>
|
||||
) : (
|
||||
<span className="text-muted-foreground">keiner</span>
|
||||
)}
|
||||
</TableCell>
|
||||
</TableRow>
|
||||
))}
|
||||
</TableBody>
|
||||
</Table>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
{/* --- Bereits erklaert ------------------------------------------ */}
|
||||
{mitVertrag.length > 0 && (
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle className="text-base">Schon einem Vertrag zugeordnet</CardTitle>
|
||||
<CardDescription>
|
||||
Erkannt am Namen der Gesellschaft. Steht hier etwas Falsches, stimmt die
|
||||
Schreibweise am Vertrag nicht mit der auf dem Kontoauszug überein.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<ul className="divide-y text-sm">
|
||||
{mitVertrag.map((gruppe) => (
|
||||
<li
|
||||
key={gruppe.schluessel}
|
||||
className="flex flex-wrap items-center justify-between gap-2 py-2"
|
||||
>
|
||||
<span>
|
||||
<span className="font-medium">{gruppe.anzeigename}</span>
|
||||
<span className="ml-2 text-muted-foreground">
|
||||
{RHYTHMUS_BESCHRIFTUNG[gruppe.rhythmus]},{' '}
|
||||
{formatCent(centZuZahl(gruppe.jahresbetragCent))} im Jahr
|
||||
</span>
|
||||
</span>
|
||||
<Button asChild variant="ghost" size="sm">
|
||||
<Link href={`/vertraege/${gruppe.vertragId}`}>
|
||||
{gruppe.vertragBezeichnung}
|
||||
</Link>
|
||||
</Button>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</CardContent>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
{/* --- Abgehakt --------------------------------------------------- */}
|
||||
{bild.abgehakt.length > 0 && (
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle className="text-base">Als „kein Vertrag“ abgehakt</CardTitle>
|
||||
<CardDescription>
|
||||
Diese Empfänger bleiben aus der Liste heraus, auch nach dem nächsten Import.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<ul className="divide-y text-sm">
|
||||
{bild.abgehakt.map((eintrag) => (
|
||||
<li
|
||||
key={eintrag.id}
|
||||
className="flex flex-wrap items-center justify-between gap-2 py-2"
|
||||
>
|
||||
<span>
|
||||
<span className="font-medium">{eintrag.anzeigename}</span>
|
||||
{eintrag.begruendung && (
|
||||
<span className="ml-2 text-muted-foreground">
|
||||
— {eintrag.begruendung}
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
{schreiben && (
|
||||
<Zurueckholen betreuteId={betreute.id} eintragId={eintrag.id} />
|
||||
)}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</CardContent>
|
||||
</Card>
|
||||
)}
|
||||
|
||||
<Alert variant="hinweis">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Diese Seite wertet nur aus, sie legt nichts an. Gruppiert wird nach dem Empfänger
|
||||
aus dem Kontoauszug — Groß- und Kleinschreibung, Satzzeichen und die Rechtsform
|
||||
werden dabei zusammengefasst. Ähnliche, aber verschiedene Namen bleiben bewusst
|
||||
getrennt: „Stadtwerke Bamberg“ und „Stadtwerke Bayreuth“ sind zwei Rechnungssteller.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,11 +1,62 @@
|
||||
import { redirect } from 'next/navigation'
|
||||
import { Info } from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { LEERER_VERTRAG, VertragFormular } from '@/components/vertraege/vertrag-formular'
|
||||
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
|
||||
import { alsZahlRhythmus, type Rhythmus } from '@/lib/finanzen/wiederkehrend'
|
||||
import { betragFormatieren } from '@/lib/finanzen/betrag'
|
||||
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
export default async function VertragAnlegen() {
|
||||
/**
|
||||
* Uebernimmt eine Vorbelegung aus der Adresszeile.
|
||||
*
|
||||
* Sie kommt von "Wiederkehrende Zahlungen": Dort steht schon, wer da
|
||||
* abbucht und wie viel. Diese Angaben noch einmal abzutippen waere genau
|
||||
* die Arbeit, die die Auswertung ersparen soll.
|
||||
*
|
||||
* Uebernommen wird nur, was aus dem Kontoauszug ablesbar ist - Gesellschaft,
|
||||
* Beitrag, Rhythmus. Die Bezeichnung und die Vertragsart bleiben leer: Was
|
||||
* fuer ein Vertrag das ist, steht nicht im Auszug, und eine geratene
|
||||
* Vorbelegung wird uebersehen statt korrigiert.
|
||||
*/
|
||||
function vorbelegung(parameter: Record<string, string | string[] | undefined>) {
|
||||
const text = (name: string): string => {
|
||||
const wert = parameter[name]
|
||||
return typeof wert === 'string' ? wert.trim() : ''
|
||||
}
|
||||
|
||||
const werte = { ...LEERER_VERTRAG }
|
||||
let etwasUebernommen = false
|
||||
|
||||
const gesellschaft = text('gesellschaft')
|
||||
if (gesellschaft) {
|
||||
werte.gesellschaft = gesellschaft.slice(0, 200)
|
||||
etwasUebernommen = true
|
||||
}
|
||||
|
||||
const cent = text('beitragCent')
|
||||
if (/^[0-9]{1,15}$/.test(cent)) {
|
||||
werte.beitrag = betragFormatieren(BigInt(cent))
|
||||
etwasUebernommen = true
|
||||
}
|
||||
|
||||
const rhythmus = alsZahlRhythmus(text('rhythmus') as Rhythmus)
|
||||
if (rhythmus) {
|
||||
werte.rhythmus = rhythmus as typeof werte.rhythmus
|
||||
etwasUebernommen = true
|
||||
}
|
||||
|
||||
return { werte, etwasUebernommen }
|
||||
}
|
||||
|
||||
export default async function VertragAnlegen({
|
||||
searchParams,
|
||||
}: {
|
||||
searchParams: Promise<Record<string, string | string[] | undefined>>
|
||||
}) {
|
||||
const parameter = await searchParams
|
||||
const benutzer = await erfordereBenutzer('/vertraege/neu')
|
||||
const aktive = await aktiveBetreute(benutzer)
|
||||
if (!aktive) return null
|
||||
@@ -13,6 +64,8 @@ export default async function VertragAnlegen() {
|
||||
const { darfSchreiben } = await erfordereZugang(aktive.id, 'VERTRAEGE', 'lesen')
|
||||
if (!darfSchreiben('VERTRAEGE')) redirect('/vertraege')
|
||||
|
||||
const { werte, etwasUebernommen } = vorbelegung(parameter)
|
||||
|
||||
return (
|
||||
<div className="space-y-6">
|
||||
<SeitenKopf
|
||||
@@ -25,7 +78,18 @@ export default async function VertragAnlegen() {
|
||||
]}
|
||||
/>
|
||||
|
||||
<VertragFormular betreuteId={aktive.id} werte={LEERER_VERTRAG} />
|
||||
{etwasUebernommen && (
|
||||
<Alert variant="hinweis">
|
||||
<Info aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Gesellschaft, Beitrag und Rhythmus sind aus den wiederkehrenden Zahlungen
|
||||
übernommen. Bezeichnung und Art musst du selbst wählen — was für ein Vertrag das
|
||||
ist, steht nicht im Kontoauszug.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
<VertragFormular betreuteId={aktive.id} werte={werte} />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import Link from 'next/link'
|
||||
import { ReceiptText } from 'lucide-react'
|
||||
import { Repeat, ReceiptText } from 'lucide-react'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Leerzustand } from '@/components/seiten-kopf'
|
||||
import { Kachel, KachelZeile } from '@/components/dashboard/kachel'
|
||||
@@ -17,7 +17,10 @@ import { formatCent, formatDatum } from '@/lib/utils'
|
||||
export function BelegeKachel({ daten }: { daten: BelegeDaten | null }) {
|
||||
if (!daten) return null
|
||||
|
||||
const offen = daten.belegeOhneBuchungGesamt + daten.buchungenOhneBelegGesamt
|
||||
const offen =
|
||||
daten.belegeOhneBuchungGesamt +
|
||||
daten.buchungenOhneBelegGesamt +
|
||||
daten.wiederkehrendOhneVertrag
|
||||
|
||||
return (
|
||||
<Kachel
|
||||
@@ -72,6 +75,29 @@ export function BelegeKachel({ daten }: { daten: BelegeDaten | null }) {
|
||||
</section>
|
||||
)}
|
||||
|
||||
{daten.wiederkehrendOhneVertrag > 0 && (
|
||||
<section aria-labelledby="wiederkehrend-ohne-vertrag">
|
||||
<h3
|
||||
id="wiederkehrend-ohne-vertrag"
|
||||
className="mb-1 text-sm font-semibold uppercase tracking-wide text-muted-foreground"
|
||||
>
|
||||
Regelmäßige Abbuchungen ohne Vertrag ({daten.wiederkehrendOhneVertrag})
|
||||
</h3>
|
||||
<KachelZeile href="/finanzen/wiederkehrend">
|
||||
<span className="min-w-0 flex-1">
|
||||
<span className="flex items-center gap-2 font-medium">
|
||||
<Repeat className="size-4 shrink-0" aria-hidden="true" />
|
||||
{daten.wiederkehrendOhneVertrag} Empfänger ansehen
|
||||
</span>
|
||||
<span className="block text-sm text-muted-foreground">
|
||||
Wer regelmäßig abbucht, hat einen Vertrag — und der fehlt dann im
|
||||
Vermögensverzeichnis.
|
||||
</span>
|
||||
</span>
|
||||
</KachelZeile>
|
||||
</section>
|
||||
)}
|
||||
|
||||
{daten.buchungenOhneBelegGesamt > 0 && (
|
||||
<section aria-labelledby="buchungen-ohne-beleg">
|
||||
<h3
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
'use client'
|
||||
|
||||
import * as React from 'react'
|
||||
import { useActionState } from 'react'
|
||||
import { AlertCircle, CheckCircle2, Undo2, XCircle } from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Input } from '@/components/ui/input'
|
||||
import { Absendeknopf } from '@/components/finanzen/eingaben'
|
||||
import {
|
||||
zahlungsgruppeAbhaken,
|
||||
zahlungsgruppeZurueckholen,
|
||||
type Formularzustand,
|
||||
} from '@/server/actions/finanzen'
|
||||
|
||||
/**
|
||||
* „Kein Vertrag" — eine Gruppe dauerhaft aus der Liste nehmen.
|
||||
*
|
||||
* Die Begründung ist freiwillig, steht aber im Formular ganz vorn. In einem
|
||||
* Jahr weiß niemand mehr, warum „Stadtwerke Bamberg" abgehakt wurde, und
|
||||
* dann fängt die Prüfung von vorn an. Ein halber Satz jetzt spart das.
|
||||
*/
|
||||
export function AlsGeklaertAbhaken({
|
||||
betreuteId,
|
||||
schluessel,
|
||||
anzeigename,
|
||||
}: {
|
||||
betreuteId: string
|
||||
schluessel: string
|
||||
anzeigename: string
|
||||
}) {
|
||||
const [zustand, absenden] = useActionState<Formularzustand, FormData>(
|
||||
zahlungsgruppeAbhaken,
|
||||
{},
|
||||
)
|
||||
const [offen, setOffen] = React.useState(false)
|
||||
|
||||
if (!offen) {
|
||||
return (
|
||||
<div className="space-y-2">
|
||||
{zustand.fehler && (
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{zustand.fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
<Button type="button" variant="ghost" size="sm" onClick={() => setOffen(true)}>
|
||||
<XCircle aria-hidden="true" />
|
||||
Kein Vertrag
|
||||
</Button>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
return (
|
||||
<form action={absenden} className="space-y-2 rounded-md border p-3">
|
||||
<input type="hidden" name="betreuteId" value={betreuteId} />
|
||||
<input type="hidden" name="schluessel" value={schluessel} />
|
||||
<input type="hidden" name="anzeigename" value={anzeigename} />
|
||||
|
||||
<p className="text-sm">
|
||||
„{anzeigename}“ verschwindet aus der Liste. Zurückholen geht jederzeit.
|
||||
</p>
|
||||
|
||||
<Input
|
||||
name="begruendung"
|
||||
placeholder="Warum kein Vertrag? (z. B. Miete, Strom, Steuer)"
|
||||
maxLength={200}
|
||||
autoFocus
|
||||
/>
|
||||
|
||||
<div className="flex gap-2">
|
||||
<Absendeknopf size="sm" wartetext="Wird abgehakt …">
|
||||
Abhaken
|
||||
</Absendeknopf>
|
||||
<Button type="button" variant="ghost" size="sm" onClick={() => setOffen(false)}>
|
||||
Abbrechen
|
||||
</Button>
|
||||
</div>
|
||||
</form>
|
||||
)
|
||||
}
|
||||
|
||||
/** Holt eine abgehakte Gruppe zurück in die Liste. */
|
||||
export function Zurueckholen({
|
||||
betreuteId,
|
||||
eintragId,
|
||||
}: {
|
||||
betreuteId: string
|
||||
eintragId: string
|
||||
}) {
|
||||
const [zustand, absenden] = useActionState<Formularzustand, FormData>(
|
||||
zahlungsgruppeZurueckholen,
|
||||
{},
|
||||
)
|
||||
|
||||
return (
|
||||
<form action={absenden} className="inline">
|
||||
<input type="hidden" name="betreuteId" value={betreuteId} />
|
||||
<input type="hidden" name="eintragId" value={eintragId} />
|
||||
{zustand.fehler && (
|
||||
<span className="mr-2 text-xs text-destructive">{zustand.fehler}</span>
|
||||
)}
|
||||
<Absendeknopf variant="ghost" size="sm" wartetext="…">
|
||||
<Undo2 aria-hidden="true" />
|
||||
Zurückholen
|
||||
</Absendeknopf>
|
||||
</form>
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Zeigt die Rückmeldung der letzten Aktion.
|
||||
*
|
||||
* Bewusst getrennt von den Knöpfen: Nach dem Abhaken verschwindet die
|
||||
* ganze Zeile samt Knopf, und mit ihr die Erfolgsmeldung. Sie hier
|
||||
* anzuzeigen wäre sinnlos — deshalb steht der Erfolg als kurzer Hinweis
|
||||
* oben auf der Seite, sobald die Liste neu geladen ist.
|
||||
*/
|
||||
export function Rueckmeldung({ text }: { text: string | null }) {
|
||||
if (!text) return null
|
||||
return (
|
||||
<Alert variant="erfolg">
|
||||
<CheckCircle2 aria-hidden="true" />
|
||||
<AlertDescription>{text}</AlertDescription>
|
||||
</Alert>
|
||||
)
|
||||
}
|
||||
@@ -21,6 +21,7 @@ import type {
|
||||
PosteingangDaten,
|
||||
WartetAufAndereDaten,
|
||||
} from '@/lib/dashboard/typen'
|
||||
import { offeneZahlungsgruppen } from '@/lib/finanzen/wiederkehrend-laden'
|
||||
|
||||
/**
|
||||
* Alles, was das Dashboard "Heute" braucht - in einem Rutsch.
|
||||
@@ -267,6 +268,11 @@ export async function dashboardLaden(
|
||||
}
|
||||
: null
|
||||
|
||||
// Regelmaessige Abbuchungen ohne Vertrag. Eigene Abfrage, weil sie andere
|
||||
// Spalten braucht als der Belegzwang - und weil sie ganz entfaellt, wenn
|
||||
// das Finanzmodul nicht lesbar ist.
|
||||
const wiederkehrendOhneVertrag = darfFinanzen ? await offeneZahlungsgruppen(betreuteId) : 0
|
||||
|
||||
const belege: BelegeDaten | null =
|
||||
buchungenOhneBeleg && buchungenOhneBelegGesamt !== null
|
||||
? {
|
||||
@@ -286,6 +292,7 @@ export async function dashboardLaden(
|
||||
gegenstelle: b.gegenstelle,
|
||||
})),
|
||||
buchungenOhneBelegGesamt,
|
||||
wiederkehrendOhneVertrag,
|
||||
}
|
||||
: null
|
||||
|
||||
|
||||
@@ -149,6 +149,15 @@ export type BelegeDaten = {
|
||||
belegeOhneBuchungGesamt: number
|
||||
buchungenOhneBeleg: BuchungOhneBeleg[]
|
||||
buchungenOhneBelegGesamt: number
|
||||
/**
|
||||
* Regelmaessige Abbuchungen ohne hinterlegten Vertrag.
|
||||
*
|
||||
* Steht bewusst in dieser Kachel und nicht in einer eigenen: Es ist
|
||||
* dieselbe Frage - "wozu gehoert diese Zahlung?" -, nur eine Ebene
|
||||
* hoeher. Eine sechste Kachel auf "Heute" waere eine Kachel, die man
|
||||
* nach zwei Wochen nicht mehr sieht.
|
||||
*/
|
||||
wiederkehrendOhneVertrag: number
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
import 'server-only'
|
||||
import { db, nichtGeloescht } from '@/lib/db'
|
||||
import {
|
||||
einzelneZahlungen,
|
||||
gruppieren,
|
||||
offeneKandidaten,
|
||||
type Einzelzahlung,
|
||||
type Zahlungsgruppe,
|
||||
} from '@/lib/finanzen/wiederkehrend'
|
||||
|
||||
/**
|
||||
* Holt die Daten fuer die Ansicht "Wiederkehrende Zahlungen".
|
||||
*
|
||||
* Getrennt von wiederkehrend.ts, damit die Erkennung selbst ohne Datenbank
|
||||
* bleibt und sich mit Einheitstests festnageln laesst. Hier steht nur, was
|
||||
* ohne Postgres nicht geht.
|
||||
*/
|
||||
|
||||
export type WiederkehrendBild = {
|
||||
gruppen: Zahlungsgruppe[]
|
||||
einzelne: Einzelzahlung[]
|
||||
/** Wie viele Gruppen noch keinem Vertrag zugeordnet sind. */
|
||||
offen: number
|
||||
/** Bereits abgehakte Gruppen - zum Zurueckholen. */
|
||||
abgehakt: { id: string; schluessel: string; anzeigename: string; begruendung: string | null }[]
|
||||
/** Wurde ueberhaupt schon etwas importiert? Sonst ist die Seite leer aus gutem Grund. */
|
||||
ausgabenGesamt: number
|
||||
}
|
||||
|
||||
export async function wiederkehrendLaden(betreuteId: string): Promise<WiederkehrendBild> {
|
||||
const [buchungen, vertraege, abgehakt] = await Promise.all([
|
||||
db.buchung.findMany({
|
||||
where: {
|
||||
betreuteId,
|
||||
// Nur echte Ausgaben der betreuten Person. Umbuchungen zwischen
|
||||
// eigenen Konten sind kein Vertragshinweis - wer monatlich aufs
|
||||
// Sparbuch legt, hat deswegen keinen Vertrag. Auslagen des
|
||||
// Betreuers gehoeren ebenfalls nicht hierher.
|
||||
richtung: 'AUSGABE',
|
||||
betrifftBetreute: true,
|
||||
...nichtGeloescht,
|
||||
},
|
||||
select: { id: true, datum: true, betragCent: true, gegenstelle: true },
|
||||
orderBy: { datum: 'asc' },
|
||||
}),
|
||||
db.vertrag.findMany({
|
||||
where: { betreuteId, ...nichtGeloescht },
|
||||
select: { id: true, bezeichnung: true, gesellschaft: true },
|
||||
}),
|
||||
db.zahlungsgruppeGeklaert.findMany({
|
||||
where: { betreuteId },
|
||||
select: { id: true, schluessel: true, anzeigename: true, begruendung: true },
|
||||
orderBy: { anzeigename: 'asc' },
|
||||
}),
|
||||
])
|
||||
|
||||
const optionen = {
|
||||
abgehakt: new Set(abgehakt.map((eintrag) => eintrag.schluessel)),
|
||||
vertraege,
|
||||
}
|
||||
|
||||
const gruppen = gruppieren(buchungen, optionen)
|
||||
|
||||
return {
|
||||
gruppen,
|
||||
einzelne: einzelneZahlungen(buchungen, optionen),
|
||||
offen: offeneKandidaten(gruppen),
|
||||
abgehakt,
|
||||
ausgabenGesamt: buchungen.length,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Nur die Zahl fuer das Dashboard - ohne die vollen Listen aufzubauen.
|
||||
*
|
||||
* Laedt dieselben Buchungen, gibt aber nur die Anzahl offener Gruppen
|
||||
* zurueck. Die Kachel soll die Seite nicht spuerbar verlangsamen.
|
||||
*/
|
||||
export async function offeneZahlungsgruppen(betreuteId: string): Promise<number> {
|
||||
const bild = await wiederkehrendLaden(betreuteId)
|
||||
return bild.offen
|
||||
}
|
||||
@@ -0,0 +1,512 @@
|
||||
import { summe } from '@/lib/finanzen/betrag'
|
||||
import { nachTagSortieren, tageZwischen } from '@/lib/finanzen/datum'
|
||||
|
||||
/**
|
||||
* Wiederkehrende Zahlungen aufspueren - ohne Datenbank, damit sich jede
|
||||
* Entscheidung einzeln nachrechnen laesst.
|
||||
*
|
||||
* Der Anlass: Am Anfang einer Betreuung weiss niemand, welche Vertraege es
|
||||
* gibt. Die Antwort steht aber im Kontoauszug - wer regelmaessig abbucht,
|
||||
* hat einen Vertrag. Diese Datei macht aus hunderten Buchungszeilen eine
|
||||
* Arbeitsliste.
|
||||
*
|
||||
* Zwei Haltungen liegen allem zugrunde:
|
||||
*
|
||||
* 1. **Im Zweifel getrennt lassen.** Zwei Zeilen zu viel sind harmlos - man
|
||||
* sieht hin und hakt ab. Eine falsch zusammengefasste Gruppe verbirgt
|
||||
* dagegen einen Vertrag, und der fehlt dann im Vermoegensverzeichnis.
|
||||
* Deshalb wird nur zusammengefasst, was sicher dasselbe ist.
|
||||
*
|
||||
* 2. **Nichts behaupten, was nicht belegt ist.** Die Erkennung nennt immer
|
||||
* mit, worauf sie sich stuetzt ("4 Zahlungen, etwa alle 3 Monate").
|
||||
* Eine Einordnung ohne nachvollziehbare Grundlage waere geraten, und
|
||||
* geratene Zahlen landen sonst im Bericht ans Gericht.
|
||||
*/
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Eingabe und Ergebnis
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export type ZahlungEingabe = {
|
||||
id: string
|
||||
datum: Date
|
||||
betragCent: bigint
|
||||
gegenstelle: string | null
|
||||
}
|
||||
|
||||
/** Ein hinterlegter Vertrag - zum Abgleich, ob die Zahlung schon erklaert ist. */
|
||||
export type VertragAbgleich = {
|
||||
id: string
|
||||
bezeichnung: string
|
||||
gesellschaft: string | null
|
||||
}
|
||||
|
||||
export type Rhythmus =
|
||||
| 'MONATLICH'
|
||||
| 'ZWEIMONATLICH'
|
||||
| 'VIERTELJAEHRLICH'
|
||||
| 'HALBJAEHRLICH'
|
||||
| 'JAEHRLICH'
|
||||
| 'UNREGELMAESSIG'
|
||||
|
||||
export const RHYTHMUS_BESCHRIFTUNG: Record<Rhythmus, string> = {
|
||||
MONATLICH: 'monatlich',
|
||||
ZWEIMONATLICH: 'zweimonatlich',
|
||||
VIERTELJAEHRLICH: 'vierteljährlich',
|
||||
HALBJAEHRLICH: 'halbjährlich',
|
||||
JAEHRLICH: 'jährlich',
|
||||
UNREGELMAESSIG: 'unregelmäßig',
|
||||
}
|
||||
|
||||
/** Wie oft der Rhythmus im Jahr zuschlaegt. Fuer die Hochrechnung. */
|
||||
const ZAHLUNGEN_JE_JAHR: Record<Rhythmus, number> = {
|
||||
MONATLICH: 12,
|
||||
ZWEIMONATLICH: 6,
|
||||
VIERTELJAEHRLICH: 4,
|
||||
HALBJAEHRLICH: 2,
|
||||
JAEHRLICH: 1,
|
||||
UNREGELMAESSIG: 0,
|
||||
}
|
||||
|
||||
export type Zahlungsgruppe = {
|
||||
/** Normalisierter Name - der Schluessel, unter dem abgehakt wird. */
|
||||
schluessel: string
|
||||
/** Die laengste vorgefundene Schreibweise, fuer die Anzeige. */
|
||||
anzeigename: string
|
||||
/** Alle vorgefundenen Schreibweisen, falls mehrere zusammengefasst wurden. */
|
||||
schreibweisen: string[]
|
||||
anzahl: number
|
||||
ersteZahlung: Date
|
||||
letzteZahlung: Date
|
||||
/** Median der Betraege - unempfindlicher gegen einen Ausreisser als der Schnitt. */
|
||||
betragCent: bigint
|
||||
kleinsterBetragCent: bigint
|
||||
groessterBetragCent: bigint
|
||||
/** Schwanken die Betraege stark? Dann ist es eher keine feste Praemie. */
|
||||
betragSchwankt: boolean
|
||||
rhythmus: Rhythmus
|
||||
/** Medianabstand in Tagen - die Grundlage der Rhythmuserkennung. */
|
||||
abstandTage: number | null
|
||||
/** Hochgerechnet auf ein Jahr. Bei unregelmaessigem Rhythmus: das
|
||||
* tatsaechlich Gezahlte, nicht hochgerechnet. */
|
||||
jahresbetragCent: bigint
|
||||
/** Passt der Name zu einem hinterlegten Vertrag? */
|
||||
vertragId: string | null
|
||||
vertragBezeichnung: string | null
|
||||
buchungIds: string[]
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Namen vergleichbar machen
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Rechtsformen und Zusaetze, die keinen Unterschied machen.
|
||||
*
|
||||
* Bewusst kurz gehalten. Jeder Eintrag hier ist eine Behauptung "das darf
|
||||
* weg" - und jede falsche Behauptung wirft zwei verschiedene Empfaenger
|
||||
* zusammen. "Versicherung" steht deshalb NICHT in der Liste: Zwischen
|
||||
* "Allianz Versicherung" und "Allianz Lebensversicherung" liegt ein
|
||||
* Unterschied, der im Vermoegensverzeichnis zaehlt.
|
||||
*/
|
||||
const RECHTSFORMEN = [
|
||||
'gmbh & co kg',
|
||||
'gmbh und co kg',
|
||||
'gmbh',
|
||||
'mbh',
|
||||
'ohg',
|
||||
'kgaa',
|
||||
'kg',
|
||||
'ag',
|
||||
'se',
|
||||
'ev',
|
||||
'vvag',
|
||||
'ag',
|
||||
'aoer',
|
||||
'koer',
|
||||
]
|
||||
|
||||
/** Ersetzt Umlaute, damit "Muenchener" und "Münchener" zusammenfallen. */
|
||||
function umlauteAufloesen(text: string): string {
|
||||
return text
|
||||
.replace(/ä/g, 'ae')
|
||||
.replace(/ö/g, 'oe')
|
||||
.replace(/ü/g, 'ue')
|
||||
.replace(/ß/g, 'ss')
|
||||
}
|
||||
|
||||
/**
|
||||
* Macht zwei Schreibweisen desselben Empfaengers vergleichbar.
|
||||
*
|
||||
* Was hier zusammenfaellt, wird spaeter in einer Zeile angezeigt. Deshalb
|
||||
* nur das Unstrittige: Gross- und Kleinschreibung, Satzzeichen, doppelte
|
||||
* Leerzeichen, Umlaute und die Rechtsform am Ende.
|
||||
*
|
||||
* Was ausdruecklich NICHT passiert: Aehnlichkeitssuche ueber Abstandsmasse.
|
||||
* "Stadtwerke Bamberg" und "Stadtwerke Bayreuth" unterscheiden sich in drei
|
||||
* Zeichen und sind zwei voellig verschiedene Rechnungssteller.
|
||||
*/
|
||||
export function normalisieren(gegenstelle: string | null | undefined): string {
|
||||
if (!gegenstelle) return ''
|
||||
|
||||
let text = umlauteAufloesen(gegenstelle.toLowerCase())
|
||||
|
||||
// Satzzeichen zu Leerzeichen, damit "vers.ag" zu "vers ag" wird und die
|
||||
// Rechtsform anschliessend als eigenes Wort erkennbar ist.
|
||||
text = text.replace(/[.,;:/\\()[\]{}"'`*+_-]/g, ' ')
|
||||
text = text.replace(/\s+/g, ' ').trim()
|
||||
|
||||
// Rechtsform nur am ENDE entfernen. Mitten im Namen kann dieselbe
|
||||
// Zeichenfolge etwas anderes sein - "ag" steckt in "Agentur".
|
||||
let geaendert = true
|
||||
while (geaendert) {
|
||||
geaendert = false
|
||||
for (const form of RECHTSFORMEN) {
|
||||
if (text.endsWith(` ${form}`)) {
|
||||
text = text.slice(0, -(form.length + 1)).trim()
|
||||
geaendert = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return text
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Rhythmus
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
function median(werte: number[]): number {
|
||||
if (werte.length === 0) return 0
|
||||
const sortiert = [...werte].sort((a, b) => a - b)
|
||||
const mitte = Math.floor(sortiert.length / 2)
|
||||
return sortiert.length % 2 === 1
|
||||
? sortiert[mitte]!
|
||||
: Math.round((sortiert[mitte - 1]! + sortiert[mitte]!) / 2)
|
||||
}
|
||||
|
||||
function medianBigInt(werte: bigint[]): bigint {
|
||||
if (werte.length === 0) return 0n
|
||||
const sortiert = [...werte].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
|
||||
const mitte = Math.floor(sortiert.length / 2)
|
||||
return sortiert.length % 2 === 1
|
||||
? sortiert[mitte]!
|
||||
: (sortiert[mitte - 1]! + sortiert[mitte]!) / 2n
|
||||
}
|
||||
|
||||
/**
|
||||
* Ordnet einen Medianabstand einem Rhythmus zu.
|
||||
*
|
||||
* Die Spannen sind bewusst weit: Lastschriften kommen am ersten Werktag,
|
||||
* und der wandert. Zwischen dem 1. Februar und dem 1. Maerz liegen 28 Tage,
|
||||
* zwischen dem 1. Juli und dem 1. August 31 - beides ist monatlich.
|
||||
*/
|
||||
export function rhythmusAusAbstand(tage: number): Rhythmus {
|
||||
if (tage >= 24 && tage <= 38) return 'MONATLICH'
|
||||
if (tage >= 50 && tage <= 70) return 'ZWEIMONATLICH'
|
||||
if (tage >= 80 && tage <= 100) return 'VIERTELJAEHRLICH'
|
||||
if (tage >= 160 && tage <= 200) return 'HALBJAEHRLICH'
|
||||
if (tage >= 330 && tage <= 400) return 'JAEHRLICH'
|
||||
return 'UNREGELMAESSIG'
|
||||
}
|
||||
|
||||
/** Der Medianabstand zwischen aufeinanderfolgenden Zahlungen, in Tagen. */
|
||||
export function abstandInTagen(daten: Date[]): number | null {
|
||||
if (daten.length < 2) return null
|
||||
const sortiert = nachTagSortieren(daten, (d) => d)
|
||||
const abstaende: number[] = []
|
||||
for (let i = 1; i < sortiert.length; i++) {
|
||||
abstaende.push(Math.abs(tageZwischen(sortiert[i - 1]!, sortiert[i]!)))
|
||||
}
|
||||
return median(abstaende)
|
||||
}
|
||||
|
||||
/**
|
||||
* Schwanken die Betraege so stark, dass es keine feste Zahlung mehr ist?
|
||||
*
|
||||
* Ein Fuenftel Abweichung vom Median ist grosszuegig - Beitragsanpassungen
|
||||
* und Stromabschlaege bewegen sich in dieser Groessenordnung. Wer darueber
|
||||
* liegt, zahlt eher nach Verbrauch als nach Vertrag.
|
||||
*/
|
||||
export function betraegeSchwanken(betraege: bigint[]): boolean {
|
||||
if (betraege.length < 2) return false
|
||||
const mitte = medianBigInt(betraege)
|
||||
if (mitte === 0n) return true
|
||||
|
||||
return betraege.some((betrag) => {
|
||||
const abweichung = betrag > mitte ? betrag - mitte : mitte - betrag
|
||||
// Ganzzahlig gerechnet: |x - m| * 100 > m * 20
|
||||
return abweichung * 100n > mitte * 20n
|
||||
})
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Gruppieren
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Ab wann gilt eine Zahlung als wiederkehrend?
|
||||
*
|
||||
* Zwei ist das Minimum, das ueberhaupt einen Abstand ergibt. Damit bleibt
|
||||
* eine Luecke, die man kennen muss: Eine JAEHRLICH abgebuchte Praemie
|
||||
* erscheint bei nur einem importierten Jahr genau einmal und wird hier
|
||||
* nicht gefunden. Deshalb gibt es daneben die Liste der einzelnen groesseren
|
||||
* Zahlungen - siehe einzelneZahlungen().
|
||||
*/
|
||||
export const MINDESTANZAHL = 2
|
||||
|
||||
export type GruppierungsOptionen = {
|
||||
/** Schon abgehakte Schluessel - "das ist kein Vertrag". */
|
||||
abgehakt?: ReadonlySet<string>
|
||||
/** Hinterlegte Vertraege, zum Abgleich. */
|
||||
vertraege?: VertragAbgleich[]
|
||||
}
|
||||
|
||||
/** Ordnet Vertraege ihrem normalisierten Gesellschaftsnamen zu. */
|
||||
function vertragsIndex(vertraege: VertragAbgleich[]): Map<string, VertragAbgleich> {
|
||||
const index = new Map<string, VertragAbgleich>()
|
||||
for (const vertrag of vertraege) {
|
||||
const schluessel = normalisieren(vertrag.gesellschaft)
|
||||
// Erster Treffer gewinnt. Zwei Vertraege bei derselben Gesellschaft sind
|
||||
// moeglich (Hausrat und Haftpflicht bei der Allianz); fuer die Frage
|
||||
// "ist das schon erklaert?" genuegt einer.
|
||||
if (schluessel && !index.has(schluessel)) index.set(schluessel, vertrag)
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
/**
|
||||
* Waehlt aus mehreren Schreibweisen die, die man jemandem zeigen kann.
|
||||
*
|
||||
* Banken liefern denselben Empfaenger mal als "Allianz Lebensversicherung
|
||||
* AG", mal als "ALLIANZ LEBENSVERS AG". Die laengste zu nehmen waere
|
||||
* naheliegend - und faellt regelmaessig auf die geschriene Fassung herein,
|
||||
* weil Versalien nicht kuerzer sind.
|
||||
*
|
||||
* Das ist mehr als Kosmetik: Dieser Name wird beim "Vertrag anlegen" in das
|
||||
* Feld Gesellschaft uebernommen. Steht dort alles in Grossbuchstaben, tippt
|
||||
* man es von Hand neu - und dann war die Vorbelegung wertlos.
|
||||
*
|
||||
* Also: erst die Schreibweisen mit Klein- und Grossbuchstaben, unter denen
|
||||
* die laengste. Gibt es nur geschriene, nimmt man eben die laengste davon.
|
||||
*/
|
||||
export function besteSchreibweise(schreibweisen: string[]): string {
|
||||
if (schreibweisen.length === 0) return ''
|
||||
|
||||
const gemischt = schreibweisen.filter((name) => name !== name.toUpperCase())
|
||||
const auswahl = gemischt.length > 0 ? gemischt : schreibweisen
|
||||
|
||||
return auswahl.reduce((a, b) => (b.length > a.length ? b : a), auswahl[0]!)
|
||||
}
|
||||
|
||||
/**
|
||||
* Fasst Zahlungen zu Gruppen zusammen und bewertet sie.
|
||||
*
|
||||
* Erwartet werden ausschliesslich Ausgaben, die die betreute Person
|
||||
* betreffen - die Auswahl trifft der Aufrufer, weil sie von der Datenbank
|
||||
* kommt. Umbuchungen zwischen eigenen Konten gehoeren nicht hierher: Wer
|
||||
* monatlich aufs Sparbuch legt, hat deswegen keinen Vertrag.
|
||||
*/
|
||||
export function gruppieren(
|
||||
zahlungen: ZahlungEingabe[],
|
||||
optionen: GruppierungsOptionen = {},
|
||||
): Zahlungsgruppe[] {
|
||||
const abgehakt = optionen.abgehakt ?? new Set<string>()
|
||||
const index = vertragsIndex(optionen.vertraege ?? [])
|
||||
|
||||
const nachSchluessel = new Map<string, ZahlungEingabe[]>()
|
||||
for (const zahlung of zahlungen) {
|
||||
const schluessel = normalisieren(zahlung.gegenstelle)
|
||||
// Ohne Gegenstelle gibt es nichts zu gruppieren. Solche Buchungen sind
|
||||
// Bargeldabhebungen oder handerfasste Zeilen - kein Vertragshinweis.
|
||||
if (!schluessel) continue
|
||||
if (abgehakt.has(schluessel)) continue
|
||||
|
||||
const bisher = nachSchluessel.get(schluessel)
|
||||
if (bisher) bisher.push(zahlung)
|
||||
else nachSchluessel.set(schluessel, [zahlung])
|
||||
}
|
||||
|
||||
const gruppen: Zahlungsgruppe[] = []
|
||||
|
||||
for (const [schluessel, posten] of nachSchluessel) {
|
||||
if (posten.length < MINDESTANZAHL) continue
|
||||
|
||||
const sortiert = nachTagSortieren(posten, (p) => p.datum)
|
||||
const betraege = posten.map((p) => p.betragCent)
|
||||
const abstandTage = abstandInTagen(posten.map((p) => p.datum))
|
||||
const rhythmus = abstandTage === null ? 'UNREGELMAESSIG' : rhythmusAusAbstand(abstandTage)
|
||||
const betragCent = medianBigInt(betraege)
|
||||
|
||||
const jeJahr = ZAHLUNGEN_JE_JAHR[rhythmus]
|
||||
const jahresbetragCent =
|
||||
jeJahr > 0 ? betragCent * BigInt(jeJahr) : summe(betraege)
|
||||
|
||||
const schreibweisen = [
|
||||
...new Set(posten.map((p) => (p.gegenstelle ?? '').trim()).filter(Boolean)),
|
||||
].sort()
|
||||
|
||||
const vertrag = index.get(schluessel) ?? null
|
||||
|
||||
gruppen.push({
|
||||
schluessel,
|
||||
anzeigename: besteSchreibweise(schreibweisen) || schluessel,
|
||||
schreibweisen,
|
||||
anzahl: posten.length,
|
||||
ersteZahlung: sortiert[0]!.datum,
|
||||
letzteZahlung: sortiert[sortiert.length - 1]!.datum,
|
||||
betragCent,
|
||||
kleinsterBetragCent: betraege.reduce((a, b) => (b < a ? b : a), betraege[0]!),
|
||||
groessterBetragCent: betraege.reduce((a, b) => (b > a ? b : a), betraege[0]!),
|
||||
betragSchwankt: betraegeSchwanken(betraege),
|
||||
rhythmus,
|
||||
abstandTage,
|
||||
jahresbetragCent,
|
||||
vertragId: vertrag?.id ?? null,
|
||||
vertragBezeichnung: vertrag?.bezeichnung ?? null,
|
||||
buchungIds: sortiert.map((p) => p.id),
|
||||
})
|
||||
}
|
||||
|
||||
// Absteigend nach Jahresbetrag: Was am meisten kostet, will man zuerst
|
||||
// geklaert haben.
|
||||
return gruppen.sort((a, b) =>
|
||||
a.jahresbetragCent > b.jahresbetragCent
|
||||
? -1
|
||||
: a.jahresbetragCent < b.jahresbetragCent
|
||||
? 1
|
||||
: a.anzeigename.localeCompare(b.anzeigename, 'de'),
|
||||
)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Die Luecke: einmalige Zahlungen
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Ab welchem Betrag eine einzelne Zahlung erwaehnenswert ist.
|
||||
*
|
||||
* 150 EUR ist die Grenze, ab der sich das Nachsehen lohnt. Darunter stehen
|
||||
* Einkaeufe und Gebuehren, darueber faengt es an, nach Jahresbeitrag
|
||||
* auszusehen.
|
||||
*/
|
||||
export const EINZELZAHLUNG_AB_CENT = 15_000n
|
||||
|
||||
export type Einzelzahlung = {
|
||||
schluessel: string
|
||||
anzeigename: string
|
||||
buchungId: string
|
||||
datum: Date
|
||||
betragCent: bigint
|
||||
vertragId: string | null
|
||||
vertragBezeichnung: string | null
|
||||
}
|
||||
|
||||
/**
|
||||
* Einzelne groessere Zahlungen ohne hinterlegten Vertrag.
|
||||
*
|
||||
* Der Grund fuer diese zweite Liste: Die Gruppierung braucht mindestens
|
||||
* zwei Zahlungen. Eine jaehrlich abgebuchte Versicherungspraemie erscheint
|
||||
* bei einem importierten Jahr aber genau einmal - und ausgerechnet
|
||||
* Versicherungen werden oft jaehrlich gezahlt. Ohne diese Liste waere die
|
||||
* Suche genau dort blind, wo sie am meisten bringen soll.
|
||||
*
|
||||
* Sie ist ausdruecklich kein Vertragsverdacht, sondern eine Merkliste. In
|
||||
* der Oberflaeche steht sie deshalb getrennt und mit eigener Ueberschrift.
|
||||
*/
|
||||
export function einzelneZahlungen(
|
||||
zahlungen: ZahlungEingabe[],
|
||||
optionen: GruppierungsOptionen = {},
|
||||
): Einzelzahlung[] {
|
||||
const abgehakt = optionen.abgehakt ?? new Set<string>()
|
||||
const index = vertragsIndex(optionen.vertraege ?? [])
|
||||
|
||||
const anzahlJeSchluessel = new Map<string, number>()
|
||||
for (const zahlung of zahlungen) {
|
||||
const schluessel = normalisieren(zahlung.gegenstelle)
|
||||
if (!schluessel) continue
|
||||
anzahlJeSchluessel.set(schluessel, (anzahlJeSchluessel.get(schluessel) ?? 0) + 1)
|
||||
}
|
||||
|
||||
const treffer: Einzelzahlung[] = []
|
||||
|
||||
for (const zahlung of zahlungen) {
|
||||
const schluessel = normalisieren(zahlung.gegenstelle)
|
||||
if (!schluessel) continue
|
||||
if (abgehakt.has(schluessel)) continue
|
||||
// Alles, was mehrfach vorkommt, steht bereits in der Gruppenliste.
|
||||
if ((anzahlJeSchluessel.get(schluessel) ?? 0) >= MINDESTANZAHL) continue
|
||||
if (zahlung.betragCent < EINZELZAHLUNG_AB_CENT) continue
|
||||
|
||||
const vertrag = index.get(schluessel) ?? null
|
||||
|
||||
treffer.push({
|
||||
schluessel,
|
||||
anzeigename: (zahlung.gegenstelle ?? '').trim() || schluessel,
|
||||
buchungId: zahlung.id,
|
||||
datum: zahlung.datum,
|
||||
betragCent: zahlung.betragCent,
|
||||
vertragId: vertrag?.id ?? null,
|
||||
vertragBezeichnung: vertrag?.bezeichnung ?? null,
|
||||
})
|
||||
}
|
||||
|
||||
return treffer.sort((a, b) =>
|
||||
a.betragCent > b.betragCent ? -1 : a.betragCent < b.betragCent ? 1 : 0,
|
||||
)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Fuer die Anzeige
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Der Satz, der unter einer Gruppe steht.
|
||||
*
|
||||
* Er nennt die Grundlage der Einordnung, statt nur das Ergebnis zu
|
||||
* behaupten - damit man widersprechen kann, wenn es nicht stimmt.
|
||||
*/
|
||||
export function rhythmusErklaerung(gruppe: Zahlungsgruppe): string {
|
||||
const zahlungen = `${gruppe.anzahl} ${gruppe.anzahl === 1 ? 'Zahlung' : 'Zahlungen'}`
|
||||
|
||||
if (gruppe.rhythmus === 'UNREGELMAESSIG' || gruppe.abstandTage === null) {
|
||||
return `${zahlungen}, ohne erkennbaren Abstand`
|
||||
}
|
||||
|
||||
const tage = gruppe.abstandTage
|
||||
const monate = Math.round(tage / 30)
|
||||
const abstand =
|
||||
monate <= 1 ? 'etwa monatlich' : `etwa alle ${monate} Monate`
|
||||
|
||||
return `${zahlungen}, ${abstand}`
|
||||
}
|
||||
|
||||
/**
|
||||
* Uebersetzt den erkannten Rhythmus in den Zahlrhythmus des Vertrags.
|
||||
*
|
||||
* Zwei Faelle haben dort keine Entsprechung: ZWEIMONATLICH kennt das
|
||||
* Vertragsmodell nicht, und UNREGELMAESSIG ist keine Aussage, sondern das
|
||||
* Eingestaendnis, keine zu haben. Beide liefern null - dann bleibt im
|
||||
* Formular die Vorgabe stehen, statt etwas Falsches vorzublenden. Eine
|
||||
* vorbelegte falsche Angabe wird uebersehen; ein leeres Feld nicht.
|
||||
*/
|
||||
export function alsZahlRhythmus(rhythmus: Rhythmus): string | null {
|
||||
switch (rhythmus) {
|
||||
case 'MONATLICH':
|
||||
return 'MONATLICH'
|
||||
case 'VIERTELJAEHRLICH':
|
||||
return 'VIERTELJAEHRLICH'
|
||||
case 'HALBJAEHRLICH':
|
||||
return 'HALBJAEHRLICH'
|
||||
case 'JAEHRLICH':
|
||||
return 'JAEHRLICH'
|
||||
default:
|
||||
return 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
|
||||
}
|
||||
+1
-1
@@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
/** Muss zur "version" in der package.json passen. */
|
||||
export const VERSION = '1.1.2'
|
||||
export const VERSION = '1.2.0'
|
||||
|
||||
/**
|
||||
* Kurzer Git-Stand, beim Bauen hineingereicht:
|
||||
|
||||
@@ -821,3 +821,106 @@ export async function wertstandLoeschen(
|
||||
revalidatePath('/finanzen/vermoegen')
|
||||
return { erfolg: 'Wert gelöscht.' }
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Wiederkehrende Zahlungen
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Hakt eine Gruppe wiederkehrender Zahlungen als "kein Vertrag" ab.
|
||||
*
|
||||
* Der Schluessel kommt aus normalisieren() und wird hier NICHT noch einmal
|
||||
* gebildet: Was der Benutzer auf dem Bildschirm gesehen hat, soll auch
|
||||
* abgehakt werden. Bildeten Anzeige und Aktion den Schluessel getrennt,
|
||||
* koennten sie auseinanderlaufen - und dann verschwaende eine andere
|
||||
* Gruppe als die angeklickte.
|
||||
*/
|
||||
export async function zahlungsgruppeAbhaken(
|
||||
_zustand: Formularzustand,
|
||||
daten: FormData,
|
||||
): Promise<Formularzustand> {
|
||||
const betreuteId = String(daten.get('betreuteId') ?? '')
|
||||
const schluessel = String(daten.get('schluessel') ?? '').trim()
|
||||
const anzeigename = String(daten.get('anzeigename') ?? '').trim()
|
||||
const begruendung = String(daten.get('begruendung') ?? '').trim()
|
||||
|
||||
if (!schluessel || !anzeigename) {
|
||||
return { fehler: 'Diese Zahlungsgruppe lässt sich nicht zuordnen.' }
|
||||
}
|
||||
|
||||
try {
|
||||
const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
|
||||
|
||||
await db.zahlungsgruppeGeklaert.upsert({
|
||||
where: { betreuteId_schluessel: { betreuteId, schluessel } },
|
||||
create: {
|
||||
betreuteId,
|
||||
schluessel,
|
||||
anzeigename,
|
||||
begruendung: begruendung === '' ? null : begruendung,
|
||||
},
|
||||
update: { begruendung: begruendung === '' ? null : begruendung },
|
||||
})
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'ERSTELLT',
|
||||
entitaet: 'ZahlungsgruppeGeklaert',
|
||||
bezeichnung: `${anzeigename} — kein Vertrag`,
|
||||
betreuteId,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
})
|
||||
} catch (ausnahme) {
|
||||
const verweigert = zugriffsfehler(ausnahme)
|
||||
if (verweigert) return verweigert
|
||||
console.error('[finanzen] Zahlungsgruppe konnte nicht abgehakt werden:', ausnahme)
|
||||
return { fehler: 'Die Zahlungsgruppe konnte nicht abgehakt werden.' }
|
||||
}
|
||||
|
||||
revalidatePath('/finanzen/wiederkehrend')
|
||||
revalidatePath('/heute')
|
||||
return { erfolg: `„${anzeigename}“ gilt als geklärt.` }
|
||||
}
|
||||
|
||||
/** Holt eine abgehakte Gruppe zurueck in die Liste. */
|
||||
export async function zahlungsgruppeZurueckholen(
|
||||
_zustand: Formularzustand,
|
||||
daten: FormData,
|
||||
): Promise<Formularzustand> {
|
||||
const betreuteId = String(daten.get('betreuteId') ?? '')
|
||||
const eintragId = String(daten.get('eintragId') ?? '')
|
||||
|
||||
try {
|
||||
const { benutzer } = await erfordereZugang(betreuteId, 'FINANZEN', 'schreiben')
|
||||
|
||||
// Zeilenweise Pruefung: Die ID muss zu DIESER betreuten Person gehoeren.
|
||||
const eintrag = await db.zahlungsgruppeGeklaert.findFirst({
|
||||
where: { id: eintragId, betreuteId },
|
||||
select: { id: true, anzeigename: true },
|
||||
})
|
||||
if (!eintrag) return { fehler: 'Diesen Eintrag gibt es nicht (mehr).' }
|
||||
|
||||
await db.zahlungsgruppeGeklaert.delete({ where: { id: eintrag.id } })
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'GELOESCHT',
|
||||
entitaet: 'ZahlungsgruppeGeklaert',
|
||||
entitaetId: eintrag.id,
|
||||
bezeichnung: `${eintrag.anzeigename} — wieder offen`,
|
||||
betreuteId,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
})
|
||||
} catch (ausnahme) {
|
||||
const verweigert = zugriffsfehler(ausnahme)
|
||||
if (verweigert) return verweigert
|
||||
console.error('[finanzen] Zahlungsgruppe konnte nicht zurückgeholt werden:', ausnahme)
|
||||
return { fehler: 'Der Eintrag konnte nicht zurückgeholt werden.' }
|
||||
}
|
||||
|
||||
revalidatePath('/finanzen/wiederkehrend')
|
||||
revalidatePath('/heute')
|
||||
return { erfolg: 'Die Gruppe steht wieder in der Liste.' }
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user