feat: Dashboard Heute, Kontakte und Kontaktprotokoll

Das Dashboard beantwortet die Frage, was heute ansteht - nicht, welche
Daten es gibt. Jede Kachel endet in einer Handlung: Fristen-Ampel,
wartet auf andere (mit Tagen seit dem letzten Kontakt), offene
Nachforderungen des Bezirks mit Fortschrittsbalken, ungepruefter
Posteingang, unverbuchte Belege, Kennzahlen.

Zwoelf Abfragen in einem Promise.all, kein N+1. Cent-Betraege werden
beim Verlassen der Serverseite gewandelt.

Kacheln zu Modulen, die ein Mitleser nicht freigegeben bekommen hat,
entfallen ganz - sie zeigen nicht "0", denn das waere eine Aussage ueber
Daten, die er nicht sehen darf.

Kontaktprotokoll als Schnellerfassung: Datum vorbelegt, Art als grosse
Knopfreihe, Dauer als Schnellwahl, ein Freitextfeld. Alles andere
eingeklappt. Ziel sind unter 20 Sekunden am Handy.

Das Haekchen "persoenlicher Kontakt zur betreuten Person" ist bewusst
NICHT vorbelegt - es wandert in den Jahresbericht nach § 1863 BGB, und
ein versehentlich gesetztes Haekchen waere dort eine falsche Angabe
gegenueber dem Gericht.

Aus demselben Grund gilt der Textbaustein "regelmaessiger persoenlicher
Kontakt" erst ab persoenlichem Kontakt in mindestens 75 Prozent der
Monate. Sonst schreibt die Auswertung ausdruecklich, dass kein
persoenlicher Kontakt dokumentiert ist. Ein geschoenter Bericht hilft
niemandem.

Protokolldaten werden als 12:00 UTC gespeichert und durchgaengig in UTC
gerechnet, sonst kippt die Zeitzone einzelne Besuchstage.

51 Tests.

