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
2026-08-22 02:16:22 +02:00
parent dcd3a8ce71
commit 22b3a9b9e9
134 changed files with 30753 additions and 17 deletions
+336
View File
@@ -0,0 +1,336 @@
import 'server-only'
import { startOfDay } from 'date-fns'
import type { Modul } from '@prisma/client'
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
import {
fristenEinordnen,
heimkostenlageBerechnen,
nachforderungenAuswerten,
tagAusDatenbank,
tageBisTag,
vermoegenBerechnen,
wartendeEinordnen,
type NachforderungRoh,
} from '@/lib/dashboard/bewertung'
import type {
BelegeDaten,
DashboardDaten,
FristenAmpelDaten,
KennzahlenDaten,
NachforderungenDaten,
PosteingangDaten,
WartetAufAndereDaten,
} from '@/lib/dashboard/typen'
/**
* Alles, was das Dashboard "Heute" braucht - in einem Rutsch.
*
* Die Abfragen laufen nebeneinander in einem Promise.all. Keine Schleife
* fragt je Datensatz nach; wo eine Beziehung gebraucht wird (juengster
* Wertstand je Vermoegensposten), holt Prisma sie in derselben Runde mit.
*
* Wer ein Modul nicht lesen darf, bekommt dafuer null zurueck statt
* leerer Listen - die Kachel entfaellt dann ganz, statt faelschlich "0"
* zu behaupten.
*/
/** Wie viele Zeilen zeigt eine Kachel hoechstens? Der Rest steht im Modul. */
const KACHEL_ZEILEN = 5
/** Sicherung gegen ausufernde Abfragen bei sehr langen Akten. */
const FRISTEN_MAX = 200
export type Lesepruefung = (modul: Modul) => boolean
export async function dashboardLaden(
betreute: { id: string; vorname: string; nachname: string },
darfLesen: Lesepruefung,
jetzt: Date = new Date(),
): Promise<DashboardDaten> {
const heute = startOfDay(jetzt)
const betreuteId = betreute.id
const darfFristen = darfLesen('FRISTEN')
const darfVorgaenge = darfLesen('VORGAENGE')
const darfSozialhilfe = darfLesen('SOZIALHILFE')
const darfDokumente = darfLesen('DOKUMENTE')
const darfFinanzen = darfLesen('FINANZEN')
const darfGesundheit = darfLesen('GESUNDHEIT')
const [
fristenRoh,
wartendRoh,
nachforderungenRoh,
posteingang,
posteingangAnzahl,
belegeOhneBuchung,
belegeOhneBuchungGesamt,
buchungenOhneBeleg,
buchungenOhneBelegGesamt,
postenRoh,
heimkostenRoh,
jahresberichtRoh,
] = await Promise.all([
// 1. Fristen - alle offenen, die Einordnung passiert danach im Speicher.
darfFristen
? db.frist.findMany({
where: { betreuteId, status: 'OFFEN', ...nichtGeloescht },
orderBy: { datum: 'asc' },
take: FRISTEN_MAX,
select: {
id: true,
titel: true,
datum: true,
typ: true,
rechtsgrundlage: true,
ausschlussfrist: true,
vorgangId: true,
},
})
: null,
// 2. Vorgaenge, bei denen jemand anderes am Zug ist.
darfVorgaenge
? db.vorgang.findMany({
where: { betreuteId, status: 'WARTET_AUF_DRITTE', ...nichtGeloescht },
orderBy: { letzterKontaktAm: 'asc' },
select: {
id: true,
titel: true,
kategorie: true,
gegenstelle: true,
aktenzeichen: true,
naechsterSchritt: true,
letzterKontaktAm: true,
erstelltAm: true,
},
})
: null,
// 3. Nachforderungen: alle Zeilen, damit "x von y" stimmt.
darfSozialhilfe
? db.nachforderung.findMany({
where: { antrag: { betreuteId, ...nichtGeloescht }, ...nichtGeloescht },
orderBy: [{ reihenfolge: 'asc' }, { erstelltAm: 'asc' }],
select: {
id: true,
bezeichnung: true,
status: true,
fristBis: true,
reihenfolge: true,
antragId: true,
antrag: { select: { traeger: true, aktenzeichen: true } },
},
})
: null,
// 4. Ungeprüfter Posteingang.
darfDokumente
? db.dokument.findMany({
where: { betreuteId, posteingangStatus: 'NEU', ...nichtGeloescht },
orderBy: [{ eingangAm: 'desc' }, { erstelltAm: 'desc' }],
take: KACHEL_ZEILEN,
select: { id: true, titel: true, art: true, absender: true, eingangAm: true },
})
: null,
darfDokumente
? db.dokument.count({
where: { betreuteId, posteingangStatus: 'NEU', ...nichtGeloescht },
})
: null,
// 5a. Rechnungen und Quittungen, an denen keine Buchung haengt.
darfDokumente && darfFinanzen
? db.dokument.findMany({
where: {
betreuteId,
art: { in: ['RECHNUNG', 'QUITTUNG'] },
belegFuer: { none: { geloeschtAm: null } },
...nichtGeloescht,
},
orderBy: [{ eingangAm: 'desc' }, { erstelltAm: 'desc' }],
take: KACHEL_ZEILEN,
select: { id: true, titel: true, art: true, eingangAm: true },
})
: null,
darfDokumente && darfFinanzen
? db.dokument.count({
where: {
betreuteId,
art: { in: ['RECHNUNG', 'QUITTUNG'] },
belegFuer: { none: { geloeschtAm: null } },
...nichtGeloescht,
},
})
: null,
// 5b. Buchungen ohne Beleg und ohne Begruendung - Belegzwang.
darfFinanzen
? db.buchung.findMany({
where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
orderBy: { datum: 'desc' },
take: KACHEL_ZEILEN,
select: {
id: true,
datum: true,
betragCent: true,
richtung: true,
kategorie: true,
gegenstelle: true,
},
})
: null,
darfFinanzen
? db.buchung.count({
where: { betreuteId, belegId: null, belegFehltBegruendung: null, ...nichtGeloescht },
})
: null,
// 6a. Vermoegen: je Posten der juengste Wertstand.
darfFinanzen
? db.vermoegensposten.findMany({
where: { betreuteId, ...nichtGeloescht },
select: {
id: true,
art: true,
wertstaende: {
orderBy: { stichtag: 'desc' },
take: 1,
select: { stichtag: true, wertCent: true },
},
},
})
: null,
// 6b. Der zuletzt erfasste Heimkostenmonat.
darfGesundheit
? db.heimkostenmonat.findFirst({
where: { betreuteId },
orderBy: [{ jahr: 'desc' }, { monat: 'desc' }],
})
: null,
// 6c. Der naechste Jahresbericht.
darfFristen
? db.frist.findFirst({
where: {
betreuteId,
status: 'OFFEN',
systemSchluessel: { startsWith: 'jahresbericht-' },
...nichtGeloescht,
},
orderBy: { datum: 'asc' },
select: { id: true, titel: true, datum: true },
})
: null,
])
// --- Einordnen -----------------------------------------------------------
const fristen: FristenAmpelDaten | null = fristenRoh
? fristenEinordnen(fristenRoh, heute)
: null
const wartet: WartetAufAndereDaten | null = wartendRoh
? (() => {
const alle = wartendeEinordnen(wartendRoh, heute)
return { ...alle, eintraege: alle.eintraege.slice(0, KACHEL_ZEILEN) }
})()
: null
const nachforderungen: NachforderungenDaten | null = nachforderungenRoh
? nachforderungenAuswerten(
nachforderungenRoh.map<NachforderungRoh>((zeile) => ({
id: zeile.id,
bezeichnung: zeile.bezeichnung,
status: zeile.status,
fristBis: zeile.fristBis,
reihenfolge: zeile.reihenfolge,
antragId: zeile.antragId,
antragTraeger: zeile.antrag.traeger,
antragAktenzeichen: zeile.antrag.aktenzeichen,
})),
heute,
)
: null
const posteingangDaten: PosteingangDaten | null =
posteingang && posteingangAnzahl !== null
? {
anzahl: posteingangAnzahl,
neueste: posteingang.map((d) => ({
id: d.id,
titel: d.titel,
art: d.art,
absender: d.absender,
eingangAm: d.eingangAm ? tagAusDatenbank(d.eingangAm) : null,
})),
}
: null
const belege: BelegeDaten | null =
buchungenOhneBeleg && buchungenOhneBelegGesamt !== null
? {
belegeOhneBuchung: (belegeOhneBuchung ?? []).map((d) => ({
id: d.id,
titel: d.titel,
art: d.art,
eingangAm: d.eingangAm ? tagAusDatenbank(d.eingangAm) : null,
})),
belegeOhneBuchungGesamt: belegeOhneBuchungGesamt ?? 0,
buchungenOhneBeleg: buchungenOhneBeleg.map((b) => ({
id: b.id,
datum: tagAusDatenbank(b.datum),
betragCent: centZuZahl(b.betragCent) ?? 0,
richtung: b.richtung,
kategorie: b.kategorie,
gegenstelle: b.gegenstelle,
})),
buchungenOhneBelegGesamt,
}
: null
const vermoegenRoh = postenRoh ? vermoegenBerechnen(postenRoh) : null
const heimkosten = heimkostenRoh ? heimkostenlageBerechnen(heimkostenRoh) : null
const kennzahlen: KennzahlenDaten = {
vermoegen: vermoegenRoh
? {
stichtag: vermoegenRoh.stichtag,
aktivaCent: centZuZahl(vermoegenRoh.aktivaCent) ?? 0,
verbindlichkeitenCent: centZuZahl(vermoegenRoh.verbindlichkeitenCent) ?? 0,
nettoCent: centZuZahl(vermoegenRoh.nettoCent) ?? 0,
postenGesamt: vermoegenRoh.postenGesamt,
postenOhneWert: vermoegenRoh.postenOhneWert,
}
: null,
heimkosten: heimkosten
? {
jahr: heimkosten.jahr,
monat: heimkosten.monat,
gesamtkostenCent: centZuZahl(heimkosten.gesamtkostenCent) ?? 0,
deckungCent: centZuZahl(heimkosten.deckungCent) ?? 0,
deckungsluecke: centZuZahl(heimkosten.deckungsluecke) ?? 0,
}
: null,
jahresbericht: jahresberichtRoh
? {
id: jahresberichtRoh.id,
titel: jahresberichtRoh.titel,
datum: tagAusDatenbank(jahresberichtRoh.datum),
tage: tageBisTag(tagAusDatenbank(jahresberichtRoh.datum), heute),
}
: null,
}
return {
betreuteId,
name: `${betreute.vorname} ${betreute.nachname}`.trim(),
heute,
fristen,
wartet,
nachforderungen,
posteingang: posteingangDaten,
belege,
kennzahlen,
}
}