feat: Stammdaten, Ersteinrichtung, Zweitfaktor und Protokollansicht
Damit ist Etappe 1 fachlich vollstaendig. Ersteinrichtung in drei Schritten, bewusst ausserhalb des Anwendungsrahmens: der setzt Benutzer, zweiten Faktor UND eine betreute Person voraus - beim allerersten Start gibt es nichts davon. Die Aktion fuer den ersten Zugang sperrt sich selbst, sobald ein Benutzer existiert. Zweiter Faktor: Das Geheimnis wird zuerst nur abgelegt, ohne totpAktiviertAm. Erst ein echter Code aus der App schaltet ihn scharf. Wer sich beim Abtippen vertut oder die falsche App nimmt, wuerde sich sonst dauerhaft aussperren. Erst danach gibt es die Wiederherstellungscodes - einmal angezeigt, danach nur noch als Hash. Betreuungsjahr (src/lib/stammdaten/betreuungsjahr.ts): laeuft ab dem Tag der Bestellung, nicht ab dem Kalenderjahr. Schrittweise vorwaerts gerechnet statt ueber eine Differenz, damit Schaltjahre und der 29. Februar von selbst stimmen. Daran haengen Jahresbericht, Rechnungslegung und die Ausschlussfrist der Aufwandspauschale. Aendert sich das Bestellungsdatum, werden die Pflichtfristen neu abgeleitet - ueber einen dynamischen Import, damit die Stammdaten auch dann speicherbar bleiben, wenn das Fristenmodul fehlt. Protokollansicht zeigt je Eintrag die geaenderten Felder als alt -> neu. Die Aenderungen liegen verschluesselt, weil dort Diagnosen und Kontostaende stehen koennen. Seed legt bewusst keine echten Personendaten an, nur den ersten Zugang. Mit SEED_DEMO=true kommt ein vollstaendiger Beispielfall dazu - Erika Musterfrau, COPD GOLD III, Pflegegrad 3, Heimeinzug Januar 2026, leerstehendes Haus, zwei Versicherungen, laufender Antrag beim Bezirk mit acht Nachforderungen. Nur ausserhalb der Produktion. Docker Compose ohne Reverse Proxy - der ist auf dem Zielserver vorhanden. Die Datenbank hat keine Portfreigabe und ist nur ueber das interne Netz erreichbar; die Anwendung horcht auf 127.0.0.1. Etappe: 1 Phase: Fundament
This commit is contained in:
Florian Wilde
@@ -0,0 +1,282 @@
|
||||
import type { BuchungKategorie, BuchungRichtung } from '@prisma/client'
|
||||
import { summe, teileGerundet } from '@/lib/finanzen/betrag'
|
||||
import { alsTag, imZeitraum, nachTagSortieren } from '@/lib/finanzen/datum'
|
||||
import {
|
||||
AUSGABE_KATEGORIEN,
|
||||
EINNAHME_KATEGORIEN,
|
||||
KATEGORIE_BESCHRIFTUNG,
|
||||
} from '@/lib/finanzen/kategorien'
|
||||
|
||||
/**
|
||||
* Auswertung des Kassenbuchs - ohne Datenbank, damit sich jede Zahl
|
||||
* einzeln nachrechnen laesst.
|
||||
*
|
||||
* Drei Regeln liegen allem zugrunde:
|
||||
*
|
||||
* 1. Umbuchungen zwischen eigenen Konten sind weder Einnahme noch
|
||||
* Ausgabe. Wer 500 EUR vom Giro aufs Sparbuch legt, hat nichts
|
||||
* eingenommen. Sie tauchen in keiner Summe auf.
|
||||
* 2. Buchungen mit betrifftBetreute = false gehoeren nicht zum Vermoegen
|
||||
* der betreuten Person. Das sind eigene Auslagen des Betreuers - sie
|
||||
* werden getrennt gefuehrt und getrennt abgerechnet.
|
||||
* 3. Vermoegenswirksame Buchungen (Verkaufserloes, Rueckkaufswert) sind
|
||||
* keine laufenden Einnahmen. Sie veraendern aber sehr wohl den
|
||||
* Kontostand und muessen deshalb in der Rechenprobe mitlaufen -
|
||||
* sonst geht die Probe nicht auf. Im Bericht stehen sie eigens
|
||||
* ausgewiesen.
|
||||
*/
|
||||
|
||||
export type BuchungEingabe = {
|
||||
id: string
|
||||
datum: Date
|
||||
betragCent: bigint
|
||||
richtung: BuchungRichtung
|
||||
kategorie: BuchungKategorie
|
||||
gegenstelle: string | null
|
||||
verwendungszweck: string | null
|
||||
kontoId: string | null
|
||||
kontoBezeichnung?: string | null
|
||||
belegId: string | null
|
||||
belegTitel?: string | null
|
||||
belegFehltBegruendung: string | null
|
||||
betrifftBetreute: boolean
|
||||
vermoegenswirksam: boolean
|
||||
/** Laeuft die Buchung ueber ein Konto des Betreuers? */
|
||||
aufBetreuerkonto?: boolean
|
||||
}
|
||||
|
||||
/** Zaehlt nur, was das Vermoegen der betreuten Person beruehrt. */
|
||||
export function istVermoegensbuchung(buchung: BuchungEingabe): boolean {
|
||||
return buchung.betrifftBetreute && buchung.richtung !== 'UMBUCHUNG'
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Belegzwang
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* 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()
|
||||
}
|
||||
|
||||
export function belegBegruendet(buchung: BuchungEingabe): boolean {
|
||||
return !buchung.belegId && (buchung.belegFehltBegruendung ?? '').trim() !== ''
|
||||
}
|
||||
|
||||
export type Belegquote = {
|
||||
gesamt: number
|
||||
mitBeleg: number
|
||||
begruendet: number
|
||||
ohneNachweis: number
|
||||
/** 0 bis 100, ganzzahlig. Bei null Buchungen: 100 - es fehlt ja nichts. */
|
||||
quoteProzent: number
|
||||
}
|
||||
|
||||
export function belegquote(buchungen: BuchungEingabe[]): Belegquote {
|
||||
const gesamt = buchungen.length
|
||||
const mitBeleg = buchungen.filter((b) => Boolean(b.belegId)).length
|
||||
const begruendet = buchungen.filter((b) => belegBegruendet(b)).length
|
||||
const ohneNachweis = buchungen.filter((b) => belegFehlt(b)).length
|
||||
const quoteProzent =
|
||||
gesamt === 0 ? 100 : Math.round(((mitBeleg + begruendet) / gesamt) * 100)
|
||||
return { gesamt, mitBeleg, begruendet, ohneNachweis, quoteProzent }
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Fehler, der in der Rechnungslegung um die Ohren fliegt: eine
|
||||
* Buchung, die auf einem Konto des Betreuers laeuft und trotzdem als
|
||||
* Vermoegen der betreuten Person gefuehrt wird. Das vermischt zwei
|
||||
* Vermoegensmassen - genau das, was § 1835 BGB verhindern soll.
|
||||
*/
|
||||
export function vermischungsWarnung(buchung: {
|
||||
aufBetreuerkonto?: boolean
|
||||
betrifftBetreute: boolean
|
||||
}): string | null {
|
||||
if (buchung.aufBetreuerkonto && buchung.betrifftBetreute) {
|
||||
return (
|
||||
'Diese Buchung läuft über ein Konto, das als Konto des Betreuers gekennzeichnet ist, ' +
|
||||
'gilt aber als Vermögen der betreuten Person. Beides zusammen vermischt zwei ' +
|
||||
'Vermögensmassen. Entweder ist das Konto falsch gekennzeichnet, oder die Buchung ist ' +
|
||||
'eine eigene Auslage – dann bitte „betrifft Vermögen der Betreuten“ abwählen.'
|
||||
)
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Gruppierung nach Kategorien
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export type KategorieGruppe = {
|
||||
kategorie: BuchungKategorie
|
||||
beschriftung: string
|
||||
summeCent: bigint
|
||||
davonVermoegenswirksamCent: bigint
|
||||
anzahl: number
|
||||
buchungen: BuchungEingabe[]
|
||||
}
|
||||
|
||||
function gruppieren(
|
||||
buchungen: BuchungEingabe[],
|
||||
reihenfolge: BuchungKategorie[],
|
||||
): KategorieGruppe[] {
|
||||
const nachKategorie = new Map<BuchungKategorie, BuchungEingabe[]>()
|
||||
for (const buchung of buchungen) {
|
||||
const liste = nachKategorie.get(buchung.kategorie) ?? []
|
||||
liste.push(buchung)
|
||||
nachKategorie.set(buchung.kategorie, liste)
|
||||
}
|
||||
|
||||
// Erst die Kategorien in Berichtsreihenfolge, danach alles, was sonst
|
||||
// noch auftaucht (z.B. eine Rueckerstattung in einer Ausgabekategorie).
|
||||
const bekannt = reihenfolge.filter((k) => nachKategorie.has(k))
|
||||
const uebrig = [...nachKategorie.keys()].filter((k) => !reihenfolge.includes(k))
|
||||
|
||||
return [...bekannt, ...uebrig].map((kategorie) => {
|
||||
const liste = nachTagSortieren(nachKategorie.get(kategorie) ?? [], (b) => b.datum)
|
||||
return {
|
||||
kategorie,
|
||||
beschriftung: KATEGORIE_BESCHRIFTUNG[kategorie],
|
||||
summeCent: summe(liste.map((b) => b.betragCent)),
|
||||
davonVermoegenswirksamCent: summe(
|
||||
liste.filter((b) => b.vermoegenswirksam).map((b) => b.betragCent),
|
||||
),
|
||||
anzahl: liste.length,
|
||||
buchungen: liste,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
export function einnahmenGruppiert(buchungen: BuchungEingabe[]): KategorieGruppe[] {
|
||||
return gruppieren(
|
||||
buchungen.filter((b) => istVermoegensbuchung(b) && b.richtung === 'EINNAHME'),
|
||||
EINNAHME_KATEGORIEN,
|
||||
)
|
||||
}
|
||||
|
||||
export function ausgabenGruppiert(buchungen: BuchungEingabe[]): KategorieGruppe[] {
|
||||
return gruppieren(
|
||||
buchungen.filter((b) => istVermoegensbuchung(b) && b.richtung === 'AUSGABE'),
|
||||
AUSGABE_KATEGORIEN,
|
||||
)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Laufende Einnahmen und Ausgaben (fuer das Vermoegensverzeichnis)
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export type LaufenderPosten = {
|
||||
kategorie: BuchungKategorie
|
||||
beschriftung: string
|
||||
/** Summe im betrachteten Zeitraum. */
|
||||
summeCent: bigint
|
||||
/** Auf den Monat heruntergerechnet, kaufmaennisch auf den Cent gerundet. */
|
||||
monatlichCent: bigint
|
||||
anzahl: number
|
||||
}
|
||||
|
||||
export type LaufendeBewegungen = {
|
||||
von: Date
|
||||
bis: Date
|
||||
monate: number
|
||||
einnahmen: LaufenderPosten[]
|
||||
ausgaben: LaufenderPosten[]
|
||||
summeEinnahmenCent: bigint
|
||||
summeAusgabenCent: bigint
|
||||
monatlichEinnahmenCent: bigint
|
||||
monatlichAusgabenCent: bigint
|
||||
}
|
||||
|
||||
/**
|
||||
* Was laeuft regelmaessig? Das Vermoegensverzeichnis verlangt neben dem
|
||||
* Bestand auch die laufenden Einnahmen und Ausgaben. Grundlage sind die
|
||||
* Buchungen des angegebenen Zeitraums (in der Regel die letzten zwoelf
|
||||
* Monate), heruntergerechnet auf den Monat.
|
||||
*
|
||||
* Vermoegenswirksame Buchungen bleiben hier aussen vor: ein einmaliger
|
||||
* Verkaufserloes ist keine laufende Einnahme und wuerde die Hochrechnung
|
||||
* verfaelschen.
|
||||
*/
|
||||
export function laufendeBewegungen(
|
||||
buchungen: BuchungEingabe[],
|
||||
von: Date,
|
||||
bis: Date,
|
||||
monate = 12,
|
||||
): LaufendeBewegungen {
|
||||
const imFenster = buchungen.filter(
|
||||
(b) => istVermoegensbuchung(b) && !b.vermoegenswirksam && imZeitraum(b.datum, von, bis),
|
||||
)
|
||||
|
||||
const umrechnen = (gruppen: KategorieGruppe[]): LaufenderPosten[] =>
|
||||
gruppen.map((g) => ({
|
||||
kategorie: g.kategorie,
|
||||
beschriftung: g.beschriftung,
|
||||
summeCent: g.summeCent,
|
||||
monatlichCent: teileGerundet(g.summeCent, BigInt(monate)),
|
||||
anzahl: g.anzahl,
|
||||
}))
|
||||
|
||||
const einnahmen = umrechnen(einnahmenGruppiert(imFenster))
|
||||
const ausgaben = umrechnen(ausgabenGruppiert(imFenster))
|
||||
|
||||
const summeEinnahmenCent = summe(einnahmen.map((p) => p.summeCent))
|
||||
const summeAusgabenCent = summe(ausgaben.map((p) => p.summeCent))
|
||||
|
||||
return {
|
||||
von: alsTag(von),
|
||||
bis: alsTag(bis),
|
||||
monate,
|
||||
einnahmen,
|
||||
ausgaben,
|
||||
summeEinnahmenCent,
|
||||
summeAusgabenCent,
|
||||
// Bewusst aus der Gesamtsumme gerechnet und nicht aus den gerundeten
|
||||
// Einzelwerten - sonst weicht die Summe der Zeilen vom Gesamtwert ab.
|
||||
monatlichEinnahmenCent: teileGerundet(summeEinnahmenCent, BigInt(monate)),
|
||||
monatlichAusgabenCent: teileGerundet(summeAusgabenCent, BigInt(monate)),
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Kennzahlen fuer die Uebersichtsseite
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export type Kassenkennzahlen = {
|
||||
anzahl: number
|
||||
einnahmenCent: bigint
|
||||
ausgabenCent: bigint
|
||||
saldoCent: bigint
|
||||
vermoegenswirksamCent: bigint
|
||||
eigeneAuslagenCent: bigint
|
||||
beleg: Belegquote
|
||||
vermischungen: number
|
||||
}
|
||||
|
||||
export function kennzahlen(buchungen: BuchungEingabe[]): Kassenkennzahlen {
|
||||
const relevant = buchungen.filter(istVermoegensbuchung)
|
||||
const einnahmenCent = summe(
|
||||
relevant.filter((b) => b.richtung === 'EINNAHME').map((b) => b.betragCent),
|
||||
)
|
||||
const ausgabenCent = summe(
|
||||
relevant.filter((b) => b.richtung === 'AUSGABE').map((b) => b.betragCent),
|
||||
)
|
||||
|
||||
return {
|
||||
anzahl: buchungen.length,
|
||||
einnahmenCent,
|
||||
ausgabenCent,
|
||||
saldoCent: einnahmenCent - ausgabenCent,
|
||||
vermoegenswirksamCent: summe(
|
||||
relevant.filter((b) => b.vermoegenswirksam).map((b) => b.betragCent),
|
||||
),
|
||||
eigeneAuslagenCent: summe(
|
||||
buchungen.filter((b) => !b.betrifftBetreute).map((b) => b.betragCent),
|
||||
),
|
||||
beleg: belegquote(buchungen),
|
||||
vermischungen: buchungen.filter((b) => vermischungsWarnung(b) !== null).length,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user