docs: README, Datenschutztexte, Dockerfile und Sicherungsskripte

Damit ist Etappe 1 abgeschlossen und betriebsfertig dokumentiert.

README mit beiden Betriebswegen. Docker Compose auf eigenem Server ist
der Hauptweg; Vercel und Neon sind vollstaendig beschrieben, aber mit
einer klaren Begruendung, warum ich davon abrate: beide Anbieter sind
US-Unternehmen und unterliegen auch bei EU-Region potenziell dem
CLOUD-Act. Bei Gesundheitsdaten einer nicht entscheidungsfaehigen Person
ist das eine Abwaegung, die man bewusst treffen muss.

Reverse-Proxy-Beispiele fuer Caddy, nginx und Traefik - der Proxy selbst
ist nicht Teil des Compose-Setups, weil er auf dem Zielserver schon
steht. Die Datenbank hat keine Portfreigabe.

Sicherung: pg_dump schreibt direkt in die Verschluesselung, der Klartext
landet nie auf der Platte. Danach eine Selbstpruefung - laesst sich die
Datei nicht wieder entschluesseln, endet der Lauf mit Fehler statt mit
einem stillen Scheinerfolg. Der jeweils erste Stand eines Monats bleibt
dauerhaft stehen.

Die README sagt ausdruecklich, was das Backup NICHT enthaelt: den
Schluessel ENC_KEY_V1 und die Dateien im Objektspeicher. Dazu eine
Anleitung, die Wiederherstellung einmal im Jahr zu ueben - mit dem
letzten Schritt, in der Anwendung nachzusehen, ob die Diagnosen im
Klartext erscheinen. Erst dann stimmt nicht nur die Datenbank, sondern
auch der Schluessel.

Verarbeitungsverzeichnis und Datenschutzhinweise als ausfuellbare
Textbausteine. Die Hinweise sind in einfacher Sprache geschrieben - sie
sollen der betreuten Person vorgelesen werden koennen. Die Seite
/datenschutz liest denselben Text aus docs/, damit es nicht zwei
Fassungen gibt, die auseinanderlaufen.

Dockerfile in drei Stufen mit Tesseract, deutschen Sprachdaten und
poppler-utils. Zeitzone Europe/Berlin ist gesetzt - ohne sie rechnet der
Server in UTC und verschiebt Fristen um einen Tag.