Etappe: 2
Phase: Alltag
This commit is contained in:
Florian Wilde
2026-08-22 02:26:38 +02:00
parent 0cdd4edfdc
commit 6b4df4c9cb
18 changed files with 2162 additions and 6 deletions
@@ -0,0 +1,110 @@
import type { Metadata } from 'next'
import { notFound, redirect } from 'next/navigation'
import { SeitenKopf } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { PapierkorbKnopf } from '@/components/kontakte/papierkorb-knopf'
import { ProtokollErfassung } from '@/components/kontakte/protokoll-erfassung'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
import { oeffnen } from '@/lib/crypto/feld'
import { db, nichtGeloescht } from '@/lib/db'
import {
KONTAKT_ART_BESCHRIFTUNG,
KONTAKT_ROLLE_BESCHRIFTUNG,
tagFuerFormular,
} from '@/lib/validierung/kontakte'
import { protokollInPapierkorb } from '@/server/actions/kontakte'
import { formatDatum } from '@/lib/utils'
export const metadata: Metadata = { title: 'Eintrag bearbeiten' }
/**
* Einen bestehenden Eintrag nachbessern - typisch: der Satz, der beim
* Erfassen im Heimflur zu knapp geraten ist, und die Wuensche, die einem
* erst auf der Rueckfahrt wieder einfallen.
*/
export default async function ProtokollBearbeitenSeite({
params,
}: {
params: Promise<{ id: string }>
}) {
const { id } = await params
const benutzer = await erfordereBenutzer(`/kontakte/protokoll/${id}`)
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute } = await erfordereZugang(aktive.id, 'KONTAKTE', 'schreiben')
const [roh, kontakte, vorgaenge] = await Promise.all([
db.kontaktprotokoll.findFirst({
where: { id, betreuteId: betreute.id, ...nichtGeloescht },
}),
db.kontakt.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
orderBy: [{ name: 'asc' }],
select: { id: true, name: true, organisation: true, rolle: true },
}),
db.vorgang.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
orderBy: [{ aktualisiertAm: 'desc' }],
select: { id: true, titel: true },
}),
])
if (!roh) notFound()
const protokoll = oeffnen('Kontaktprotokoll', roh)
return (
<div className="max-w-2xl space-y-6">
<SeitenKopf
titel="Eintrag bearbeiten"
beschreibung={`${KONTAKT_ART_BESCHRIFTUNG[roh.art]} am ${formatDatum(roh.datum)}`}
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: 'Kontaktprotokoll', href: '/kontakte/protokoll' },
{ titel: 'Bearbeiten' },
]}
/>
<ProtokollErfassung
betreuteId={betreute.id}
heute={tagFuerFormular(new Date())}
kontakte={kontakte.map((kontakt) => ({
id: kontakt.id,
bezeichnung: `${kontakt.name}${
kontakt.organisation ? ` – ${kontakt.organisation}` : ''
} (${KONTAKT_ROLLE_BESCHRIFTUNG[kontakt.rolle]})`,
}))}
vorgaenge={vorgaenge.map((vorgang) => ({ id: vorgang.id, bezeichnung: vorgang.titel }))}
protokoll={{
id: roh.id,
datum: tagFuerFormular(roh.datum),
art: roh.art,
dauerMinuten: roh.dauerMinuten,
gespraechspartner: roh.gespraechspartner,
mitBetreuter: roh.mitBetreuter,
kontaktId: roh.kontaktId,
vorgangId: roh.vorgangId,
inhalt: protokoll.inhalt ?? null,
wuensche: protokoll.wuensche ?? null,
folgeaufgaben: protokoll.folgeaufgaben ?? null,
}}
weiter="/kontakte/protokoll"
/>
<Rechtshinweis rechtsgrundlage="§ 1863 BGB, § 1821 BGB" kurz />
<div className="border-t pt-6">
<PapierkorbKnopf
aktion={protokollInPapierkorb}
id={roh.id}
betreuteId={betreute.id}
frage="Diesen Eintrag in den Papierkorb verschieben? Er fehlt dann in der Auswertung für den Jahresbericht."
beschriftung="Eintrag in den Papierkorb"
/>
</div>
</div>
)
}
@@ -0,0 +1,107 @@
import type { Metadata } from 'next'
import { redirect } from 'next/navigation'
import { SeitenKopf } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { ProtokollErfassung, type ProtokollWerte } from '@/components/kontakte/protokoll-erfassung'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
import { db, nichtGeloescht } from '@/lib/db'
import { KONTAKT_ROLLE_BESCHRIFTUNG } from '@/lib/validierung/kontakte'
export const metadata: Metadata = { title: 'Kontakt festhalten' }
/**
* Die Schnellerfassung.
*
* Diese Seite wird im Stehen bedient, mit einer Hand, direkt nach dem
* Besuch. Alles, was nicht in den ersten Sekunden gebraucht wird, ist
* eingeklappt.
*/
export default async function ProtokollNeuSeite({
searchParams,
}: {
searchParams: Promise<{ kontakt?: string; vorgang?: string; weiter?: string }>
}) {
const parameter = await searchParams
const benutzer = await erfordereBenutzer('/kontakte/protokoll/neu')
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute } = await erfordereZugang(aktive.id, 'KONTAKTE', 'schreiben')
const [kontakte, vorgaenge] = await Promise.all([
db.kontakt.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
orderBy: [{ name: 'asc' }],
select: { id: true, name: true, organisation: true, rolle: true },
}),
db.vorgang.findMany({
where: { betreuteId: betreute.id, erledigtAm: null, ...nichtGeloescht },
orderBy: [{ aktualisiertAm: 'desc' }],
select: { id: true, titel: true },
}),
])
// Vorbelegung, wenn aus einem Kontakt oder Vorgang heraus aufgerufen.
const vorbelegt: ProtokollWerte | undefined =
parameter.kontakt || parameter.vorgang
? {
id: '',
datum: heuteAlsFeldwert(),
art: 'BESUCH',
dauerMinuten: null,
gespraechspartner: null,
mitBetreuter: false,
kontaktId: parameter.kontakt ?? null,
vorgangId: parameter.vorgang ?? null,
inhalt: null,
wuensche: null,
folgeaufgaben: null,
}
: undefined
return (
<div className="max-w-2xl space-y-6">
<SeitenKopf
titel="Kontakt festhalten"
beschreibung="Datum, Art, ein Satz – fertig. Alles Weitere ist optional."
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: 'Kontaktprotokoll', href: '/kontakte/protokoll' },
{ titel: 'Neu' },
]}
/>
<ProtokollErfassung
betreuteId={betreute.id}
heute={heuteAlsFeldwert()}
kontakte={kontakte.map((kontakt) => ({
id: kontakt.id,
bezeichnung: `${kontakt.name}${
kontakt.organisation ? ` – ${kontakt.organisation}` : ''
} (${KONTAKT_ROLLE_BESCHRIFTUNG[kontakt.rolle]})`,
}))}
vorgaenge={vorgaenge.map((vorgang) => ({ id: vorgang.id, bezeichnung: vorgang.titel }))}
protokoll={vorbelegt}
weiter={sichererPfad(parameter.weiter)}
/>
<Rechtshinweis rechtsgrundlage="§ 1863 BGB, § 1821 BGB" kurz />
</div>
)
}
/** Heutiges Datum im Format, das ein <input type="date"> erwartet. */
function heuteAlsFeldwert(): string {
const heute = new Date()
const monat = String(heute.getMonth() + 1).padStart(2, '0')
const tag = String(heute.getDate()).padStart(2, '0')
return `${heute.getFullYear()}-${monat}-${tag}`
}
/** Nur anwendungsinterne Pfade zulassen. */
function sichererPfad(pfad: string | undefined): string | undefined {
if (!pfad || !pfad.startsWith('/') || pfad.startsWith('//')) return undefined
return pfad
}
+234
View File
@@ -0,0 +1,234 @@
import type { Metadata } from 'next'
import Link from 'next/link'
import { redirect } from 'next/navigation'
import { addYears, isAfter, startOfYear, subMonths } from 'date-fns'
import { MessageSquarePlus } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Feld } from '@/components/feld'
import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
import { AuswertungAnzeige } from '@/components/kontakte/auswertung-anzeige'
import { ProtokollListe, type ProtokollZeile } from '@/components/kontakte/protokoll-liste'
import { darf } from '@/lib/auth/rollen'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
import { oeffnen } from '@/lib/crypto/feld'
import { db, nichtGeloescht } from '@/lib/db'
import { kontaktstatistik } from '@/lib/kontakte/auswertung'
import { cn } from '@/lib/utils'
export const metadata: Metadata = { title: 'Kontaktprotokoll' }
/**
* Alle Kontaktprotokolle, chronologisch, mit Zeitraumfilter - und darueber
* die Auswertung, aus der spaeter der Jahresbericht gespeist wird.
*
* Der Standardzeitraum sind die letzten zwoelf Monate. Wer den Bericht
* schreibt, stellt oben auf das Betreuungsjahr um; die Schnellwahl dafuer
* steht bereit, sobald ein Bestellungsdatum in den Stammdaten steht.
*/
export default async function ProtokollSeite({
searchParams,
}: {
searchParams: Promise<{ von?: string; bis?: string; hervorgehoben?: string }>
}) {
const parameter = await searchParams
const benutzer = await erfordereBenutzer('/kontakte/protokoll')
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute, zugang } = await erfordereZugang(aktive.id, 'KONTAKTE', 'lesen')
const darfSchreiben = darf(zugang, 'KONTAKTE', 'schreiben')
const heute = new Date()
const vonVorgabe = subMonths(heute, 12)
const von = tagAusParameter(parameter.von, 'anfang') ?? tagesAnfang(vonVorgabe)
const bis = tagAusParameter(parameter.bis, 'ende') ?? tagesEnde(heute)
const [protokolleRoh, auswertung] = await Promise.all([
db.kontaktprotokoll.findMany({
where: { betreuteId: betreute.id, datum: { gte: von, lte: bis }, ...nichtGeloescht },
orderBy: { datum: 'desc' },
include: {
kontakt: { select: { id: true, name: true } },
vorgang: { select: { id: true, titel: true } },
},
}),
kontaktstatistik(betreute.id, von, bis),
])
const zeilen: ProtokollZeile[] = protokolleRoh.map((eintrag) => {
const offen = oeffnen('Kontaktprotokoll', eintrag)
return {
id: eintrag.id,
datum: eintrag.datum,
art: eintrag.art,
dauerMinuten: eintrag.dauerMinuten,
gespraechspartner: eintrag.gespraechspartner,
mitBetreuter: eintrag.mitBetreuter,
inhalt: offen.inhalt ?? null,
wuensche: offen.wuensche ?? null,
folgeaufgaben: offen.folgeaufgaben ?? null,
kontakt: eintrag.kontakt,
vorgang: eintrag.vorgang,
}
})
// Schnellwahlen fuer den Zeitraum.
const schnellwahl: { titel: string; von: Date; bis: Date }[] = [
{ titel: 'Letzte 12 Monate', von: tagesAnfang(subMonths(heute, 12)), bis: tagesEnde(heute) },
{ titel: 'Laufendes Jahr', von: tagesAnfang(startOfYear(heute)), bis: tagesEnde(heute) },
]
if (betreute.bestellungAm) {
const beginn = betreuungsjahrBeginn(betreute.bestellungAm, heute)
schnellwahl.push({
titel: 'Laufendes Betreuungsjahr',
von: tagesAnfang(beginn),
bis: tagesEnde(heute),
})
}
return (
<div className="space-y-6">
<SeitenKopf
titel="Kontaktprotokoll"
beschreibung="Jeder Besuch, jedes Telefonat, jeder Brief – und was daraus folgt."
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: 'Kontaktprotokoll' },
]}
aktionen={
darfSchreiben ? (
<Button asChild>
<Link href="/kontakte/protokoll/neu">
<MessageSquarePlus aria-hidden="true" />
Kontakt festhalten
</Link>
</Button>
) : undefined
}
/>
{/* --- Zeitraum ------------------------------------------------------- */}
<Card>
<CardContent className="space-y-4 p-5">
<form method="get" className="flex flex-wrap items-end gap-4">
<Feld id="von" beschriftung="Von" className="w-44">
<Input name="von" type="date" defaultValue={alsFeldwert(von)} />
</Feld>
<Feld id="bis" beschriftung="Bis" className="w-44">
<Input name="bis" type="date" defaultValue={alsFeldwert(bis)} />
</Feld>
<Button type="submit" variant="outline">
Zeitraum anwenden
</Button>
</form>
<div className="flex flex-wrap gap-2">
{schnellwahl.map((wahl) => {
const aktiv = alsFeldwert(wahl.von) === alsFeldwert(von) && alsFeldwert(wahl.bis) === alsFeldwert(bis)
return (
<Link
key={wahl.titel}
href={`/kontakte/protokoll?von=${alsFeldwert(wahl.von)}&bis=${alsFeldwert(wahl.bis)}`}
className={cn(
'inline-flex min-h-11 items-center rounded-md border px-3 text-sm font-medium',
'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',
aktiv
? 'border-primary bg-primary text-primary-foreground'
: 'border-input hover:bg-accent',
)}
>
{wahl.titel}
</Link>
)
})}
</div>
</CardContent>
</Card>
{/* --- Auswertung fuer den Jahresbericht ------------------------------ */}
<AuswertungAnzeige statistik={auswertung} textbaustein={auswertung.textbaustein} />
{/* --- Die Eintraege selbst ------------------------------------------- */}
<section aria-labelledby="eintraege" className="space-y-3">
<h2 id="eintraege" className="text-lg font-semibold">
Einträge ({zeilen.length})
</h2>
{zeilen.length === 0 ? (
<Leerzustand
icon={MessageSquarePlus}
titel="In diesem Zeitraum ist nichts festgehalten."
beschreibung="Halte gleich nach dem Besuch oder dem Telefonat fest, was war – aus dem Gedächtnis wird es Wochen später ungenau, und der Jahresbericht lebt davon."
aktion={
darfSchreiben ? (
<Button asChild>
<Link href="/kontakte/protokoll/neu">Ersten Kontakt festhalten</Link>
</Button>
) : undefined
}
/>
) : (
<ProtokollListe zeilen={zeilen} hervorgehoben={parameter.hervorgehoben} />
)}
</section>
</div>
)
}
// -----------------------------------------------------------------------------
// Zeitrechnung
// -----------------------------------------------------------------------------
const TAG_MUSTER = /^\d{4}-\d{2}-\d{2}$/
/**
* Die Protokolle liegen zur Mittagszeit in UTC. Der Zeitraum wird deshalb
* ebenfalls in UTC aufgespannt - so faellt der Randtag zuverlaessig hinein.
*/
function tagAusParameter(wert: string | undefined, kante: 'anfang' | 'ende'): Date | null {
if (!wert || !TAG_MUSTER.test(wert)) return null
const datum = new Date(`${wert}T${kante === 'anfang' ? '00:00:00.000' : '23:59:59.999'}Z`)
return Number.isNaN(datum.getTime()) ? null : datum
}
function tagesAnfang(datum: Date): Date {
return new Date(
Date.UTC(datum.getFullYear(), datum.getMonth(), datum.getDate(), 0, 0, 0, 0),
)
}
function tagesEnde(datum: Date): Date {
return new Date(
Date.UTC(datum.getFullYear(), datum.getMonth(), datum.getDate(), 23, 59, 59, 999),
)
}
function alsFeldwert(datum: Date): string {
const monat = String(datum.getUTCMonth() + 1).padStart(2, '0')
const tag = String(datum.getUTCDate()).padStart(2, '0')
return `${datum.getUTCFullYear()}-${monat}-${tag}`
}
/**
* Das Betreuungsjahr laeuft ab dem Tag der Bestellung, nicht ab dem
* Kalenderjahr. Gesucht ist der letzte Jahrestag, der nicht in der Zukunft
* liegt.
*/
function betreuungsjahrBeginn(bestellungAm: Date, heute: Date): Date {
const start = new Date(
bestellungAm.getUTCFullYear(),
bestellungAm.getUTCMonth(),
bestellungAm.getUTCDate(),
)
let beginn = start
while (!isAfter(addYears(beginn, 1), heute)) {
beginn = addYears(beginn, 1)
}
return beginn
}