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,63 @@
import type { Metadata } from 'next'
import { notFound, redirect } from 'next/navigation'
import { SeitenKopf } from '@/components/seiten-kopf'
import { KontaktFormular } from '@/components/kontakte/kontakt-formular'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
import { oeffnen } from '@/lib/crypto/feld'
import { db, nichtGeloescht } from '@/lib/db'
export const metadata: Metadata = { title: 'Kontakt bearbeiten' }
export default async function KontaktBearbeitenSeite({
params,
}: {
params: Promise<{ id: string }>
}) {
const { id } = await params
const benutzer = await erfordereBenutzer(`/kontakte/${id}/bearbeiten`)
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute } = await erfordereZugang(aktive.id, 'KONTAKTE', 'schreiben')
const roh = await db.kontakt.findFirst({
where: { id, betreuteId: betreute.id, ...nichtGeloescht },
})
if (!roh) notFound()
const kontakt = oeffnen('Kontakt', roh)
return (
<div className="max-w-3xl space-y-6">
<SeitenKopf
titel="Kontakt bearbeiten"
beschreibung={kontakt.name}
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: kontakt.name, href: `/kontakte/${kontakt.id}` },
{ titel: 'Bearbeiten' },
]}
/>
<KontaktFormular
betreuteId={betreute.id}
kontakt={{
id: kontakt.id,
name: kontakt.name,
organisation: kontakt.organisation,
rolle: kontakt.rolle,
telefon: kontakt.telefon,
mobil: kontakt.mobil,
fax: kontakt.fax,
email: kontakt.email,
strasse: kontakt.strasse,
plz: kontakt.plz,
ort: kontakt.ort,
aktenzeichen: kontakt.aktenzeichen,
notizen: kontakt.notizen ?? null,
}}
/>
</div>
)
}
+186
View File
@@ -0,0 +1,186 @@
import type { Metadata } from 'next'
import Link from 'next/link'
import { notFound, redirect } from 'next/navigation'
import { MessageSquarePlus } from 'lucide-react'
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
import { KontaktKarte } from '@/components/kontakte/kontakt-karte'
import { PapierkorbKnopf } from '@/components/kontakte/papierkorb-knopf'
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 { KONTAKT_ROLLE_BESCHRIFTUNG } from '@/lib/validierung/kontakte'
import { kontaktInPapierkorb } from '@/server/actions/kontakte'
export const metadata: Metadata = { title: 'Kontakt' }
/**
* Ein Kontakt mit seiner Gespraechshistorie.
*
* Die Historie ist der eigentliche Wert der Seite: Wer vor dem naechsten
* Anruf beim Bezirk hierher schaut, weiss, was beim letzten Mal gesagt
* wurde - und unter welchem Aktenzeichen.
*/
export default async function KontaktSeite({ params }: { params: Promise<{ id: string }> }) {
const { id } = await params
const benutzer = await erfordereBenutzer(`/kontakte/${id}`)
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 [kontaktRoh, protokolleRoh] = await Promise.all([
db.kontakt.findFirst({ where: { id, betreuteId: betreute.id, ...nichtGeloescht } }),
db.kontaktprotokoll.findMany({
where: { kontaktId: id, betreuteId: betreute.id, ...nichtGeloescht },
orderBy: { datum: 'desc' },
include: { vorgang: { select: { id: true, titel: true } } },
}),
])
if (!kontaktRoh) notFound()
const kontakt = oeffnen('Kontakt', kontaktRoh)
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: null,
vorgang: eintrag.vorgang,
}
})
return (
<div className="space-y-6">
<SeitenKopf
titel={kontakt.name}
beschreibung={
<>
{KONTAKT_ROLLE_BESCHRIFTUNG[kontakt.rolle]}
{kontakt.organisation ? ` · ${kontakt.organisation}` : ''}
</>
}
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: kontakt.name },
]}
aktionen={
darfSchreiben ? (
<>
<Button asChild variant="outline">
<Link href={`/kontakte/${kontakt.id}/bearbeiten`}>Bearbeiten</Link>
</Button>
<Button asChild>
<Link
href={`/kontakte/protokoll/neu?kontakt=${kontakt.id}&weiter=/kontakte/${kontakt.id}`}
>
<MessageSquarePlus aria-hidden="true" />
Gespräch festhalten
</Link>
</Button>
</>
) : undefined
}
/>
<Card>
<CardHeader className="pb-2">
<CardTitle className="text-base">Erreichbarkeit</CardTitle>
</CardHeader>
<CardContent>
<ul>
<KontaktKarte
kontakt={{
id: kontakt.id,
name: kontakt.name,
organisation: kontakt.organisation,
rolle: kontakt.rolle,
telefon: kontakt.telefon,
mobil: kontakt.mobil,
fax: kontakt.fax,
email: kontakt.email,
strasse: kontakt.strasse,
plz: kontakt.plz,
ort: kontakt.ort,
aktenzeichen: kontakt.aktenzeichen,
protokolle: zeilen.length,
letzterKontaktAm: zeilen[0]?.datum ?? null,
}}
/>
</ul>
</CardContent>
</Card>
{kontakt.notizen && (
<Card>
<CardHeader className="pb-2">
<CardTitle className="text-base">
Notizen
<Badge variant="secondary" className="ml-2">
verschlüsselt gespeichert
</Badge>
</CardTitle>
</CardHeader>
<CardContent>
<p className="whitespace-pre-wrap">{kontakt.notizen}</p>
</CardContent>
</Card>
)}
<section aria-labelledby="historie" className="space-y-3">
<h2 id="historie" className="text-lg font-semibold">
Gesprächshistorie ({zeilen.length})
</h2>
{zeilen.length === 0 ? (
<Leerzustand
icon={MessageSquarePlus}
titel="Noch kein Gespräch festgehalten."
beschreibung="Halte nach jedem Telefonat fest, was besprochen wurde und wer es zugesagt hat. Beim nächsten Anruf ist genau das die Grundlage."
aktion={
darfSchreiben ? (
<Button asChild>
<Link
href={`/kontakte/protokoll/neu?kontakt=${kontakt.id}&weiter=/kontakte/${kontakt.id}`}
>
Gespräch festhalten
</Link>
</Button>
) : undefined
}
/>
) : (
<ProtokollListe zeilen={zeilen} ohneKontaktspalte />
)}
</section>
{darfSchreiben && (
<div className="border-t pt-6">
<PapierkorbKnopf
aktion={kontaktInPapierkorb}
id={kontakt.id}
betreuteId={betreute.id}
frage={`„${kontakt.name}“ in den Papierkorb verschieben? Die Gesprächshistorie bleibt erhalten.`}
beschriftung="Kontakt in den Papierkorb"
/>
</div>
)}
</div>
)
}
+30
View File
@@ -0,0 +1,30 @@
import type { Metadata } from 'next'
import { redirect } from 'next/navigation'
import { SeitenKopf } from '@/components/seiten-kopf'
import { KontaktFormular } from '@/components/kontakte/kontakt-formular'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
export const metadata: Metadata = { title: 'Kontakt anlegen' }
export default async function KontaktNeuSeite() {
const benutzer = await erfordereBenutzer('/kontakte/neu')
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute } = await erfordereZugang(aktive.id, 'KONTAKTE', 'schreiben')
return (
<div className="max-w-3xl space-y-6">
<SeitenKopf
titel="Kontakt anlegen"
beschreibung="Name und Rolle reichen für den Anfang. Telefonnummer und Aktenzeichen lassen sich jederzeit nachtragen."
pfad={[
{ titel: 'Heute', href: '/heute' },
{ titel: 'Kontakte', href: '/kontakte' },
{ titel: 'Neu' },
]}
/>
<KontaktFormular betreuteId={betreute.id} />
</div>
)
}
+141
View File
@@ -0,0 +1,141 @@
import type { Metadata } from 'next'
import Link from 'next/link'
import { redirect } from 'next/navigation'
import { Users } from 'lucide-react'
import type { KontaktRolle } from '@prisma/client'
import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Leerzustand, SeitenKopf } from '@/components/seiten-kopf'
import { KontaktKarte, type KontaktListeneintrag } from '@/components/kontakte/kontakt-karte'
import { darf } from '@/lib/auth/rollen'
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
import { db, nichtGeloescht } from '@/lib/db'
import { KONTAKT_ROLLEN, KONTAKT_ROLLE_BESCHRIFTUNG } from '@/lib/validierung/kontakte'
export const metadata: Metadata = { title: 'Kontakte' }
/**
* Das Kontaktverzeichnis.
*
* Gruppiert nach Rolle, nicht alphabetisch: Wenn ich hier hereinschaue,
* suche ich "den Rechtspfleger" oder "die Sachbearbeiterin beim Bezirk" -
* nicht einen Namen, den ich ohnehin nicht mehr weiss.
*/
export default async function KontakteSeite() {
const benutzer = await erfordereBenutzer('/kontakte')
const aktive = await aktiveBetreute(benutzer)
if (!aktive) redirect('/ersteinrichtung')
const { betreute, zugang } = await erfordereZugang(aktive.id, 'KONTAKTE', 'lesen')
const darfSchreiben = darf(zugang, 'KONTAKTE', 'schreiben')
// Zwei Abfragen, keine Schleife: die Kontakte selbst und - in einem
// Rutsch - Anzahl und juengstes Datum der Protokolle je Kontakt.
const [kontakte, protokollzahlen] = await Promise.all([
db.kontakt.findMany({
where: { betreuteId: betreute.id, ...nichtGeloescht },
orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
select: {
id: true,
name: true,
organisation: true,
rolle: true,
telefon: true,
mobil: true,
fax: true,
email: true,
strasse: true,
plz: true,
ort: true,
aktenzeichen: true,
},
}),
db.kontaktprotokoll.groupBy({
by: ['kontaktId'],
where: { betreuteId: betreute.id, kontaktId: { not: null }, ...nichtGeloescht },
_count: { _all: true },
_max: { datum: true },
}),
])
const zahlen = new Map(
protokollzahlen.map((zeile) => [
zeile.kontaktId,
{ anzahl: zeile._count._all, letzter: zeile._max.datum },
]),
)
const eintraege: KontaktListeneintrag[] = kontakte.map((kontakt) => ({
...kontakt,
protokolle: zahlen.get(kontakt.id)?.anzahl ?? 0,
letzterKontaktAm: zahlen.get(kontakt.id)?.letzter ?? null,
}))
const gruppen = KONTAKT_ROLLEN.map((rolle) => ({
rolle: rolle as KontaktRolle,
eintraege: eintraege.filter((e) => e.rolle === rolle),
})).filter((gruppe) => gruppe.eintraege.length > 0)
return (
<div className="space-y-6">
<SeitenKopf
titel="Kontakte"
beschreibung="Alle Stellen, mit denen ich in dieser Betreuung zu tun habe – mit dem Aktenzeichen, unter dem sie den Vorgang führen."
pfad={[{ titel: 'Heute', href: '/heute' }, { titel: 'Kontakte' }]}
aktionen={
darfSchreiben ? (
<>
<Button asChild variant="outline">
<Link href="/kontakte/protokoll">Kontaktprotokoll</Link>
</Button>
<Button asChild>
<Link href="/kontakte/neu">Kontakt anlegen</Link>
</Button>
</>
) : (
<Button asChild variant="outline">
<Link href="/kontakte/protokoll">Kontaktprotokoll</Link>
</Button>
)
}
/>
{gruppen.length === 0 ? (
<Leerzustand
icon={Users}
titel="Noch kein Kontakt erfasst."
beschreibung="Fang mit den drei Stellen an, mit denen du am häufigsten zu tun hast: Rechtspfleger beim Betreuungsgericht, Sachbearbeiter beim Bezirk und die Heimleitung."
aktion={
darfSchreiben ? (
<Button asChild>
<Link href="/kontakte/neu">Ersten Kontakt anlegen</Link>
</Button>
) : undefined
}
/>
) : (
<div className="space-y-4">
{gruppen.map((gruppe) => (
<Card key={gruppe.rolle}>
<CardHeader className="pb-2">
<CardTitle className="text-base">
{KONTAKT_ROLLE_BESCHRIFTUNG[gruppe.rolle]}
<span className="ml-2 text-sm font-normal text-muted-foreground">
{gruppe.eintraege.length}
</span>
</CardTitle>
</CardHeader>
<CardContent>
<ul className="divide-y">
{gruppe.eintraege.map((kontakt) => (
<KontaktKarte key={kontakt.id} kontakt={kontakt} />
))}
</ul>
</CardContent>
</Card>
))}
</div>
)}
</div>
)
}
@@ -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
}