Etappe: 1
Phase: Fundament
This commit is contained in:
Florian Wilde
2026-08-22 02:35:08 +02:00
parent 6b4df4c9cb
commit 3833a9dd8f
141 changed files with 30302 additions and 66 deletions
@@ -0,0 +1,103 @@
import Link from 'next/link'
import { notFound } from 'next/navigation'
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
import { AlertCircle } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { SeitenKopf } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { Buchungsformular } from '@/components/finanzen/buchungs-formular'
import { db, nichtGeloescht } from '@/lib/db'
import { finanzKontext } from '@/lib/finanzen/seite'
import { heute, tagAlsText } from '@/lib/finanzen/datum'
export const metadata = { title: 'Buchung erfassen' }
/**
* Buchung erfassen.
*
* Mit ?schnell=1 bleibt das Formular nach dem Speichern offen – für den
* Abend, an dem ein ganzer Kontoauszug nachgetragen wird.
*/
export default async function BuchungNeuSeite({
searchParams,
}: {
searchParams: Promise<Record<string, string | string[] | undefined>>
}) {
const parameter = await searchParams
const { betreute, darfSchreiben } = await finanzKontext()
if (!darfSchreiben('FINANZEN')) notFound()
const schnell = parameter.schnell === '1'
const kontoId = typeof parameter.kontoId === 'string' ? parameter.kontoId : null
const [konten, belege] = await Promise.all([
db.konto.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
select: { id: true, bezeichnung: true, istBetreuerkonto: true },
orderBy: [{ istBetreuerkonto: 'asc' }, { bezeichnung: 'asc' }],
}),
db.dokument.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
select: { id: true, titel: true },
orderBy: { erstelltAm: 'desc' },
take: 200,
}),
])
return (
<div className="max-w-3xl space-y-6">
<SeitenKopf
titel={schnell ? 'Schnellerfassung' : 'Buchung erfassen'}
beschreibung={
schnell
? 'Das Formular bleibt nach dem Speichern offen. Datum und Konto musst du je Buchung neu wählen – dafür wanderst du zügig durch den Kontoauszug.'
: 'Beträge immer positiv eintragen; ob Geld kommt oder geht, sagt die Richtung.'
}
pfad={[
{ titel: 'Vermögen & Kasse', href: '/finanzen' },
{ titel: 'Kassenbuch', href: '/finanzen/buchungen' },
{ titel: schnell ? 'Schnellerfassung' : 'Neu' },
]}
aktionen={
<Button asChild variant="ghost">
<Link href={schnell ? '/finanzen/buchungen/neu' : '/finanzen/buchungen/neu?schnell=1'}>
{schnell ? 'Zur normalen Erfassung' : 'Zur Schnellerfassung'}
</Link>
</Button>
}
/>
{konten.length === 0 && (
<Alert variant="warnung">
<AlertCircle aria-hidden="true" />
<AlertTitle>Es gibt noch kein Konto</AlertTitle>
<AlertDescription>
Du kannst eine Buchung auch ohne Konto erfassen, aber dann lässt sie sich später
keinem Kontostand zuordnen – und die Rechenprobe der Rechnungslegung geht nicht auf.{' '}
<Link href="/finanzen/konten/neu" className="underline">
Erst ein Konto anlegen
</Link>
.
</AlertDescription>
</Alert>
)}
<Buchungsformular
betreuteId={betreute.id}
konten={
kontoId
? [
...konten.filter((k) => k.id === kontoId),
...konten.filter((k) => k.id !== kontoId),
]
: konten
}
belege={belege}
schnellerfassung={schnell}
standardDatum={tagAlsText(heute())}
/>
<Rechtshinweis rechtsgrundlage="§ 1865 BGB" />
</div>
)
}
+286
View File
@@ -0,0 +1,286 @@
import Link from 'next/link'
import { Banknote, Plus, Upload } from 'lucide-react'
import type { Prisma } from '@prisma/client'
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
import { SeitenKopf, Leerzustand } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { Belegzeichen, Betrag, Kennzahl, Vermischungswarnung } from '@/components/finanzen/bausteine'
import { Buchungsfilter } from '@/components/finanzen/buchungs-filter'
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
import { oeffnen } from '@/lib/crypto/feld'
import { formatCent, formatDatum } from '@/lib/utils'
import { finanzKontext } from '@/lib/finanzen/seite'
import { belegFehlt, kennzahlen, vermischungsWarnung, type BuchungEingabe } from '@/lib/finanzen/kassenbuch'
import { KATEGORIE_BESCHRIFTUNG, RICHTUNG_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
import { buchungsfilterSchema } from '@/lib/validierung/finanzen'
export const metadata = { title: 'Kassenbuch' }
const HOECHSTZAHL = 300
/**
* Das Kassenbuch.
*
* Zwei Dinge sind hier absichtlich auffällig: Buchungen ohne Beleg und
* ohne Begründung werden rot markiert, und eine Buchung, die auf einem
* Konto des Betreuers läuft und trotzdem als Vermögen der Betreuten
* gilt, bekommt eine eigene Warnung. Beides sind die Punkte, an denen
* eine Rechnungslegung beim Gericht auseinanderfällt.
*/
export default async function BuchungenSeite({
searchParams,
}: {
searchParams: Promise<Record<string, string | string[] | undefined>>
}) {
const roh = await searchParams
const { betreute, darfSchreiben } = await finanzKontext()
const schreiben = darfSchreiben('FINANZEN')
const flach: Record<string, string> = {}
for (const [schluessel, wert] of Object.entries(roh)) {
if (typeof wert === 'string') flach[schluessel] = wert
}
const gepruft = buchungsfilterSchema.safeParse(flach)
const filter = gepruft.success
? gepruft.data
: {
kontoId: null,
kategorie: null,
richtung: null,
von: null,
bis: null,
suche: null,
nurOhneBeleg: false,
nurEigeneAuslagen: false,
}
const bedingung: Prisma.BuchungWhereInput = {
betreuteId: betreute.id,
...nichtGeloescht,
...(filter.kontoId ? { kontoId: filter.kontoId } : {}),
...(filter.kategorie ? { kategorie: filter.kategorie } : {}),
...(filter.richtung ? { richtung: filter.richtung } : {}),
...(filter.von || filter.bis
? {
datum: {
...(filter.von ? { gte: filter.von } : {}),
...(filter.bis ? { lte: filter.bis } : {}),
},
}
: {}),
// Der Verwendungszweck ist verschluesselt und laesst sich nicht
// durchsuchen - gesucht wird deshalb nur in der Gegenstelle.
...(filter.suche ? { gegenstelle: { contains: filter.suche, mode: 'insensitive' } } : {}),
...(filter.nurEigeneAuslagen ? { betrifftBetreute: false } : {}),
...(filter.nurOhneBeleg
? { belegId: null, OR: [{ belegFehltBegruendung: null }, { belegFehltBegruendung: '' }] }
: {}),
}
const [zeilen, gesamt, konten] = await Promise.all([
db.buchung.findMany({
where: bedingung,
include: {
konto: { select: { id: true, bezeichnung: true, istBetreuerkonto: true } },
beleg: { select: { id: true, titel: true } },
},
orderBy: [{ datum: 'desc' }, { erstelltAm: 'desc' }],
take: HOECHSTZAHL,
}),
db.buchung.count({ where: bedingung }),
db.konto.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
select: { id: true, bezeichnung: true },
orderBy: { bezeichnung: 'asc' },
}),
])
const buchungen: BuchungEingabe[] = 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,
}
})
const zahlen = kennzahlen(buchungen)
return (
<div className="space-y-6">
<SeitenKopf
titel="Kassenbuch"
beschreibung="Jede Einnahme und jede Ausgabe. Aus diesen Zeilen entsteht die Rechnungslegung – deshalb gehört zu jeder Zeile ein Beleg oder eine Begründung, warum keiner da ist."
pfad={[{ titel: 'Vermögen & Kasse', href: '/finanzen' }, { titel: 'Kassenbuch' }]}
aktionen={
schreiben ? (
<>
<Button asChild variant="secondary">
<Link href="/finanzen/buchungen/import">
<Upload aria-hidden="true" />
Importieren
</Link>
</Button>
<Button asChild>
<Link href="/finanzen/buchungen/neu">
<Plus aria-hidden="true" />
Buchung erfassen
</Link>
</Button>
</>
) : undefined
}
/>
<Buchungsfilter
konten={konten}
aktiv={{
kontoId: filter.kontoId ?? '',
kategorie: filter.kategorie ?? '',
richtung: filter.richtung ?? '',
von: filter.von ? filter.von.toISOString().slice(0, 10) : '',
bis: filter.bis ? filter.bis.toISOString().slice(0, 10) : '',
suche: filter.suche ?? '',
nurOhneBeleg: filter.nurOhneBeleg,
nurEigeneAuslagen: filter.nurEigeneAuslagen,
}}
/>
<div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
<Kennzahl titel="Buchungen in der Auswahl" wert={gesamt} />
<Kennzahl
titel="Einnahmen"
wert={formatCent(centZuZahl(zahlen.einnahmenCent))}
hinweis="ohne Umbuchungen und eigene Auslagen"
/>
<Kennzahl
titel="Ausgaben"
wert={formatCent(centZuZahl(zahlen.ausgabenCent))}
hinweis="ohne Umbuchungen und eigene Auslagen"
/>
<Kennzahl
titel="Ohne Beleg und ohne Begründung"
wert={zahlen.beleg.ohneNachweis}
hinweis={
zahlen.beleg.ohneNachweis > 0
? 'Genau danach fragt der Rechtspfleger.'
: 'Da fehlt nichts.'
}
ton={zahlen.beleg.ohneNachweis > 0 ? 'achtung' : 'gut'}
/>
</div>
{zahlen.vermischungen > 0 && <Vermischungswarnung />}
{buchungen.length === 0 ? (
<Leerzustand
icon={Banknote}
titel={gesamt === 0 ? 'Noch keine Buchung erfasst' : 'Keine Buchung passt zu diesem Filter'}
beschreibung={
gesamt === 0
? 'Erfasse die erste Buchung von Hand oder lies einen Kontoauszug als CSV ein.'
: 'Setz den Filter zurück oder wähl einen anderen Zeitraum.'
}
aktion={
schreiben && gesamt === 0 ? (
<Button asChild>
<Link href="/finanzen/buchungen/neu">
<Plus aria-hidden="true" />
Buchung erfassen
</Link>
</Button>
) : undefined
}
/>
) : (
<>
<Table>
<TableHeader>
<TableRow>
<TableHead>Datum</TableHead>
<TableHead>Vorgang</TableHead>
<TableHead>Konto</TableHead>
<TableHead>Beleg</TableHead>
<TableHead className="text-right">Betrag</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{buchungen.map((buchung) => (
<TableRow
key={buchung.id}
className={belegFehlt(buchung) ? 'bg-ampel-rot/5' : undefined}
>
<TableCell className="whitespace-nowrap align-top">
{formatDatum(buchung.datum)}
</TableCell>
<TableCell className="align-top">
<Link
href={`/finanzen/buchungen/${buchung.id}`}
className="font-medium hover:underline"
>
{buchung.gegenstelle ?? KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
</Link>
<span className="block text-sm text-muted-foreground">
{RICHTUNG_BESCHRIFTUNG[buchung.richtung]} ·{' '}
{KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
</span>
{buchung.verwendungszweck && (
<span className="block text-sm text-muted-foreground">
{buchung.verwendungszweck}
</span>
)}
<span className="mt-1 flex flex-wrap gap-1.5">
{!buchung.betrifftBetreute && (
<Badge variant="secondary">eigene Auslage</Badge>
)}
{buchung.vermoegenswirksam && (
<Badge variant="outline">vermögenswirksam</Badge>
)}
{vermischungsWarnung(buchung) && <Vermischungswarnung kurz />}
</span>
</TableCell>
<TableCell className="align-top text-sm text-muted-foreground">
{buchung.kontoBezeichnung ?? 'kein Konto'}
</TableCell>
<TableCell className="align-top">
<Belegzeichen
belegId={buchung.belegId}
belegTitel={buchung.belegTitel ?? null}
begruendung={buchung.belegFehltBegruendung}
/>
</TableCell>
<TableCell className="text-right align-top">
<Betrag cent={centZuZahl(buchung.betragCent)} richtung={buchung.richtung} />
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
{gesamt > buchungen.length && (
<p className="text-sm text-muted-foreground">
Es werden die {HOECHSTZAHL} jüngsten von {gesamt} Buchungen gezeigt. Grenze den
Zeitraum ein, um die älteren zu sehen.
</p>
)}
</>
)}
<Rechtshinweis rechtsgrundlage="§ 1865 BGB" />
</div>
)
}
+245
View File
@@ -0,0 +1,245 @@
import Link from 'next/link'
import { notFound } from 'next/navigation'
import { ArrowRight } from 'lucide-react'
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 { SeitenKopf } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { Betrag } from '@/components/finanzen/bausteine'
import { Kontoformular } from '@/components/finanzen/konto-formular'
import { Saldoformular } from '@/components/finanzen/saldo-formular'
import { Loeschknopf } from '@/components/finanzen/aktionen'
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
import { oeffnen } from '@/lib/crypto/feld'
import { formatDatum } from '@/lib/utils'
import { finanzKontext } from '@/lib/finanzen/seite'
import { heute, tagAlsText } from '@/lib/finanzen/datum'
import { ibanFormatieren } from '@/lib/finanzen/iban'
import { KONTO_ART_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
import { kontoLoeschen, saldostandLoeschen } from '@/server/actions/finanzen'
export const metadata = { title: 'Konto' }
/**
* Ein einzelnes Konto: Stammdaten, Historie der Kontostände und die
* letzten Buchungen. Kontostände werden hier angelegt und nie
* überschrieben – jede alte Aufstellung bleibt reproduzierbar.
*/
export default async function KontoSeite({ params }: { params: Promise<{ id: string }> }) {
const { id } = await params
const { betreute, darfSchreiben } = await finanzKontext()
const schreiben = darfSchreiben('FINANZEN')
const konto = await db.konto.findFirst({
where: { id, betreuteId: betreute.id, ...nichtGeloescht },
include: {
saldostaende: { orderBy: { stichtag: 'desc' } },
_count: { select: { buchungen: true } },
},
})
if (!konto) notFound()
const offen = oeffnen('Konto', konto)
const buchungen = await db.buchung.findMany({
where: { kontoId: konto.id, ...nichtGeloescht },
orderBy: { datum: 'desc' },
take: 10,
select: {
id: true,
datum: true,
betragCent: true,
richtung: true,
kategorie: true,
gegenstelle: true,
},
})
return (
<div className="space-y-8">
<SeitenKopf
titel={konto.bezeichnung}
beschreibung={
<span className="space-y-1">
<span className="block">
{KONTO_ART_BESCHRIFTUNG[konto.art]}
{konto.bank ? ` · ${konto.bank}` : ''}
</span>
{offen.iban && (
<span className="block font-mono text-sm">{ibanFormatieren(offen.iban)}</span>
)}
</span>
}
pfad={[
{ titel: 'Vermögen & Kasse', href: '/finanzen' },
{ titel: 'Konten', href: '/finanzen/konten' },
{ titel: konto.bezeichnung },
]}
aktionen={
<Button asChild variant="ghost">
<Link href={`/finanzen/buchungen?kontoId=${konto.id}`}>
Buchungen dieses Kontos
<ArrowRight aria-hidden="true" />
</Link>
</Button>
}
/>
{konto.istBetreuerkonto && (
<Badge variant="orange">
Konto des Betreuers – gehört nicht zum Vermögen der betreuten Person
</Badge>
)}
{/* ------------------------------------------------------------- */}
<Card>
<CardHeader>
<CardTitle>Kontostände</CardTitle>
<CardDescription>
Ein Stand gilt als Bestand am Ende seines Stichtags. Stände werden nie überschrieben –
so lässt sich eine abgegebene Vermögensübersicht Jahre später exakt nachbilden.
</CardDescription>
</CardHeader>
<CardContent className="space-y-6">
{konto.saldostaende.length === 0 ? (
<p className="rounded-md border border-dashed p-4 text-sm text-muted-foreground">
Noch kein Kontostand erfasst. Ohne Stand bleibt dieses Konto in der Rechnungslegung
mit 0,00 € stehen – und die Rechenprobe geht nicht auf.
</p>
) : (
<Table>
<TableHeader>
<TableRow>
<TableHead>Stichtag</TableHead>
<TableHead>Stand</TableHead>
<TableHead>Quelle</TableHead>
{schreiben && <TableHead className="text-right">Aktion</TableHead>}
</TableRow>
</TableHeader>
<TableBody>
{konto.saldostaende.map((stand) => (
<TableRow key={stand.id}>
<TableCell className="whitespace-nowrap">
{formatDatum(stand.stichtag)}
</TableCell>
<TableCell>
<Betrag cent={centZuZahl(stand.betragCent)} fett />
</TableCell>
<TableCell className="text-sm text-muted-foreground">
{stand.quelle ?? 'keine Quelle angegeben'}
</TableCell>
{schreiben && (
<TableCell className="text-right">
<Loeschknopf
aktion={saldostandLoeschen}
felder={{ betreuteId: betreute.id, saldostandId: stand.id }}
frage={`Kontostand vom ${formatDatum(stand.stichtag)} endgültig entfernen? Er wird nicht in den Papierkorb gelegt.`}
/>
</TableCell>
)}
</TableRow>
))}
</TableBody>
</Table>
)}
{schreiben && (
<div className="border-t pt-6">
<h3 className="mb-3 text-base font-semibold">Neuen Kontostand festhalten</h3>
<Saldoformular
betreuteId={betreute.id}
konten={[{ id: konto.id, bezeichnung: konto.bezeichnung }]}
kontoId={konto.id}
standardStichtag={tagAlsText(heute())}
/>
</div>
)}
</CardContent>
</Card>
{/* ------------------------------------------------------------- */}
<Card>
<CardHeader>
<CardTitle>Letzte Buchungen</CardTitle>
<CardDescription>
{konto._count.buchungen} Buchung(en) insgesamt auf diesem Konto.
</CardDescription>
</CardHeader>
<CardContent>
{buchungen.length === 0 ? (
<p className="text-sm text-muted-foreground">Noch keine Buchungen auf diesem Konto.</p>
) : (
<Table>
<TableHeader>
<TableRow>
<TableHead>Datum</TableHead>
<TableHead>Gegenstelle</TableHead>
<TableHead className="text-right">Betrag</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{buchungen.map((buchung) => (
<TableRow key={buchung.id}>
<TableCell className="whitespace-nowrap">
{formatDatum(buchung.datum)}
</TableCell>
<TableCell>
<Link
href={`/finanzen/buchungen/${buchung.id}`}
className="hover:underline"
>
{buchung.gegenstelle ?? 'ohne Gegenstelle'}
</Link>
</TableCell>
<TableCell className="text-right">
<Betrag cent={centZuZahl(buchung.betragCent)} richtung={buchung.richtung} />
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
)}
</CardContent>
</Card>
{/* ------------------------------------------------------------- */}
{schreiben && (
<Card>
<CardHeader>
<CardTitle>Stammdaten ändern</CardTitle>
</CardHeader>
<CardContent className="space-y-8">
<Kontoformular
betreuteId={betreute.id}
konto={{
id: konto.id,
bezeichnung: konto.bezeichnung,
bank: konto.bank,
art: konto.art,
iban: offen.iban,
bic: konto.bic,
istBetreuerkonto: konto.istBetreuerkonto,
eroeffnetAm: tagAlsText(konto.eroeffnetAm) || null,
geschlossenAm: tagAlsText(konto.geschlossenAm) || null,
}}
/>
<div className="border-t pt-6">
<Loeschknopf
aktion={kontoLoeschen}
felder={{ betreuteId: betreute.id, kontoId: konto.id }}
beschriftung="Konto in den Papierkorb"
variante="outline"
frage="Konto in den Papierkorb legen? Es bleibt 30 Tage wiederherstellbar. Konten mit Buchungen werden nicht gelöscht – trage stattdessen ein Schließungsdatum ein."
/>
</div>
</CardContent>
</Card>
)}
<Rechtshinweis rechtsgrundlage="§ 1835 BGB" />
</div>
)
}
@@ -0,0 +1,30 @@
import { notFound } from 'next/navigation'
import { SeitenKopf } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { Kontoformular } from '@/components/finanzen/konto-formular'
import { finanzKontext } from '@/lib/finanzen/seite'
export const metadata = { title: 'Konto anlegen' }
export default async function KontoNeuSeite() {
const { betreute, darfSchreiben } = await finanzKontext()
if (!darfSchreiben('FINANZEN')) notFound()
return (
<div className="max-w-3xl space-y-6">
<SeitenKopf
titel="Konto anlegen"
beschreibung="Die IBAN wird verschlüsselt gespeichert. Zusätzlich wird ein Blindindex abgelegt – damit erkennt die Anwendung ein doppelt angelegtes Konto, ohne die IBAN im Klartext vorzuhalten."
pfad={[
{ titel: 'Vermögen & Kasse', href: '/finanzen' },
{ titel: 'Konten', href: '/finanzen/konten' },
{ titel: 'Neu' },
]}
/>
<Kontoformular betreuteId={betreute.id} />
<Rechtshinweis rechtsgrundlage="§ 1835 BGB" />
</div>
)
}
+123
View File
@@ -0,0 +1,123 @@
import Link from 'next/link'
import { Landmark, Plus } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { Badge } from '@/components/ui/badge'
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
import { SeitenKopf, Leerzustand } from '@/components/seiten-kopf'
import { Betrag } from '@/components/finanzen/bausteine'
import { centZuZahl } from '@/lib/db'
import { formatCent, formatDatum } from '@/lib/utils'
import { finanzKontext } from '@/lib/finanzen/seite'
import { heute } from '@/lib/finanzen/datum'
import { kontenLaden, kontostaendeZumStichtag } from '@/lib/berichte/gemeinsam'
export const metadata = { title: 'Konten' }
export default async function KontenSeite() {
const { betreute, darfSchreiben } = await finanzKontext()
const schreiben = darfSchreiben('FINANZEN')
const stichtag = heute()
const konten = await kontenLaden(betreute.id)
const staende = kontostaendeZumStichtag(konten, stichtag)
const summeCent = staende
.filter((s) => !s.istBetreuerkonto)
.reduce((s, z) => s + (z.betragCent ?? 0n), 0n)
return (
<div className="space-y-6">
<SeitenKopf
titel="Konten"
beschreibung="Alle Konten und Kassen, über die Geld der betreuten Person läuft – einschließlich Verwahrgeld im Heim und Barkasse."
pfad={[{ titel: 'Vermögen & Kasse', href: '/finanzen' }, { titel: 'Konten' }]}
aktionen={
schreiben ? (
<Button asChild>
<Link href="/finanzen/konten/neu">
<Plus aria-hidden="true" />
Konto anlegen
</Link>
</Button>
) : undefined
}
/>
{konten.length === 0 ? (
<Leerzustand
icon={Landmark}
titel="Noch kein Konto erfasst"
beschreibung="Ohne Konten gibt es keine Bestände – und ohne Bestände keine Rechnungslegung. Fang mit dem Girokonto an."
aktion={
schreiben ? (
<Button asChild>
<Link href="/finanzen/konten/neu">
<Plus aria-hidden="true" />
Konto anlegen
</Link>
</Button>
) : undefined
}
/>
) : (
<>
<Table>
<TableHeader>
<TableRow>
<TableHead>Konto</TableHead>
<TableHead>Art</TableHead>
<TableHead>Bank</TableHead>
<TableHead>Stand vom</TableHead>
<TableHead className="text-right">Betrag</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{staende.map((stand) => (
<TableRow key={stand.kontoId}>
<TableCell>
<Link
href={`/finanzen/konten/${stand.kontoId}`}
className="font-medium hover:underline"
>
{stand.bezeichnung}
</Link>
{stand.ibanMaskiert && (
<span className="block text-sm text-muted-foreground">
{stand.ibanMaskiert}
</span>
)}
{stand.istBetreuerkonto && (
<Badge variant="orange" className="mt-1">
Konto des Betreuers
</Badge>
)}
</TableCell>
<TableCell className="text-sm text-muted-foreground">
{stand.artBeschriftung}
</TableCell>
<TableCell className="text-sm text-muted-foreground">
{stand.bank ?? '–'}
</TableCell>
<TableCell className="whitespace-nowrap text-sm text-muted-foreground">
{stand.stichtag ? formatDatum(stand.stichtag) : 'nie erfasst'}
</TableCell>
<TableCell className="text-right">
<Betrag cent={centZuZahl(stand.betragCent)} />
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
<p className="flex items-baseline justify-between gap-4 border-t pt-3 font-semibold">
<span>Summe der Konten der betreuten Person</span>
<span className="tabular-nums">{formatCent(centZuZahl(summeCent))}</span>
</p>
<p className="text-sm text-muted-foreground">
Konten des Betreuers sind in dieser Summe nicht enthalten – sie gehören nicht zum
Vermögen der betreuten Person.
</p>
</>
)}
</div>
)
}
+318
View File
@@ -0,0 +1,318 @@
import Link from 'next/link'
import { ArrowRight, Banknote, FileDown, Landmark, Plus, Upload } from 'lucide-react'
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 { SeitenKopf, Leerzustand } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import {
Belegzeichen,
Betrag,
Hinweisliste,
Kennzahl,
Vermischungswarnung,
} from '@/components/finanzen/bausteine'
import { centZuZahl } from '@/lib/db'
import { formatCent, formatDatum } from '@/lib/utils'
import { finanzKontext } from '@/lib/finanzen/seite'
import { heute, monatePlus, tagePlus } from '@/lib/finanzen/datum'
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'
export const metadata = { title: 'Vermögen & Kasse' }
/**
* Übersichtsseite des Finanzmoduls.
*
* Sie beantwortet die vier Fragen, die man sich beim Öffnen stellt:
* Was ist da? Wo liegt es? Was ist zuletzt passiert? Und: Wo fehlt noch
* ein Beleg?
*/
export default async function FinanzenSeite() {
const { betreute, darfSchreiben } = await finanzKontext()
const schreiben = darfSchreiben('FINANZEN')
const stichtag = heute()
const [konten, buchungen, vermoegen] = await Promise.all([
kontenLaden(betreute.id),
buchungenLaden(betreute.id),
vermoegenLaden(betreute.id, stichtag),
])
const eigeneKonten = konten.filter((k) => !k.istBetreuerkonto)
const staende = kontostaendeZumStichtag(eigeneKonten, stichtag)
const summeKontenCent = staende.reduce((s, z) => s + (z.betragCent ?? 0n), 0n)
const zwoelfMonate = tagePlus(monatePlus(stichtag, -12), 1)
const letzteZwoelf = buchungen.filter((b) => b.datum >= zwoelfMonate)
const zahlen = kennzahlen(letzteZwoelf)
const letzte = [...buchungen].sort((a, b) => b.datum.getTime() - a.datum.getTime()).slice(0, 8)
const jahr = betreute.bestellungAm ? laufendesBetreuungsjahr(betreute.bestellungAm) : null
const hinweise: string[] = []
for (const stand of staende) {
if (stand.betragCent === null) {
hinweise.push(`Für „${stand.bezeichnung}“ ist noch kein Kontostand erfasst.`)
} else if (stand.stichtag && stand.stichtag < monatePlus(stichtag, -3)) {
hinweise.push(
`Der Stand von „${stand.bezeichnung}“ ist vom ${formatDatum(stand.stichtag)} und damit ` +
'älter als drei Monate.',
)
}
}
if (!betreute.bestellungAm) {
hinweise.push(
'In den Stammdaten fehlt das Datum der Bestellung. Ohne dieses Datum lässt sich das ' +
'Betreuungsjahr nicht bestimmen – und damit auch keine Rechnungslegung erzeugen.',
)
}
return (
<div className="space-y-8">
<SeitenKopf
titel="Vermögen & Kasse"
beschreibung={
jahr
? `Aktuell läuft das ${jahr.bezeichnung}. Alles hier fließt in das Vermögensverzeichnis und die Rechnungslegung.`
: 'Konten, Kassenbuch und Vermögensposten. Von hier aus entstehen beide Berichte ans Betreuungsgericht.'
}
pfad={[{ titel: 'Vermögen & Kasse' }]}
aktionen={
schreiben ? (
<>
<Button asChild variant="secondary">
<Link href="/finanzen/buchungen/neu">
<Plus aria-hidden="true" />
Buchung erfassen
</Link>
</Button>
<Button asChild>
<Link href="/finanzen/berichte">
<FileDown aria-hidden="true" />
Berichte
</Link>
</Button>
</>
) : undefined
}
/>
<div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
<Kennzahl
titel="Guthaben auf Konten"
wert={formatCent(centZuZahl(summeKontenCent))}
hinweis={`${staende.length} Konto/Konten der betreuten Person`}
href="/finanzen/konten"
/>
<Kennzahl
titel="Reinvermögen"
wert={formatCent(centZuZahl(summeKontenCent + vermoegen.summeAktivaCent - vermoegen.summePassivaCent))}
hinweis="Konten und Vermögensposten, abzüglich Verbindlichkeiten"
href="/finanzen/vermoegen"
/>
<Kennzahl
titel="Belegquote (12 Monate)"
wert={`${zahlen.beleg.quoteProzent} %`}
hinweis={
zahlen.beleg.ohneNachweis > 0
? `${zahlen.beleg.ohneNachweis} Buchung(en) ohne Beleg und ohne Begründung`
: 'Alle Buchungen sind belegt oder begründet'
}
ton={zahlen.beleg.ohneNachweis > 0 ? 'achtung' : 'gut'}
href="/finanzen/buchungen?nurOhneBeleg=on"
/>
<Kennzahl
titel="Saldo der letzten 12 Monate"
wert={formatCent(centZuZahl(zahlen.saldoCent))}
hinweis={`${formatCent(centZuZahl(zahlen.einnahmenCent))} ein, ${formatCent(centZuZahl(zahlen.ausgabenCent))} aus`}
ton={zahlen.saldoCent < 0n ? 'achtung' : 'neutral'}
href="/finanzen/buchungen"
/>
</div>
{zahlen.vermischungen > 0 && <Vermischungswarnung />}
<Hinweisliste hinweise={hinweise} titel="Das solltest du nachtragen" />
{/* ------------------------------------------------------------- */}
<Card>
<CardHeader>
<CardTitle>Konten</CardTitle>
<CardDescription>
Stand zum {formatDatum(stichtag)} – jeweils der jüngste erfasste Saldostand.
</CardDescription>
</CardHeader>
<CardContent>
{konten.length === 0 ? (
<Leerzustand
icon={Landmark}
titel="Noch kein Konto erfasst"
beschreibung="Fang mit dem Girokonto an, über das Rente und Heimkosten laufen. Das Verwahrgeldkonto im Heim gehört ebenfalls dazu."
aktion={
schreiben ? (
<Button asChild>
<Link href="/finanzen/konten/neu">
<Plus aria-hidden="true" />
Konto anlegen
</Link>
</Button>
) : undefined
}
/>
) : (
<Table>
<TableHeader>
<TableRow>
<TableHead>Konto</TableHead>
<TableHead>Art</TableHead>
<TableHead>Stand vom</TableHead>
<TableHead className="text-right">Betrag</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{kontostaendeZumStichtag(konten, stichtag).map((stand) => (
<TableRow key={stand.kontoId}>
<TableCell>
<Link
href={`/finanzen/konten/${stand.kontoId}`}
className="font-medium hover:underline"
>
{stand.bezeichnung}
</Link>
{stand.istBetreuerkonto && (
<span className="block text-sm text-muted-foreground">
Konto des Betreuers – zählt nicht zum Vermögen der Betreuten
</span>
)}
{stand.ibanMaskiert && (
<span className="block text-sm text-muted-foreground">
{stand.ibanMaskiert}
</span>
)}
</TableCell>
<TableCell className="text-sm text-muted-foreground">
{stand.artBeschriftung}
</TableCell>
<TableCell className="whitespace-nowrap text-sm text-muted-foreground">
{stand.stichtag ? formatDatum(stand.stichtag) : 'nie erfasst'}
</TableCell>
<TableCell className="text-right">
<Betrag cent={centZuZahl(stand.betragCent)} />
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
)}
</CardContent>
</Card>
{/* ------------------------------------------------------------- */}
<Card>
<CardHeader className="flex-row items-start justify-between gap-3">
<div>
<CardTitle>Zuletzt gebucht</CardTitle>
<CardDescription>Die acht jüngsten Einträge im Kassenbuch.</CardDescription>
</div>
<div className="flex shrink-0 flex-wrap gap-2">
{schreiben && (
<Button asChild variant="ghost" size="sm">
<Link href="/finanzen/buchungen/import">
<Upload aria-hidden="true" />
Importieren
</Link>
</Button>
)}
<Button asChild variant="ghost" size="sm">
<Link href="/finanzen/buchungen">
Alle ansehen
<ArrowRight aria-hidden="true" />
</Link>
</Button>
</div>
</CardHeader>
<CardContent>
{letzte.length === 0 ? (
<Leerzustand
icon={Banknote}
titel="Das Kassenbuch ist noch leer"
beschreibung="Erfasse die erste Buchung von Hand oder lies einen Kontoauszug als CSV ein."
aktion={
schreiben ? (
<div className="flex flex-wrap justify-center gap-2">
<Button asChild>
<Link href="/finanzen/buchungen/neu">
<Plus aria-hidden="true" />
Buchung erfassen
</Link>
</Button>
<Button asChild variant="secondary">
<Link href="/finanzen/buchungen/import">
<Upload aria-hidden="true" />
CSV einlesen
</Link>
</Button>
</div>
) : undefined
}
/>
) : (
<Table>
<TableHeader>
<TableRow>
<TableHead>Datum</TableHead>
<TableHead>Vorgang</TableHead>
<TableHead>Beleg</TableHead>
<TableHead className="text-right">Betrag</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{letzte.map((buchung) => (
<TableRow key={buchung.id}>
<TableCell className="whitespace-nowrap">
{formatDatum(buchung.datum)}
</TableCell>
<TableCell>
<Link
href={`/finanzen/buchungen/${buchung.id}`}
className="font-medium hover:underline"
>
{buchung.gegenstelle ?? KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
</Link>
<span className="block text-sm text-muted-foreground">
{KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
{!buchung.betrifftBetreute && ' · eigene Auslage'}
{buchung.vermoegenswirksam && ' · vermögenswirksam'}
</span>
{vermischungsWarnung(buchung) && (
<span className="mt-1 block">
<Vermischungswarnung kurz />
</span>
)}
</TableCell>
<TableCell>
<Belegzeichen
belegId={buchung.belegId}
belegTitel={buchung.belegTitel ?? null}
begruendung={buchung.belegFehltBegruendung}
/>
</TableCell>
<TableCell className="text-right">
<Betrag cent={centZuZahl(buchung.betragCent)} richtung={buchung.richtung} />
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
)}
</CardContent>
</Card>
<Rechtshinweis rechtsgrundlage="§ 1835 BGB, §§ 1859, 1865 BGB" />
</div>
)
}