Schreiben erzeugen, ausgeben und ablegen
Die Anschreiben gab es bisher nur als Text zum Kopieren. Danach war
Handarbeit: in Word nachbauen, ausdrucken, abschicken - und noch einmal
von Hand als Dokument in die Akte legen. Der letzte Schritt wurde am
haeufigsten vergessen, und dann fehlt der Nachweis im Bericht.
Neu unter /schreiben/neu: bearbeiten, als Word-Datei herunterladen, in
die Akte legen, Wiedervorlage setzen - in einem Zug. Eine Seite fuer alle
Arten und alle drei Empfaengerwege, statt die Bearbeitung dreimal an
Vertrag, Vorgang und Freitext nachzubauen.
Der dritte Weg ist der eigentliche Zugewinn: Schreiben an eine Stelle,
zu der es noch keinen Datensatz gibt. Am Anfang einer Betreuung ist das
der Normalfall - man fragt ja an, um zu erfahren, ob dort ueberhaupt
etwas besteht. Aus der freien Anschrift laesst sich mit einem Klick ein
Kontakt anlegen.
Zwei Entscheidungen, die erklaert gehoeren:
Die Akte bekommt ein PDF, heruntergeladen wird .docx. Der
Objektspeicher nimmt nur PDF und Bilder an, geprueft an den Magic Bytes.
Eine .docx ist ein ZIP-Archiv; sie durchzulassen hiesse jedes ZIP
durchzulassen, und diese Pruefung ist eine bewusste Zusage der
Anwendung. Sachlich ist PDF fuer den Nachweis ohnehin richtiger: Es
aendert sich nicht mehr. Die Oberflaeche sagt dazu, dass eine spaeter in
Word geaenderte Fassung von der Akte abweicht.
Der Berichtssatz in berichte/docx.ts bleibt unangetastet. Er setzt einen
Bericht mit Kopfzeilen und Unterschriftenblock; ein Brief braucht
Absender, Anschriftenfeld, Datumszeile und Grussformel. Beides in eine
Funktion zu zwingen haette beide Ausgaben schlechter gemacht. Der
Umsetzungshinweis im Issue ("muss nur angebunden werden") war insoweit
falsch - von mir selbst geschrieben.
Die vorhandenen Erzeuger (Rueckkaufswert, Kuendigung, Sachstandsanfrage)
bleiben unveraendert; ihr Wortlaut ist getestet und erprobt.
Geprueft: zehn Einheitstests, darunter der Gleichschritt der
Wiedervorlagefristen ueber zwei Module hinweg. Fuenf End-to-End-Tests
auf beiden Geraeteprofilen: Entwurf, Vertragsbezug, Word-Download,
Ablage samt Wiedervorlage, Kontakt aus freier Anschrift.
Refs #4
This commit is contained in:
Florian Wilde
@@ -0,0 +1,68 @@
|
||||
import { NextResponse } from 'next/server'
|
||||
import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
|
||||
import { briefDocxErzeugen } from '@/lib/schreiben/docx'
|
||||
import { dateinameFuerSchreiben, istSchreibenArt } from '@/lib/schreiben/arten'
|
||||
import { heuteAlsTag } from '@/lib/fristen/datum'
|
||||
import { tagAusText } from '@/lib/finanzen/datum'
|
||||
|
||||
/**
|
||||
* Das Schreiben als Word-Datei herunterladen.
|
||||
*
|
||||
* Warum eine Route und keine Server Action? Eine Action kann keinen
|
||||
* Download ausloesen - sie muesste die Datei kodiert zurueckgeben und der
|
||||
* Browser sie nachbauen. Eine Route liefert sie unmittelbar aus, mit
|
||||
* richtigem Namen und Typ. Denselben Weg geht schon der Vollexport.
|
||||
*
|
||||
* POST und nicht GET, weil der bearbeitete Brieftext mitkommt und in eine
|
||||
* Adresszeile weder hineinpasst noch hineingehoert: Er stuende sonst im
|
||||
* Verlauf des Browsers und in jedem Zwischenspeicher.
|
||||
*/
|
||||
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
const MIME_DOCX = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
|
||||
|
||||
export async function POST(anfrage: Request): Promise<Response> {
|
||||
let formular: FormData
|
||||
try {
|
||||
formular = await anfrage.formData()
|
||||
} catch {
|
||||
return NextResponse.json({ fehler: 'Ungültige Anfrage.' }, { status: 400 })
|
||||
}
|
||||
|
||||
const betreuteId = String(formular.get('betreuteId') ?? '')
|
||||
const rohArt = String(formular.get('art') ?? '')
|
||||
const text = String(formular.get('text') ?? '')
|
||||
const empfaenger = String(formular.get('empfaengerName') ?? '').trim()
|
||||
const versandRoh = String(formular.get('versandAm') ?? '').trim()
|
||||
|
||||
if (!betreuteId || !istSchreibenArt(rohArt) || text.trim().length < 30) {
|
||||
return NextResponse.json({ fehler: 'Unvollständige Angaben.' }, { status: 400 })
|
||||
}
|
||||
|
||||
try {
|
||||
// Zugriff wird hier geprueft und nicht nur auf der Seite davor: Eine
|
||||
// Route laesst sich unmittelbar aufrufen.
|
||||
await erfordereZugang(betreuteId, 'DOKUMENTE', 'lesen')
|
||||
} catch (ausnahme) {
|
||||
if (ausnahme instanceof ZugriffVerweigert) {
|
||||
return NextResponse.json({ fehler: ausnahme.message }, { status: 403 })
|
||||
}
|
||||
throw ausnahme
|
||||
}
|
||||
|
||||
const datum = tagAusText(versandRoh) ?? heuteAlsTag()
|
||||
const datei = await briefDocxErzeugen(text)
|
||||
const dateiname = dateinameFuerSchreiben(rohArt, empfaenger || null, datum, 'docx')
|
||||
|
||||
return new NextResponse(new Uint8Array(datei), {
|
||||
headers: {
|
||||
'Content-Type': MIME_DOCX,
|
||||
'Content-Disposition': `attachment; filename="${dateiname}"`,
|
||||
'Content-Length': String(datei.length),
|
||||
// Ein Schreiben aus einer Betreuungsakte gehoert in keinen
|
||||
// Zwischenspeicher.
|
||||
'Cache-Control': 'no-store, must-revalidate',
|
||||
},
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
import type { Metadata } from 'next'
|
||||
import { redirect } from 'next/navigation'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { AlertCircle, Scale } from 'lucide-react'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { SchreibenEditor } from '@/components/schreiben/schreiben-editor'
|
||||
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
|
||||
import { db, nichtGeloescht } from '@/lib/db'
|
||||
import { entwurfBauen } from '@/lib/schreiben/entwurf'
|
||||
import { SCHREIBEN_EIGENSCHAFTEN, istSchreibenArt } from '@/lib/schreiben/arten'
|
||||
|
||||
export const metadata: Metadata = { title: 'Schreiben' }
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
/**
|
||||
* Ein Schreiben erzeugen, bearbeiten, ausgeben und ablegen.
|
||||
*
|
||||
* Eine Seite für alle Arten und alle drei Empfängerwege — statt die
|
||||
* Bearbeitung dreimal an Vertrag, Vorgang und Freitext nachzubauen. Die
|
||||
* bestehenden Seiten verlinken hierher.
|
||||
*
|
||||
* Der Fall ohne Bezug ist ausdrücklich vorgesehen: Am Anfang einer
|
||||
* Betreuung schreibt man an Stellen, zu denen es noch keinen Datensatz
|
||||
* gibt — man fragt ja gerade an, um zu erfahren, ob dort etwas besteht.
|
||||
*/
|
||||
export default async function SchreibenSeite({
|
||||
searchParams,
|
||||
}: {
|
||||
searchParams: Promise<Record<string, string | string[] | undefined>>
|
||||
}) {
|
||||
const parameter = await searchParams
|
||||
const benutzer = await erfordereBenutzer('/schreiben/neu')
|
||||
const aktive = await aktiveBetreute(benutzer)
|
||||
if (!aktive) redirect('/ersteinrichtung')
|
||||
|
||||
const { darfSchreiben } = await erfordereZugang(aktive.id, 'DOKUMENTE', 'lesen')
|
||||
if (!darfSchreiben('DOKUMENTE')) redirect('/dokumente')
|
||||
|
||||
const text = (name: string): string => {
|
||||
const wert = parameter[name]
|
||||
return typeof wert === 'string' ? wert.trim() : ''
|
||||
}
|
||||
|
||||
const rohArt = text('art')
|
||||
const art = istSchreibenArt(rohArt) ? rohArt : 'FREI'
|
||||
const eigenschaften = SCHREIBEN_EIGENSCHAFTEN[art]
|
||||
|
||||
let entwurf
|
||||
try {
|
||||
entwurf = await entwurfBauen({
|
||||
betreuteId: aktive.id,
|
||||
benutzerName: benutzer.name,
|
||||
art,
|
||||
vertragId: text('vertragId') || null,
|
||||
vorgangId: text('vorgangId') || null,
|
||||
})
|
||||
} catch (ausnahme) {
|
||||
// Fehlender oder fremder Bezug: Das ist kein Absturz, sondern eine
|
||||
// Angabe, die nicht stimmt. Die Seite sagt es und bietet den freien
|
||||
// Weg an, statt den Benutzer vor eine Fehlerseite zu setzen.
|
||||
const meldung =
|
||||
ausnahme instanceof Error ? ausnahme.message : 'Der Entwurf ließ sich nicht bauen.'
|
||||
return (
|
||||
<div className="max-w-3xl space-y-6">
|
||||
<SeitenKopf titel="Schreiben" beschreibung={eigenschaften.beschriftung} />
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
{meldung} Du kannst stattdessen ein{' '}
|
||||
<a href="/schreiben/neu?art=FREI" className="underline">
|
||||
freies Schreiben
|
||||
</a>{' '}
|
||||
erzeugen.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
const kontakte = await db.kontakt.findMany({
|
||||
where: { betreuteId: aktive.id, ...nichtGeloescht },
|
||||
select: { id: true, name: true, organisation: true, strasse: true, plz: true, ort: true },
|
||||
orderBy: [{ organisation: 'asc' }, { name: 'asc' }],
|
||||
take: 200,
|
||||
})
|
||||
|
||||
return (
|
||||
<div className="max-w-3xl space-y-6">
|
||||
<SeitenKopf
|
||||
titel={eigenschaften.beschriftung}
|
||||
beschreibung="Bearbeiten, als Word-Datei herunterladen, in die Akte legen — und eine Wiedervorlage setzen, damit das Warten nicht vergessen geht."
|
||||
pfad={[{ titel: 'Dokumente', href: '/dokumente' }, { titel: 'Schreiben' }]}
|
||||
/>
|
||||
|
||||
<SchreibenEditor
|
||||
betreuteId={aktive.id}
|
||||
art={art}
|
||||
entwurf={{
|
||||
betreff: entwurf.betreff,
|
||||
text: entwurf.text,
|
||||
empfaengerName: entwurf.empfaengerName,
|
||||
wiedervorlageAm: entwurf.wiedervorlageAm,
|
||||
}}
|
||||
kontakte={kontakte}
|
||||
vertragId={entwurf.vertragId}
|
||||
vorgangId={entwurf.vorgangId}
|
||||
fristBegruendung={eigenschaften.fristBegruendung}
|
||||
warnungen={entwurf.warnungen}
|
||||
/>
|
||||
|
||||
<Alert variant="hinweis">
|
||||
<Scale aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Der vorgeschlagene Wortlaut ist ein Entwurf, keine Rechtsberatung. Bei einem
|
||||
genehmigungspflichtigen Geschäft gehört die Genehmigung des Betreuungsgerichts vor den
|
||||
Versand — nicht danach.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,379 +1,387 @@
|
||||
import { notFound } from 'next/navigation'
|
||||
import Link from 'next/link'
|
||||
import { ArrowLeft, Clock } from 'lucide-react'
|
||||
import type { VorgangStatus } from '@prisma/client'
|
||||
import { Badge } from '@/components/ui/badge'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { AufgabenListe, type AufgabenZeile } from '@/components/vorgaenge/aufgaben-liste'
|
||||
import { Faelligkeit } from '@/components/vorgaenge/faelligkeit'
|
||||
import { GenehmigungAnlegen } from '@/components/vorgaenge/genehmigung-anlegen'
|
||||
import {
|
||||
GenehmigungsKette,
|
||||
type GenehmigungsAnzeige,
|
||||
} from '@/components/vorgaenge/genehmigungs-kette'
|
||||
import { SachstandsanfrageKnopf } from '@/components/vorgaenge/sachstandsanfrage-knopf'
|
||||
import { StatusWechsler } from '@/components/vorgaenge/status-wechsler'
|
||||
import { VorgangLoeschen } from '@/components/vorgaenge/vorgang-loeschen'
|
||||
import { VorgangsFormular } from '@/components/vorgaenge/vorgangs-formular'
|
||||
import { ZeitstrahlAnzeige } from '@/components/vorgaenge/zeitstrahl-anzeige'
|
||||
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
|
||||
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
|
||||
import { entschluesselnWennMoeglich, oeffnen } from '@/lib/crypto/feld'
|
||||
import { KATEGORIE_BESCHRIFTUNG, PRIORITAET_BESCHRIFTUNG } from '@/lib/validierung/vorgaenge'
|
||||
import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
|
||||
import {
|
||||
VORGANG_STATUS_BESCHRIFTUNG,
|
||||
zeitstrahlBauen,
|
||||
type ZeitstrahlStatuswechsel,
|
||||
} from '@/lib/vorgaenge/zeitstrahl'
|
||||
import { formatDatum } from '@/lib/utils'
|
||||
|
||||
/**
|
||||
* Die Fallakte.
|
||||
*
|
||||
* Kopf mit Status, Gegenstelle, Aktenzeichen und dem nächsten Handgriff;
|
||||
* darunter die Aufgabenliste, das Genehmigungsverfahren und der
|
||||
* Zeitstrahl, der alles zusammenführt, was in dieser Sache passiert ist.
|
||||
*/
|
||||
export default async function VorgangSeite({ params }: { params: Promise<{ id: string }> }) {
|
||||
const { id } = await params
|
||||
const benutzer = await erfordereBenutzer(`/vorgaenge/${id}`)
|
||||
const aktive = await aktiveBetreute(benutzer)
|
||||
if (!aktive) notFound()
|
||||
|
||||
const vorgang = await db.vorgang.findFirst({
|
||||
where: { id, betreuteId: aktive.id, ...nichtGeloescht },
|
||||
include: {
|
||||
aufgaben: { orderBy: [{ reihenfolge: 'asc' }, { erstelltAm: 'asc' }] },
|
||||
genehmigungen: {
|
||||
where: nichtGeloescht,
|
||||
include: { beschlussDokument: { select: { id: true, titel: true } } },
|
||||
orderBy: { erstelltAm: 'asc' },
|
||||
},
|
||||
fristen: { where: nichtGeloescht, orderBy: { datum: 'asc' } },
|
||||
buchungen: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
|
||||
kontaktprotokolle: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
|
||||
verknuepfungen: { include: { dokument: true } },
|
||||
},
|
||||
})
|
||||
if (!vorgang) notFound()
|
||||
|
||||
const { darfSchreiben } = await erfordereZugang(aktive.id, 'VORGAENGE', 'lesen')
|
||||
const schreiben = darfSchreiben('VORGAENGE')
|
||||
|
||||
const offen = oeffnen('Vorgang', vorgang)
|
||||
|
||||
// --- Statuswechsel aus dem Audit-Log --------------------------------------
|
||||
// Das Log ist ohnehin der Nachweis gegenueber dem Gericht; daraus die
|
||||
// Statuschronik zu lesen, spart eine zusaetzliche Tabelle.
|
||||
const protokolle = await db.auditLog.findMany({
|
||||
where: { entitaet: 'Vorgang', entitaetId: vorgang.id, aktion: 'GEAENDERT' },
|
||||
orderBy: { zeitpunkt: 'asc' },
|
||||
take: 200,
|
||||
})
|
||||
|
||||
const statuswechsel: ZeitstrahlStatuswechsel[] = []
|
||||
for (const eintrag of protokolle) {
|
||||
const roh = entschluesselnWennMoeglich(
|
||||
eintrag.aenderungVerschluesselt,
|
||||
'aenderungVerschluesselt',
|
||||
)
|
||||
if (!roh) continue
|
||||
try {
|
||||
const gelesen = JSON.parse(roh) as Record<string, { alt: unknown; neu: unknown }>
|
||||
const status = gelesen.status
|
||||
if (!status || typeof status.neu !== 'string') continue
|
||||
statuswechsel.push({
|
||||
id: eintrag.id,
|
||||
zeitpunkt: eintrag.zeitpunkt,
|
||||
von: typeof status.alt === 'string' ? (status.alt as VorgangStatus) : null,
|
||||
nach: status.neu as VorgangStatus,
|
||||
wer: eintrag.userName,
|
||||
})
|
||||
} catch {
|
||||
// Ein unlesbarer Protokolleintrag darf die Akte nicht blockieren.
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// --- Zeitstrahl -----------------------------------------------------------
|
||||
const zeitstrahl = zeitstrahlBauen({
|
||||
vorgang: {
|
||||
titel: vorgang.titel,
|
||||
erstelltAm: vorgang.erstelltAm,
|
||||
erledigtAm: vorgang.erledigtAm,
|
||||
},
|
||||
dokumente: vorgang.verknuepfungen
|
||||
.map((v) => v.dokument)
|
||||
.filter((d) => d.geloeschtAm === null)
|
||||
.map((d) => ({
|
||||
id: d.id,
|
||||
titel: d.titel,
|
||||
eingangAm: d.eingangAm,
|
||||
versandAm: d.versandAm,
|
||||
erstelltAm: d.erstelltAm,
|
||||
absender: d.absender,
|
||||
empfaenger: d.empfaenger,
|
||||
})),
|
||||
kontaktprotokolle: vorgang.kontaktprotokolle.map((p) => {
|
||||
const klar = oeffnen('Kontaktprotokoll', p)
|
||||
return {
|
||||
id: p.id,
|
||||
datum: p.datum,
|
||||
art: p.art,
|
||||
gespraechspartner: p.gespraechspartner,
|
||||
mitBetreuter: p.mitBetreuter,
|
||||
inhalt: klar.inhalt ?? null,
|
||||
}
|
||||
}),
|
||||
fristen: vorgang.fristen.map((f) => ({
|
||||
id: f.id,
|
||||
titel: f.titel,
|
||||
datum: f.datum,
|
||||
erledigtAm: f.erledigtAm,
|
||||
ausschlussfrist: f.ausschlussfrist,
|
||||
rechtsgrundlage: f.rechtsgrundlage,
|
||||
})),
|
||||
buchungen: vorgang.buchungen.map((b) => {
|
||||
const klar = oeffnen('Buchung', b)
|
||||
return {
|
||||
id: b.id,
|
||||
datum: b.datum,
|
||||
betragCent: centZuZahl(b.betragCent) ?? 0,
|
||||
richtung: b.richtung,
|
||||
gegenstelle: b.gegenstelle,
|
||||
verwendungszweck: klar.verwendungszweck ?? null,
|
||||
}
|
||||
}),
|
||||
genehmigungen: vorgang.genehmigungen.map((g) => ({
|
||||
id: g.id,
|
||||
titel: g.titel,
|
||||
rechtsgrundlage: g.rechtsgrundlage,
|
||||
status: g.status,
|
||||
mitteilungAm: g.mitteilungAm,
|
||||
antragAm: g.antragAm,
|
||||
anhoerungAm: g.anhoerungAm,
|
||||
beschlussAm: g.beschlussAm,
|
||||
rechtskraftAm: g.rechtskraftAm,
|
||||
vollzugAm: g.vollzugAm,
|
||||
})),
|
||||
statuswechsel,
|
||||
})
|
||||
|
||||
// --- Sachstandsanfrage ----------------------------------------------------
|
||||
// Nur, wenn tatsaechlich auf jemanden gewartet wird - sonst waere der
|
||||
// Knopf nur Zierde.
|
||||
const wartetAufDritte = vorgang.status === 'WARTET_AUF_DRITTE'
|
||||
const anfrage = wartetAufDritte
|
||||
? sachstandsanfrageErzeugen({
|
||||
vorgangTitel: vorgang.titel,
|
||||
gegenstelle: vorgang.gegenstelle,
|
||||
aktenzeichen: vorgang.aktenzeichen,
|
||||
letzterKontaktAm: vorgang.letzterKontaktAm,
|
||||
betreute: {
|
||||
vorname: aktive.vorname,
|
||||
nachname: aktive.nachname,
|
||||
geburtsdatum: aktive.geburtsdatum,
|
||||
},
|
||||
betreuer: {
|
||||
name: benutzer.name,
|
||||
aktenzeichenGericht: aktive.aktenzeichenGericht,
|
||||
betreuungsgericht: aktive.betreuungsgericht,
|
||||
},
|
||||
})
|
||||
: null
|
||||
|
||||
// Dokumente der betreuten Person - Auswahl fuer das Beschlussdokument.
|
||||
const dokumente = vorgang.genehmigungen.length
|
||||
? await db.dokument.findMany({
|
||||
where: { betreuteId: aktive.id, ...nichtGeloescht },
|
||||
select: { id: true, titel: true },
|
||||
orderBy: { erstelltAm: 'desc' },
|
||||
take: 100,
|
||||
})
|
||||
: []
|
||||
|
||||
const aufgaben: AufgabenZeile[] = vorgang.aufgaben.map((a) => ({
|
||||
id: a.id,
|
||||
titel: a.titel,
|
||||
beschreibung: a.beschreibung,
|
||||
erledigt: a.erledigt,
|
||||
faelligAm: a.faelligAm,
|
||||
}))
|
||||
|
||||
const genehmigungen: GenehmigungsAnzeige[] = vorgang.genehmigungen.map((g) => ({
|
||||
id: g.id,
|
||||
titel: g.titel,
|
||||
rechtsgrundlage: g.rechtsgrundlage,
|
||||
status: g.status,
|
||||
mitteilungAm: g.mitteilungAm,
|
||||
antragAm: g.antragAm,
|
||||
anhoerungAm: g.anhoerungAm,
|
||||
beschlussAm: g.beschlussAm,
|
||||
rechtskraftAm: g.rechtskraftAm,
|
||||
vollzugAm: g.vollzugAm,
|
||||
beschlussDokumentId: g.beschlussDokumentId,
|
||||
beschlussDokumentTitel: g.beschlussDokument?.titel ?? null,
|
||||
dokumente,
|
||||
}))
|
||||
|
||||
return (
|
||||
<div className="space-y-8">
|
||||
<SeitenKopf
|
||||
titel={vorgang.titel}
|
||||
beschreibung={offen.beschreibung ?? undefined}
|
||||
pfad={[
|
||||
{ titel: 'Start', href: '/heute' },
|
||||
{ titel: 'Vorgänge', href: '/vorgaenge' },
|
||||
{ titel: vorgang.titel },
|
||||
]}
|
||||
aktionen={
|
||||
<>
|
||||
<Button variant="ghost" asChild>
|
||||
<Link href="/vorgaenge">
|
||||
<ArrowLeft aria-hidden="true" />
|
||||
Zurück
|
||||
</Link>
|
||||
</Button>
|
||||
{anfrage && (
|
||||
<SachstandsanfrageKnopf
|
||||
vorgangId={vorgang.id}
|
||||
betreff={anfrage.betreff}
|
||||
text={anfrage.text}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
)}
|
||||
{schreiben && <VorgangLoeschen vorgangId={vorgang.id} titel={vorgang.titel} />}
|
||||
</>
|
||||
}
|
||||
/>
|
||||
|
||||
{/* --- Kopf der Akte ---------------------------------------------- */}
|
||||
<Card>
|
||||
<CardContent className="grid gap-5 p-5 sm:grid-cols-2 lg:grid-cols-3">
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Status</p>
|
||||
<p className="font-medium">{VORGANG_STATUS_BESCHRIFTUNG[vorgang.status]}</p>
|
||||
{schreiben && (
|
||||
<StatusWechsler vorgangId={vorgang.id} status={vorgang.status} klein />
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Gegenstelle</p>
|
||||
<p className="font-medium">{vorgang.gegenstelle ?? '–'}</p>
|
||||
{vorgang.letzterKontaktAm && (
|
||||
<p className="flex items-center gap-1.5 text-sm text-muted-foreground">
|
||||
<Clock className="size-3.5" aria-hidden="true" />
|
||||
Letzter Kontakt: {formatDatum(vorgang.letzterKontaktAm)}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Aktenzeichen</p>
|
||||
<p className="font-medium">{vorgang.aktenzeichen ?? '–'}</p>
|
||||
</div>
|
||||
|
||||
<div className="space-y-1 sm:col-span-2">
|
||||
<p className="text-sm text-muted-foreground">Nächster Schritt</p>
|
||||
<p className="font-medium">
|
||||
{vorgang.naechsterSchritt ?? 'Kein offener Handgriff notiert.'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<div className="space-y-2">
|
||||
<p className="text-sm text-muted-foreground">Einordnung</p>
|
||||
<div className="flex flex-wrap gap-2">
|
||||
<Badge variant="outline">{KATEGORIE_BESCHRIFTUNG[vorgang.kategorie]}</Badge>
|
||||
<Badge variant="secondary">
|
||||
{PRIORITAET_BESCHRIFTUNG[vorgang.prioritaet] ?? 'Normal'}
|
||||
</Badge>
|
||||
<Faelligkeit datum={vorgang.faelligAm} />
|
||||
</div>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
{/* --- Aufgaben ----------------------------------------------------- */}
|
||||
<section aria-labelledby="aufgaben" className="space-y-4">
|
||||
<h2 id="aufgaben" className="text-xl font-semibold">
|
||||
Aufgaben
|
||||
</h2>
|
||||
<AufgabenListe
|
||||
vorgangId={vorgang.id}
|
||||
aufgaben={aufgaben}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
</section>
|
||||
|
||||
{/* --- Genehmigungen ------------------------------------------------ */}
|
||||
{(vorgang.genehmigungspflichtig || genehmigungen.length > 0) && (
|
||||
<section aria-labelledby="genehmigungen" className="space-y-6">
|
||||
<h2 id="genehmigungen" className="text-xl font-semibold">
|
||||
Genehmigung des Betreuungsgerichts
|
||||
</h2>
|
||||
|
||||
{genehmigungen.map((genehmigung) => (
|
||||
<GenehmigungsKette
|
||||
key={genehmigung.id}
|
||||
genehmigung={genehmigung}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
))}
|
||||
|
||||
{schreiben && genehmigungen.length === 0 && (
|
||||
<GenehmigungAnlegen vorgangId={vorgang.id} />
|
||||
)}
|
||||
</section>
|
||||
)}
|
||||
|
||||
{/* --- Zeitstrahl --------------------------------------------------- */}
|
||||
<section aria-labelledby="zeitstrahl" className="space-y-4">
|
||||
<h2 id="zeitstrahl" className="text-xl font-semibold">
|
||||
Zeitstrahl
|
||||
</h2>
|
||||
<p className="text-sm text-muted-foreground">
|
||||
Dokumente, Gespräche, Fristen, Zahlungen und Statuswechsel in einer Spalte - neueste
|
||||
zuerst.
|
||||
</p>
|
||||
<ZeitstrahlAnzeige eintraege={zeitstrahl} />
|
||||
</section>
|
||||
|
||||
{/* --- Bearbeiten --------------------------------------------------- */}
|
||||
{schreiben && (
|
||||
<section aria-labelledby="bearbeiten" className="space-y-4">
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle id="bearbeiten">Angaben bearbeiten</CardTitle>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<VorgangsFormular
|
||||
modus="aendern"
|
||||
betreuteId={aktive.id}
|
||||
vorgangId={vorgang.id}
|
||||
abbrechenHref={`/vorgaenge/${vorgang.id}`}
|
||||
werte={{
|
||||
titel: vorgang.titel,
|
||||
kategorie: vorgang.kategorie,
|
||||
status: vorgang.status,
|
||||
prioritaet: vorgang.prioritaet,
|
||||
beschreibung: offen.beschreibung ?? null,
|
||||
gegenstelle: vorgang.gegenstelle,
|
||||
aktenzeichen: vorgang.aktenzeichen,
|
||||
verantwortlich: vorgang.verantwortlich,
|
||||
naechsterSchritt: vorgang.naechsterSchritt,
|
||||
faelligAm: vorgang.faelligAm,
|
||||
letzterKontaktAm: vorgang.letzterKontaktAm,
|
||||
genehmigungspflichtig: vorgang.genehmigungspflichtig,
|
||||
}}
|
||||
/>
|
||||
</CardContent>
|
||||
</Card>
|
||||
</section>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
import { notFound } from 'next/navigation'
|
||||
import Link from 'next/link'
|
||||
import { ArrowLeft, FileDown, Clock } from 'lucide-react'
|
||||
import type { VorgangStatus } from '@prisma/client'
|
||||
import { Badge } from '@/components/ui/badge'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { AufgabenListe, type AufgabenZeile } from '@/components/vorgaenge/aufgaben-liste'
|
||||
import { Faelligkeit } from '@/components/vorgaenge/faelligkeit'
|
||||
import { GenehmigungAnlegen } from '@/components/vorgaenge/genehmigung-anlegen'
|
||||
import {
|
||||
GenehmigungsKette,
|
||||
type GenehmigungsAnzeige,
|
||||
} from '@/components/vorgaenge/genehmigungs-kette'
|
||||
import { SachstandsanfrageKnopf } from '@/components/vorgaenge/sachstandsanfrage-knopf'
|
||||
import { StatusWechsler } from '@/components/vorgaenge/status-wechsler'
|
||||
import { VorgangLoeschen } from '@/components/vorgaenge/vorgang-loeschen'
|
||||
import { VorgangsFormular } from '@/components/vorgaenge/vorgangs-formular'
|
||||
import { ZeitstrahlAnzeige } from '@/components/vorgaenge/zeitstrahl-anzeige'
|
||||
import { aktiveBetreute, erfordereBenutzer, erfordereZugang } from '@/lib/auth/sitzung'
|
||||
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
|
||||
import { entschluesselnWennMoeglich, oeffnen } from '@/lib/crypto/feld'
|
||||
import { KATEGORIE_BESCHRIFTUNG, PRIORITAET_BESCHRIFTUNG } from '@/lib/validierung/vorgaenge'
|
||||
import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
|
||||
import {
|
||||
VORGANG_STATUS_BESCHRIFTUNG,
|
||||
zeitstrahlBauen,
|
||||
type ZeitstrahlStatuswechsel,
|
||||
} from '@/lib/vorgaenge/zeitstrahl'
|
||||
import { formatDatum } from '@/lib/utils'
|
||||
|
||||
/**
|
||||
* Die Fallakte.
|
||||
*
|
||||
* Kopf mit Status, Gegenstelle, Aktenzeichen und dem nächsten Handgriff;
|
||||
* darunter die Aufgabenliste, das Genehmigungsverfahren und der
|
||||
* Zeitstrahl, der alles zusammenführt, was in dieser Sache passiert ist.
|
||||
*/
|
||||
export default async function VorgangSeite({ params }: { params: Promise<{ id: string }> }) {
|
||||
const { id } = await params
|
||||
const benutzer = await erfordereBenutzer(`/vorgaenge/${id}`)
|
||||
const aktive = await aktiveBetreute(benutzer)
|
||||
if (!aktive) notFound()
|
||||
|
||||
const vorgang = await db.vorgang.findFirst({
|
||||
where: { id, betreuteId: aktive.id, ...nichtGeloescht },
|
||||
include: {
|
||||
aufgaben: { orderBy: [{ reihenfolge: 'asc' }, { erstelltAm: 'asc' }] },
|
||||
genehmigungen: {
|
||||
where: nichtGeloescht,
|
||||
include: { beschlussDokument: { select: { id: true, titel: true } } },
|
||||
orderBy: { erstelltAm: 'asc' },
|
||||
},
|
||||
fristen: { where: nichtGeloescht, orderBy: { datum: 'asc' } },
|
||||
buchungen: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
|
||||
kontaktprotokolle: { where: nichtGeloescht, orderBy: { datum: 'desc' } },
|
||||
verknuepfungen: { include: { dokument: true } },
|
||||
},
|
||||
})
|
||||
if (!vorgang) notFound()
|
||||
|
||||
const { darfSchreiben } = await erfordereZugang(aktive.id, 'VORGAENGE', 'lesen')
|
||||
const schreiben = darfSchreiben('VORGAENGE')
|
||||
|
||||
const offen = oeffnen('Vorgang', vorgang)
|
||||
|
||||
// --- Statuswechsel aus dem Audit-Log --------------------------------------
|
||||
// Das Log ist ohnehin der Nachweis gegenueber dem Gericht; daraus die
|
||||
// Statuschronik zu lesen, spart eine zusaetzliche Tabelle.
|
||||
const protokolle = await db.auditLog.findMany({
|
||||
where: { entitaet: 'Vorgang', entitaetId: vorgang.id, aktion: 'GEAENDERT' },
|
||||
orderBy: { zeitpunkt: 'asc' },
|
||||
take: 200,
|
||||
})
|
||||
|
||||
const statuswechsel: ZeitstrahlStatuswechsel[] = []
|
||||
for (const eintrag of protokolle) {
|
||||
const roh = entschluesselnWennMoeglich(
|
||||
eintrag.aenderungVerschluesselt,
|
||||
'aenderungVerschluesselt',
|
||||
)
|
||||
if (!roh) continue
|
||||
try {
|
||||
const gelesen = JSON.parse(roh) as Record<string, { alt: unknown; neu: unknown }>
|
||||
const status = gelesen.status
|
||||
if (!status || typeof status.neu !== 'string') continue
|
||||
statuswechsel.push({
|
||||
id: eintrag.id,
|
||||
zeitpunkt: eintrag.zeitpunkt,
|
||||
von: typeof status.alt === 'string' ? (status.alt as VorgangStatus) : null,
|
||||
nach: status.neu as VorgangStatus,
|
||||
wer: eintrag.userName,
|
||||
})
|
||||
} catch {
|
||||
// Ein unlesbarer Protokolleintrag darf die Akte nicht blockieren.
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// --- Zeitstrahl -----------------------------------------------------------
|
||||
const zeitstrahl = zeitstrahlBauen({
|
||||
vorgang: {
|
||||
titel: vorgang.titel,
|
||||
erstelltAm: vorgang.erstelltAm,
|
||||
erledigtAm: vorgang.erledigtAm,
|
||||
},
|
||||
dokumente: vorgang.verknuepfungen
|
||||
.map((v) => v.dokument)
|
||||
.filter((d) => d.geloeschtAm === null)
|
||||
.map((d) => ({
|
||||
id: d.id,
|
||||
titel: d.titel,
|
||||
eingangAm: d.eingangAm,
|
||||
versandAm: d.versandAm,
|
||||
erstelltAm: d.erstelltAm,
|
||||
absender: d.absender,
|
||||
empfaenger: d.empfaenger,
|
||||
})),
|
||||
kontaktprotokolle: vorgang.kontaktprotokolle.map((p) => {
|
||||
const klar = oeffnen('Kontaktprotokoll', p)
|
||||
return {
|
||||
id: p.id,
|
||||
datum: p.datum,
|
||||
art: p.art,
|
||||
gespraechspartner: p.gespraechspartner,
|
||||
mitBetreuter: p.mitBetreuter,
|
||||
inhalt: klar.inhalt ?? null,
|
||||
}
|
||||
}),
|
||||
fristen: vorgang.fristen.map((f) => ({
|
||||
id: f.id,
|
||||
titel: f.titel,
|
||||
datum: f.datum,
|
||||
erledigtAm: f.erledigtAm,
|
||||
ausschlussfrist: f.ausschlussfrist,
|
||||
rechtsgrundlage: f.rechtsgrundlage,
|
||||
})),
|
||||
buchungen: vorgang.buchungen.map((b) => {
|
||||
const klar = oeffnen('Buchung', b)
|
||||
return {
|
||||
id: b.id,
|
||||
datum: b.datum,
|
||||
betragCent: centZuZahl(b.betragCent) ?? 0,
|
||||
richtung: b.richtung,
|
||||
gegenstelle: b.gegenstelle,
|
||||
verwendungszweck: klar.verwendungszweck ?? null,
|
||||
}
|
||||
}),
|
||||
genehmigungen: vorgang.genehmigungen.map((g) => ({
|
||||
id: g.id,
|
||||
titel: g.titel,
|
||||
rechtsgrundlage: g.rechtsgrundlage,
|
||||
status: g.status,
|
||||
mitteilungAm: g.mitteilungAm,
|
||||
antragAm: g.antragAm,
|
||||
anhoerungAm: g.anhoerungAm,
|
||||
beschlussAm: g.beschlussAm,
|
||||
rechtskraftAm: g.rechtskraftAm,
|
||||
vollzugAm: g.vollzugAm,
|
||||
})),
|
||||
statuswechsel,
|
||||
})
|
||||
|
||||
// --- Sachstandsanfrage ----------------------------------------------------
|
||||
// Nur, wenn tatsaechlich auf jemanden gewartet wird - sonst waere der
|
||||
// Knopf nur Zierde.
|
||||
const wartetAufDritte = vorgang.status === 'WARTET_AUF_DRITTE'
|
||||
const anfrage = wartetAufDritte
|
||||
? sachstandsanfrageErzeugen({
|
||||
vorgangTitel: vorgang.titel,
|
||||
gegenstelle: vorgang.gegenstelle,
|
||||
aktenzeichen: vorgang.aktenzeichen,
|
||||
letzterKontaktAm: vorgang.letzterKontaktAm,
|
||||
betreute: {
|
||||
vorname: aktive.vorname,
|
||||
nachname: aktive.nachname,
|
||||
geburtsdatum: aktive.geburtsdatum,
|
||||
},
|
||||
betreuer: {
|
||||
name: benutzer.name,
|
||||
aktenzeichenGericht: aktive.aktenzeichenGericht,
|
||||
betreuungsgericht: aktive.betreuungsgericht,
|
||||
},
|
||||
})
|
||||
: null
|
||||
|
||||
// Dokumente der betreuten Person - Auswahl fuer das Beschlussdokument.
|
||||
const dokumente = vorgang.genehmigungen.length
|
||||
? await db.dokument.findMany({
|
||||
where: { betreuteId: aktive.id, ...nichtGeloescht },
|
||||
select: { id: true, titel: true },
|
||||
orderBy: { erstelltAm: 'desc' },
|
||||
take: 100,
|
||||
})
|
||||
: []
|
||||
|
||||
const aufgaben: AufgabenZeile[] = vorgang.aufgaben.map((a) => ({
|
||||
id: a.id,
|
||||
titel: a.titel,
|
||||
beschreibung: a.beschreibung,
|
||||
erledigt: a.erledigt,
|
||||
faelligAm: a.faelligAm,
|
||||
}))
|
||||
|
||||
const genehmigungen: GenehmigungsAnzeige[] = vorgang.genehmigungen.map((g) => ({
|
||||
id: g.id,
|
||||
titel: g.titel,
|
||||
rechtsgrundlage: g.rechtsgrundlage,
|
||||
status: g.status,
|
||||
mitteilungAm: g.mitteilungAm,
|
||||
antragAm: g.antragAm,
|
||||
anhoerungAm: g.anhoerungAm,
|
||||
beschlussAm: g.beschlussAm,
|
||||
rechtskraftAm: g.rechtskraftAm,
|
||||
vollzugAm: g.vollzugAm,
|
||||
beschlussDokumentId: g.beschlussDokumentId,
|
||||
beschlussDokumentTitel: g.beschlussDokument?.titel ?? null,
|
||||
dokumente,
|
||||
}))
|
||||
|
||||
return (
|
||||
<div className="space-y-8">
|
||||
<SeitenKopf
|
||||
titel={vorgang.titel}
|
||||
beschreibung={offen.beschreibung ?? undefined}
|
||||
pfad={[
|
||||
{ titel: 'Start', href: '/heute' },
|
||||
{ titel: 'Vorgänge', href: '/vorgaenge' },
|
||||
{ titel: vorgang.titel },
|
||||
]}
|
||||
aktionen={
|
||||
<>
|
||||
<Button variant="ghost" asChild>
|
||||
<Link href="/vorgaenge">
|
||||
<ArrowLeft aria-hidden="true" />
|
||||
Zurück
|
||||
</Link>
|
||||
</Button>
|
||||
{anfrage && (
|
||||
<SachstandsanfrageKnopf
|
||||
vorgangId={vorgang.id}
|
||||
betreff={anfrage.betreff}
|
||||
text={anfrage.text}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
)}
|
||||
{schreiben && (
|
||||
<Button asChild variant="outline">
|
||||
<Link href={`/schreiben/neu?art=SACHSTAND&vorgangId=${vorgang.id}`}>
|
||||
<FileDown aria-hidden="true" />
|
||||
Als Word-Datei und in die Akte
|
||||
</Link>
|
||||
</Button>
|
||||
)}
|
||||
{schreiben && <VorgangLoeschen vorgangId={vorgang.id} titel={vorgang.titel} />}
|
||||
</>
|
||||
}
|
||||
/>
|
||||
|
||||
{/* --- Kopf der Akte ---------------------------------------------- */}
|
||||
<Card>
|
||||
<CardContent className="grid gap-5 p-5 sm:grid-cols-2 lg:grid-cols-3">
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Status</p>
|
||||
<p className="font-medium">{VORGANG_STATUS_BESCHRIFTUNG[vorgang.status]}</p>
|
||||
{schreiben && (
|
||||
<StatusWechsler vorgangId={vorgang.id} status={vorgang.status} klein />
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Gegenstelle</p>
|
||||
<p className="font-medium">{vorgang.gegenstelle ?? '–'}</p>
|
||||
{vorgang.letzterKontaktAm && (
|
||||
<p className="flex items-center gap-1.5 text-sm text-muted-foreground">
|
||||
<Clock className="size-3.5" aria-hidden="true" />
|
||||
Letzter Kontakt: {formatDatum(vorgang.letzterKontaktAm)}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="space-y-1">
|
||||
<p className="text-sm text-muted-foreground">Aktenzeichen</p>
|
||||
<p className="font-medium">{vorgang.aktenzeichen ?? '–'}</p>
|
||||
</div>
|
||||
|
||||
<div className="space-y-1 sm:col-span-2">
|
||||
<p className="text-sm text-muted-foreground">Nächster Schritt</p>
|
||||
<p className="font-medium">
|
||||
{vorgang.naechsterSchritt ?? 'Kein offener Handgriff notiert.'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<div className="space-y-2">
|
||||
<p className="text-sm text-muted-foreground">Einordnung</p>
|
||||
<div className="flex flex-wrap gap-2">
|
||||
<Badge variant="outline">{KATEGORIE_BESCHRIFTUNG[vorgang.kategorie]}</Badge>
|
||||
<Badge variant="secondary">
|
||||
{PRIORITAET_BESCHRIFTUNG[vorgang.prioritaet] ?? 'Normal'}
|
||||
</Badge>
|
||||
<Faelligkeit datum={vorgang.faelligAm} />
|
||||
</div>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
{/* --- Aufgaben ----------------------------------------------------- */}
|
||||
<section aria-labelledby="aufgaben" className="space-y-4">
|
||||
<h2 id="aufgaben" className="text-xl font-semibold">
|
||||
Aufgaben
|
||||
</h2>
|
||||
<AufgabenListe
|
||||
vorgangId={vorgang.id}
|
||||
aufgaben={aufgaben}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
</section>
|
||||
|
||||
{/* --- Genehmigungen ------------------------------------------------ */}
|
||||
{(vorgang.genehmigungspflichtig || genehmigungen.length > 0) && (
|
||||
<section aria-labelledby="genehmigungen" className="space-y-6">
|
||||
<h2 id="genehmigungen" className="text-xl font-semibold">
|
||||
Genehmigung des Betreuungsgerichts
|
||||
</h2>
|
||||
|
||||
{genehmigungen.map((genehmigung) => (
|
||||
<GenehmigungsKette
|
||||
key={genehmigung.id}
|
||||
genehmigung={genehmigung}
|
||||
darfSchreiben={schreiben}
|
||||
/>
|
||||
))}
|
||||
|
||||
{schreiben && genehmigungen.length === 0 && (
|
||||
<GenehmigungAnlegen vorgangId={vorgang.id} />
|
||||
)}
|
||||
</section>
|
||||
)}
|
||||
|
||||
{/* --- Zeitstrahl --------------------------------------------------- */}
|
||||
<section aria-labelledby="zeitstrahl" className="space-y-4">
|
||||
<h2 id="zeitstrahl" className="text-xl font-semibold">
|
||||
Zeitstrahl
|
||||
</h2>
|
||||
<p className="text-sm text-muted-foreground">
|
||||
Dokumente, Gespräche, Fristen, Zahlungen und Statuswechsel in einer Spalte - neueste
|
||||
zuerst.
|
||||
</p>
|
||||
<ZeitstrahlAnzeige eintraege={zeitstrahl} />
|
||||
</section>
|
||||
|
||||
{/* --- Bearbeiten --------------------------------------------------- */}
|
||||
{schreiben && (
|
||||
<section aria-labelledby="bearbeiten" className="space-y-4">
|
||||
<Card>
|
||||
<CardHeader>
|
||||
<CardTitle id="bearbeiten">Angaben bearbeiten</CardTitle>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<VorgangsFormular
|
||||
modus="aendern"
|
||||
betreuteId={aktive.id}
|
||||
vorgangId={vorgang.id}
|
||||
abbrechenHref={`/vorgaenge/${vorgang.id}`}
|
||||
werte={{
|
||||
titel: vorgang.titel,
|
||||
kategorie: vorgang.kategorie,
|
||||
status: vorgang.status,
|
||||
prioritaet: vorgang.prioritaet,
|
||||
beschreibung: offen.beschreibung ?? null,
|
||||
gegenstelle: vorgang.gegenstelle,
|
||||
aktenzeichen: vorgang.aktenzeichen,
|
||||
verantwortlich: vorgang.verantwortlich,
|
||||
naechsterSchritt: vorgang.naechsterSchritt,
|
||||
faelligAm: vorgang.faelligAm,
|
||||
letzterKontaktAm: vorgang.letzterKontaktAm,
|
||||
genehmigungspflichtig: vorgang.genehmigungspflichtig,
|
||||
}}
|
||||
/>
|
||||
</CardContent>
|
||||
</Card>
|
||||
</section>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,356 @@
|
||||
'use client'
|
||||
|
||||
import * as React from 'react'
|
||||
import { useActionState } from 'react'
|
||||
import Link from 'next/link'
|
||||
import {
|
||||
AlertCircle,
|
||||
CheckCircle2,
|
||||
Copy,
|
||||
FileDown,
|
||||
FolderInput,
|
||||
Info,
|
||||
UserPlus,
|
||||
} from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { Input } from '@/components/ui/input'
|
||||
import { Textarea } from '@/components/ui/textarea'
|
||||
import { Select } from '@/components/ui/select'
|
||||
import { Feld } from '@/components/feld'
|
||||
import { Absendeknopf } from '@/components/finanzen/eingaben'
|
||||
import {
|
||||
kontaktAusAnschrift,
|
||||
schreibenAblegen,
|
||||
type SchreibenZustand,
|
||||
} from '@/server/actions/schreiben'
|
||||
import type { SchreibenArt } from '@/lib/schreiben/arten'
|
||||
|
||||
export type KontaktAuswahl = {
|
||||
id: string
|
||||
name: string
|
||||
organisation: string | null
|
||||
strasse: string | null
|
||||
plz: string | null
|
||||
ort: string | null
|
||||
}
|
||||
|
||||
/**
|
||||
* Schreiben bearbeiten, herunterladen, ablegen.
|
||||
*
|
||||
* Der Text steht in einem gewöhnlichen Textfeld und ist vollständig
|
||||
* bearbeitbar. Das ist Absicht: Jeder Fall hat eine Besonderheit, die in
|
||||
* den Brief gehört. Ein Formulartext, den man nicht mehr ändern kann,
|
||||
* wird früher oder später falsch abgeschickt.
|
||||
*/
|
||||
export function SchreibenEditor({
|
||||
betreuteId,
|
||||
art,
|
||||
entwurf,
|
||||
kontakte,
|
||||
vertragId,
|
||||
vorgangId,
|
||||
fristBegruendung,
|
||||
warnungen,
|
||||
}: {
|
||||
betreuteId: string
|
||||
art: SchreibenArt
|
||||
entwurf: { betreff: string; text: string; empfaengerName: string; wiedervorlageAm: string }
|
||||
kontakte: KontaktAuswahl[]
|
||||
vertragId: string | null
|
||||
vorgangId: string | null
|
||||
fristBegruendung: string | null
|
||||
warnungen: string[]
|
||||
}) {
|
||||
const [text, setText] = React.useState(entwurf.text)
|
||||
const [betreff, setBetreff] = React.useState(entwurf.betreff)
|
||||
const [empfaengerName, setEmpfaengerName] = React.useState(entwurf.empfaengerName)
|
||||
const [empfaengerAnschrift, setEmpfaengerAnschrift] = React.useState('')
|
||||
const [versandAm, setVersandAm] = React.useState(new Date().toISOString().slice(0, 10))
|
||||
const [wiedervorlageAm, setWiedervorlageAm] = React.useState(entwurf.wiedervorlageAm)
|
||||
const [kopiert, setKopiert] = React.useState(false)
|
||||
|
||||
const [ablageZustand, ablegen] = useActionState<SchreibenZustand, FormData>(
|
||||
schreibenAblegen,
|
||||
{},
|
||||
)
|
||||
const [kontaktZustand, kontaktAnlegen] = useActionState<SchreibenZustand, FormData>(
|
||||
kontaktAusAnschrift,
|
||||
{},
|
||||
)
|
||||
|
||||
/** Gemeinsame versteckte Felder für beide Formulare und den Download. */
|
||||
function VersteckteFelder() {
|
||||
return (
|
||||
<>
|
||||
<input type="hidden" name="betreuteId" value={betreuteId} />
|
||||
<input type="hidden" name="art" value={art} />
|
||||
<input type="hidden" name="betreff" value={betreff} />
|
||||
<input type="hidden" name="text" value={text} />
|
||||
<input type="hidden" name="empfaengerName" value={empfaengerName} />
|
||||
<input type="hidden" name="empfaengerAnschrift" value={empfaengerAnschrift} />
|
||||
<input type="hidden" name="versandAm" value={versandAm} />
|
||||
<input type="hidden" name="wiedervorlageAm" value={wiedervorlageAm} />
|
||||
<input type="hidden" name="vertragId" value={vertragId ?? ''} />
|
||||
<input type="hidden" name="vorgangId" value={vorgangId ?? ''} />
|
||||
</>
|
||||
)
|
||||
}
|
||||
|
||||
function kontaktUebernehmen(id: string) {
|
||||
const kontakt = kontakte.find((k) => k.id === id)
|
||||
if (!kontakt) return
|
||||
setEmpfaengerName(kontakt.organisation ?? kontakt.name)
|
||||
setEmpfaengerAnschrift(
|
||||
[kontakt.strasse, [kontakt.plz, kontakt.ort].filter(Boolean).join(' ')]
|
||||
.filter(Boolean)
|
||||
.join('\n'),
|
||||
)
|
||||
}
|
||||
|
||||
async function textKopieren() {
|
||||
try {
|
||||
await navigator.clipboard.writeText(text)
|
||||
setKopiert(true)
|
||||
window.setTimeout(() => setKopiert(false), 2500)
|
||||
} catch {
|
||||
/* Zwischenablage gesperrt - dann markiert man eben von Hand. */
|
||||
}
|
||||
}
|
||||
|
||||
const abgelegt = Boolean(ablageZustand.erfolg)
|
||||
|
||||
return (
|
||||
<div className="space-y-6">
|
||||
{warnungen.length > 0 && (
|
||||
<Alert variant="warnung">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
<p className="font-medium">Vor dem Abschicken klären:</p>
|
||||
<ul className="mt-1 list-disc space-y-1 pl-4">
|
||||
{warnungen.map((warnung) => (
|
||||
<li key={warnung}>{warnung}</li>
|
||||
))}
|
||||
</ul>
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{/* --- Empfänger ---------------------------------------------------- */}
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
<CardTitle className="text-base">An wen geht das Schreiben?</CardTitle>
|
||||
<CardDescription>
|
||||
Der Empfänger steht im Brieftext darunter — was du hier einträgst, landet am Dokument
|
||||
in der Akte und im Dateinamen.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent className="space-y-4">
|
||||
{kontakte.length > 0 && (
|
||||
<Feld
|
||||
id="kontaktAuswahl"
|
||||
beschriftung="Aus den Kontakten übernehmen"
|
||||
erklaerung="Spart das Abtippen, wenn die Stelle schon im System steht."
|
||||
>
|
||||
<Select
|
||||
id="kontaktAuswahl"
|
||||
defaultValue=""
|
||||
onChange={(ereignis) => kontaktUebernehmen(ereignis.target.value)}
|
||||
>
|
||||
<option value="">– Kontakt wählen –</option>
|
||||
{kontakte.map((kontakt) => (
|
||||
<option key={kontakt.id} value={kontakt.id}>
|
||||
{kontakt.organisation ?? kontakt.name}
|
||||
{kontakt.ort ? ` · ${kontakt.ort}` : ''}
|
||||
</option>
|
||||
))}
|
||||
</Select>
|
||||
</Feld>
|
||||
)}
|
||||
|
||||
<Feld id="empfaengerName" beschriftung="Name oder Gesellschaft" pflicht>
|
||||
<Input
|
||||
id="empfaengerName"
|
||||
value={empfaengerName}
|
||||
onChange={(ereignis) => setEmpfaengerName(ereignis.target.value)}
|
||||
maxLength={200}
|
||||
placeholder="z. B. Allianz Lebensversicherungs-AG"
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
<Feld
|
||||
id="empfaengerAnschrift"
|
||||
beschriftung="Anschrift"
|
||||
erklaerung="Straße, dann PLZ und Ort — je Zeile eine Angabe. Nur nötig, wenn du daraus einen Kontakt anlegen willst; in den Brieftext trägst du sie unten selbst ein."
|
||||
>
|
||||
<Textarea
|
||||
id="empfaengerAnschrift"
|
||||
value={empfaengerAnschrift}
|
||||
onChange={(ereignis) => setEmpfaengerAnschrift(ereignis.target.value)}
|
||||
rows={3}
|
||||
maxLength={500}
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
{empfaengerName.trim() !== '' && empfaengerAnschrift.trim() !== '' && (
|
||||
<form action={kontaktAnlegen}>
|
||||
<VersteckteFelder />
|
||||
{kontaktZustand.fehler && (
|
||||
<Alert variant="fehler" className="mb-2">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{kontaktZustand.fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
{kontaktZustand.erfolg && (
|
||||
<Alert variant="erfolg" className="mb-2">
|
||||
<CheckCircle2 aria-hidden="true" />
|
||||
<AlertDescription>{kontaktZustand.erfolg}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
<Absendeknopf variant="outline" size="sm" wartetext="Wird angelegt …">
|
||||
<UserPlus aria-hidden="true" />
|
||||
Als Kontakt merken
|
||||
</Absendeknopf>
|
||||
</form>
|
||||
)}
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
{/* --- Der Brief ---------------------------------------------------- */}
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
<CardTitle className="text-base">Der Brief</CardTitle>
|
||||
<CardDescription>
|
||||
Vollständig bearbeitbar. Was hier steht, steht auch in der Word-Datei und in der
|
||||
Fassung für die Akte.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent className="space-y-4">
|
||||
<Feld
|
||||
id="betreff"
|
||||
beschriftung="Betreff"
|
||||
erklaerung="Wird zum Titel des Dokuments in der Akte."
|
||||
pflicht
|
||||
>
|
||||
<Input
|
||||
id="betreff"
|
||||
value={betreff}
|
||||
onChange={(ereignis) => setBetreff(ereignis.target.value)}
|
||||
maxLength={200}
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
<Feld id="text" beschriftung="Brieftext" pflicht>
|
||||
<Textarea
|
||||
id="text"
|
||||
value={text}
|
||||
onChange={(ereignis) => setText(ereignis.target.value)}
|
||||
rows={26}
|
||||
className="font-mono text-sm leading-relaxed"
|
||||
spellCheck
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
<Button type="button" variant="ghost" size="sm" onClick={() => void textKopieren()}>
|
||||
<Copy aria-hidden="true" />
|
||||
{kopiert ? 'Kopiert' : 'Text kopieren'}
|
||||
</Button>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
{/* --- Ausgabe ------------------------------------------------------ */}
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
<CardTitle className="text-base">Und jetzt?</CardTitle>
|
||||
</CardHeader>
|
||||
<CardContent className="space-y-5">
|
||||
<div className="grid gap-4 sm:grid-cols-2">
|
||||
<Feld
|
||||
id="versandAm"
|
||||
beschriftung="Versandt am"
|
||||
erklaerung="Steht am Dokument in der Akte."
|
||||
>
|
||||
<Input
|
||||
id="versandAm"
|
||||
type="date"
|
||||
value={versandAm}
|
||||
onChange={(ereignis) => setVersandAm(ereignis.target.value)}
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
<Feld
|
||||
id="wiedervorlageAm"
|
||||
beschriftung="Wiedervorlage am"
|
||||
erklaerung={fristBegruendung ?? 'Leer lassen, wenn du keine Antwort erwartest.'}
|
||||
>
|
||||
<Input
|
||||
id="wiedervorlageAm"
|
||||
type="date"
|
||||
value={wiedervorlageAm}
|
||||
onChange={(ereignis) => setWiedervorlageAm(ereignis.target.value)}
|
||||
/>
|
||||
</Feld>
|
||||
</div>
|
||||
|
||||
{/* Word-Datei: eigene Route, damit der Browser einen echten
|
||||
Download bekommt. */}
|
||||
<form action="/schreiben/docx" method="post" className="inline">
|
||||
<VersteckteFelder />
|
||||
<Button type="submit" variant="outline">
|
||||
<FileDown aria-hidden="true" />
|
||||
Als Word-Datei
|
||||
</Button>
|
||||
</form>
|
||||
|
||||
<Alert variant="hinweis">
|
||||
<Info aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
In die Akte kommt eine <strong>PDF-Fassung</strong> dieses Textes — sie ist der
|
||||
Nachweis, was hinausgegangen ist, und lässt sich nicht mehr ändern. Die Word-Datei
|
||||
ist die Arbeitsfassung zum Ausdrucken und Unterschreiben.{' '}
|
||||
<strong>Änderst du sie danach noch in Word</strong>, weicht die Akte davon ab — dann
|
||||
lieber erst dort fertig schreiben, den Text hierher zurückkopieren und dann ablegen.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
|
||||
{ablageZustand.fehler && (
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{ablageZustand.fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{abgelegt && (
|
||||
<Alert variant="erfolg">
|
||||
<CheckCircle2 aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
<p className="font-medium">{ablageZustand.erfolg}</p>
|
||||
{ablageZustand.meldung && (
|
||||
<ul className="mt-1 list-disc space-y-1 pl-4">
|
||||
{ablageZustand.meldung.map((zeile) => (
|
||||
<li key={zeile}>{zeile}</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
<p className="mt-2">
|
||||
<Link href="/dokumente?richtung=AUSGANG" className="underline">
|
||||
Zu den ausgehenden Dokumenten
|
||||
</Link>
|
||||
</p>
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
<form action={ablegen}>
|
||||
<VersteckteFelder />
|
||||
<Absendeknopf disabled={abgelegt} wartetext="Wird abgelegt …">
|
||||
<FolderInput aria-hidden="true" />
|
||||
{abgelegt ? 'Liegt in der Akte' : 'In die Akte legen'}
|
||||
</Absendeknopf>
|
||||
</form>
|
||||
</CardContent>
|
||||
</Card>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,7 +1,8 @@
|
||||
'use client'
|
||||
|
||||
import Link from 'next/link'
|
||||
import { useActionState } from 'react'
|
||||
import { CheckCircle2, FileWarning, Gavel, Scale, TriangleAlert } from 'lucide-react'
|
||||
import { CheckCircle2, FileDown, FileWarning, Gavel, Scale, TriangleAlert } from 'lucide-react'
|
||||
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { Checkbox } from '@/components/ui/checkbox'
|
||||
@@ -10,6 +11,7 @@ import { Select } from '@/components/ui/select'
|
||||
import { Textarea } from '@/components/ui/textarea'
|
||||
import { Feld } from '@/components/feld'
|
||||
import { Rechtshinweis } from '@/components/rechtshinweis'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Absendeknopf, Textbaustein, Zustandsmeldung } from '@/components/substanz-formular'
|
||||
import { kuendigungVermerken } from '@/server/actions/vertraege'
|
||||
import { formatDatum } from '@/lib/utils'
|
||||
@@ -161,6 +163,15 @@ export function KuendigungsAssistent({
|
||||
beschriftung="Kündigungsschreiben"
|
||||
hoehe="min-h-[36rem]"
|
||||
/>
|
||||
|
||||
<div className="mt-4">
|
||||
<Button asChild variant="outline">
|
||||
<Link href={`/schreiben/neu?art=KUENDIGUNG&vertragId=${vertragId}`}>
|
||||
<FileDown aria-hidden="true" />
|
||||
Bearbeiten, als Word-Datei und in die Akte
|
||||
</Link>
|
||||
</Button>
|
||||
</div>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
'use client'
|
||||
|
||||
import Link from 'next/link'
|
||||
import { useActionState, useState } from 'react'
|
||||
import { Coins, Mail, Plus } from 'lucide-react'
|
||||
import { Coins, FileDown, Mail, Plus } from 'lucide-react'
|
||||
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
@@ -149,6 +150,15 @@ export function Rueckkaufswert({
|
||||
hoehe="min-h-[32rem]"
|
||||
/>
|
||||
|
||||
{/* Der Weg, der nicht beim Kopieren endet: bearbeiten,
|
||||
Word-Datei, Ablage in der Akte, Wiedervorlage. */}
|
||||
<Button asChild variant="outline">
|
||||
<Link href={`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`}>
|
||||
<FileDown aria-hidden="true" />
|
||||
Bearbeiten, als Word-Datei und in die Akte
|
||||
</Link>
|
||||
</Button>
|
||||
|
||||
<form action={anfrageAktion} className="space-y-4" noValidate>
|
||||
<input type="hidden" name="betreuteId" value={betreuteId} />
|
||||
<input type="hidden" name="vertragId" value={vertragId} />
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
/**
|
||||
* Die Arten von Schreiben, die die Anwendung erzeugen kann.
|
||||
*
|
||||
* Rein und ohne Datenbank - der Entwurfstext entsteht anderswo
|
||||
* (src/lib/schreiben/entwurf.ts), hier steht nur, was eine Art ausmacht.
|
||||
*
|
||||
* Warum ueberhaupt eine Aufzaehlung? Damit die Wiedervorlagefrist,
|
||||
* die Beschriftung und der Dokumenttitel an EINER Stelle stehen. Vorher
|
||||
* lagen sie verstreut: 28 Tage in rueckkaufswert.ts, 42 in
|
||||
* sachstandsanfrage.ts, die Beschriftungen jeweils in der Seite.
|
||||
*/
|
||||
|
||||
export type SchreibenArt = 'RUECKKAUFSWERT' | 'KUENDIGUNG' | 'SACHSTAND' | 'FREI'
|
||||
|
||||
export const SCHREIBEN_ARTEN: readonly SchreibenArt[] = [
|
||||
'RUECKKAUFSWERT',
|
||||
'KUENDIGUNG',
|
||||
'SACHSTAND',
|
||||
'FREI',
|
||||
]
|
||||
|
||||
export type SchreibenEigenschaften = {
|
||||
beschriftung: string
|
||||
/**
|
||||
* Vorgeschlagene Wiedervorlage in Tagen.
|
||||
*
|
||||
* null heisst: keine vorschlagen. Bei einem freien Schreiben weiss
|
||||
* niemand, ob und wann eine Antwort kommt - eine erfundene Frist waere
|
||||
* schlechter als keine.
|
||||
*/
|
||||
wiedervorlageTage: number | null
|
||||
/** Woran haengt das Schreiben? Bestimmt, was die Seite laden muss. */
|
||||
bezug: 'VERTRAG' | 'VORGANG' | 'KEINER'
|
||||
/** Kurze Erklaerung, warum die Frist so lang ist. */
|
||||
fristBegruendung: string | null
|
||||
}
|
||||
|
||||
export const SCHREIBEN_EIGENSCHAFTEN: Record<SchreibenArt, SchreibenEigenschaften> = {
|
||||
RUECKKAUFSWERT: {
|
||||
beschriftung: 'Auskunft über Rückkaufswert',
|
||||
// Dieselbe Zahl wie RUECKKAUFSWERT_WIEDERVORLAGE_TAGE - dort steht sie
|
||||
// fuer die Anzeige am Vertrag, hier fuer die erzeugte Frist. Ein Test
|
||||
// haelt beide zusammen.
|
||||
wiedervorlageTage: 28,
|
||||
bezug: 'VERTRAG',
|
||||
fristBegruendung:
|
||||
'Vier Wochen sind bei Versicherern die übliche Bearbeitungszeit. Kommt bis dahin ' +
|
||||
'nichts, lohnt das Nachfassen.',
|
||||
},
|
||||
KUENDIGUNG: {
|
||||
beschriftung: 'Kündigung',
|
||||
// Kuerzer als beim Rueckkaufswert: Eine Kuendigung muss bestaetigt
|
||||
// werden, und ohne Bestaetigung ist nicht belegt, dass sie ankam.
|
||||
wiedervorlageTage: 21,
|
||||
bezug: 'VERTRAG',
|
||||
fristBegruendung:
|
||||
'Drei Wochen. Eine Kündigung ohne schriftliche Bestätigung ist nicht nachgewiesen — ' +
|
||||
'und wenn sie untergegangen ist, läuft die Frist weiter.',
|
||||
},
|
||||
SACHSTAND: {
|
||||
beschriftung: 'Sachstandsanfrage',
|
||||
wiedervorlageTage: 42,
|
||||
bezug: 'VORGANG',
|
||||
fristBegruendung:
|
||||
'Sechs Wochen. Behörden brauchen länger als Versicherer; früher nachzufassen bringt ' +
|
||||
'meist nur die Antwort, dass es noch dauert.',
|
||||
},
|
||||
FREI: {
|
||||
beschriftung: 'Freies Schreiben',
|
||||
wiedervorlageTage: null,
|
||||
bezug: 'KEINER',
|
||||
fristBegruendung: null,
|
||||
},
|
||||
}
|
||||
|
||||
/** Ist der Wert eine bekannte Art? Fuer Parameter aus der Adresszeile. */
|
||||
export function istSchreibenArt(wert: string | null | undefined): wert is SchreibenArt {
|
||||
return typeof wert === 'string' && (SCHREIBEN_ARTEN as readonly string[]).includes(wert)
|
||||
}
|
||||
|
||||
/**
|
||||
* Dateiname fuer die Word-Datei und die Ablage.
|
||||
*
|
||||
* Sprechend, sortierbar, ohne Zeichen, die ein Dateisystem nicht mag:
|
||||
* "2026-08-23_Kuendigung_Allianz.docx"
|
||||
*/
|
||||
export function dateinameFuerSchreiben(
|
||||
art: SchreibenArt,
|
||||
empfaenger: string | null,
|
||||
datum: Date,
|
||||
endung: 'docx' | 'pdf',
|
||||
): string {
|
||||
const tag = datum.toISOString().slice(0, 10)
|
||||
|
||||
const sauber = (text: string) =>
|
||||
text
|
||||
.replace(/ä/g, 'ae')
|
||||
.replace(/ö/g, 'oe')
|
||||
.replace(/ü/g, 'ue')
|
||||
.replace(/Ä/g, 'Ae')
|
||||
.replace(/Ö/g, 'Oe')
|
||||
.replace(/Ü/g, 'Ue')
|
||||
.replace(/ß/g, 'ss')
|
||||
.replace(/[^A-Za-z0-9]+/g, '-')
|
||||
.replace(/^-+|-+$/g, '')
|
||||
.slice(0, 40)
|
||||
|
||||
const teile = [tag, sauber(SCHREIBEN_EIGENSCHAFTEN[art].beschriftung)]
|
||||
const ziel = empfaenger ? sauber(empfaenger) : ''
|
||||
if (ziel) teile.push(ziel)
|
||||
|
||||
return `${teile.join('_')}.${endung}`
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
import 'server-only'
|
||||
import {
|
||||
AlignmentType,
|
||||
Document,
|
||||
Packer,
|
||||
Paragraph,
|
||||
TextRun,
|
||||
convertMillimetersToTwip,
|
||||
} from 'docx'
|
||||
|
||||
/**
|
||||
* Ein Brief als Word-Datei.
|
||||
*
|
||||
* Getrennt von src/lib/berichte/docx.ts, und das ist Absicht. Der dortige
|
||||
* Satz baut einen BERICHT: Titel, Kopfzeilen mit betreuter Person,
|
||||
* Aktenzeichen und Berichtszeitraum, am Ende ein Unterschriftenblock. Ein
|
||||
* Brief braucht etwas anderes - Absender, Anschriftenfeld, Datumszeile
|
||||
* rechts, Betreff, Anrede, Grussformel. Beides in eine Funktion zu zwingen
|
||||
* haette beide Ausgaben schlechter gemacht.
|
||||
*
|
||||
* Warum ueberhaupt .docx und nicht nur PDF? Weil jeder Fall eine
|
||||
* Besonderheit hat, die in den Brief gehoert. Wer das Schreiben vor dem
|
||||
* Absenden noch anfassen will, braucht eine Datei, die sich anfassen
|
||||
* laesst. Die Fassung fuer die Akte ist ein PDF - siehe
|
||||
* src/lib/schreiben/pdf.tsx.
|
||||
*
|
||||
* Das Layout folgt DIN 5008 lose: Anschriftenfeld oben links, Datum
|
||||
* rechts, Betreff fett. Nicht auf den Millimeter - der Brief geht in einen
|
||||
* gewoehnlichen Umschlag, nicht in ein Fensterkuvert der Behoerde.
|
||||
*/
|
||||
|
||||
const SCHRIFT = 'Arial'
|
||||
const GROESSE = 11
|
||||
|
||||
/**
|
||||
* Der Entwurfstext kommt als eine Zeichenkette mit Zeilenumbruechen.
|
||||
*
|
||||
* Er ist bereits vollstaendig gesetzt: Absender, Anschrift, Datum,
|
||||
* Betreff, Anrede, Text, Gruss. Diese Funktion formatiert ihn nur - sie
|
||||
* denkt sich nichts dazu und laesst nichts weg. Was der Benutzer im
|
||||
* Browser gesehen hat, steht auch in der Datei.
|
||||
*/
|
||||
function absatz(
|
||||
text: string,
|
||||
optionen: { fett?: boolean; rechts?: boolean; abstandNach?: number } = {},
|
||||
): Paragraph {
|
||||
return new Paragraph({
|
||||
alignment: optionen.rechts ? AlignmentType.RIGHT : AlignmentType.LEFT,
|
||||
spacing: { after: optionen.abstandNach ?? 0, line: 276 },
|
||||
children: [
|
||||
new TextRun({
|
||||
text,
|
||||
bold: optionen.fett ?? false,
|
||||
size: GROESSE * 2, // docx rechnet in halben Punkten
|
||||
font: SCHRIFT,
|
||||
}),
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Erkennt die Betreffzeile, damit sie fett gesetzt werden kann.
|
||||
*
|
||||
* Die erzeugten Schreiben beginnen sie mit "Betreff:" - siehe
|
||||
* betreffZeile() in src/lib/vertraege/anschreiben.ts. Steht dort einmal
|
||||
* etwas anderes, wird die Zeile eben normal gesetzt; ein Brief mit
|
||||
* unfettem Betreff ist immer noch ein brauchbarer Brief.
|
||||
*/
|
||||
function istBetreff(zeile: string): boolean {
|
||||
return /^Betreff:/i.test(zeile.trim())
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Datumszeile steht rechts, wie im deutschen Geschaeftsbrief.
|
||||
* Erkennbar daran, dass sie mit einem Ort und Komma oder direkt mit einem
|
||||
* Datum beginnt und sonst nichts enthaelt.
|
||||
*/
|
||||
function istDatumszeile(zeile: string): boolean {
|
||||
return /^([A-Za-zÄÖÜäöüß .-]+,\s*)?\d{1,2}\.\d{1,2}\.\d{4}$/.test(zeile.trim())
|
||||
}
|
||||
|
||||
export function briefAlsDocx(text: string): Document {
|
||||
const zeilen = text.split('\n')
|
||||
|
||||
const inhalt: Paragraph[] = zeilen.map((zeile) => {
|
||||
if (zeile.trim() === '') return absatz('', { abstandNach: 120 })
|
||||
if (istBetreff(zeile)) return absatz(zeile, { fett: true, abstandNach: 120 })
|
||||
if (istDatumszeile(zeile)) return absatz(zeile, { rechts: true })
|
||||
return absatz(zeile)
|
||||
})
|
||||
|
||||
return new Document({
|
||||
creator: 'Betreuungs-Cockpit',
|
||||
description: 'Schreiben aus der Betreuungsakte',
|
||||
title: 'Schreiben',
|
||||
sections: [
|
||||
{
|
||||
properties: {
|
||||
page: {
|
||||
margin: {
|
||||
top: convertMillimetersToTwip(25),
|
||||
right: convertMillimetersToTwip(20),
|
||||
// Links etwas mehr: Da wird gelocht und abgeheftet.
|
||||
left: convertMillimetersToTwip(25),
|
||||
bottom: convertMillimetersToTwip(20),
|
||||
},
|
||||
},
|
||||
},
|
||||
children: inhalt,
|
||||
},
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
/** Fertige .docx-Datei als Buffer. */
|
||||
export async function briefDocxErzeugen(text: string): Promise<Buffer> {
|
||||
return Packer.toBuffer(briefAlsDocx(text))
|
||||
}
|
||||
@@ -0,0 +1,242 @@
|
||||
import 'server-only'
|
||||
import { db, nichtGeloescht } from '@/lib/db'
|
||||
import { oeffnen } from '@/lib/crypto/feld'
|
||||
import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
|
||||
import {
|
||||
absenderBlock,
|
||||
anschriftBlock,
|
||||
betreffZeile,
|
||||
bestellungsAbsatz,
|
||||
datumsZeile,
|
||||
grussformel,
|
||||
type Briefkopf,
|
||||
type Empfaenger,
|
||||
} from '@/lib/vertraege/anschreiben'
|
||||
import { rueckkaufswertAnschreiben } from '@/lib/vertraege/rueckkaufswert'
|
||||
import { kuendigungsassistent } from '@/lib/vertraege/kuendigungsassistent'
|
||||
import { sachstandsanfrageErzeugen } from '@/lib/vorgaenge/sachstandsanfrage'
|
||||
import { laufzeitAusVertrag } from '@/lib/vertraege/kuendigung'
|
||||
import { VERTRAG_ART_BESCHRIFTUNG } from '@/lib/vertraege/konstanten'
|
||||
import { heuteAlsTag } from '@/lib/fristen/datum'
|
||||
import { SCHREIBEN_EIGENSCHAFTEN, type SchreibenArt } from '@/lib/schreiben/arten'
|
||||
|
||||
/**
|
||||
* Baut den Entwurf eines Schreibens - Text, Betreff, Empfaenger.
|
||||
*
|
||||
* Hier laufen die vorhandenen Erzeuger zusammen (Rueckkaufswert,
|
||||
* Kuendigung, Sachstandsanfrage). Sie bleiben unveraendert: Ihr Wortlaut
|
||||
* ist getestet und in der Praxis erprobt, und ihn fuer eine neue
|
||||
* Ausgabeform umzuschreiben waere ein Risiko ohne Gewinn.
|
||||
*
|
||||
* Was hier dazukommt, ist der vierte Fall: das freie Schreiben an eine
|
||||
* Stelle, zu der es noch keinen Datensatz gibt. Am Anfang einer Betreuung
|
||||
* ist das der Normalfall - man fragt ja gerade an, um zu erfahren, ob dort
|
||||
* ueberhaupt etwas besteht.
|
||||
*/
|
||||
|
||||
export type SchreibenEntwurf = {
|
||||
art: SchreibenArt
|
||||
betreff: string
|
||||
/** Vollstaendiger Brieftext, bearbeitbar. */
|
||||
text: string
|
||||
empfaengerName: string
|
||||
empfaengerAnschrift: string
|
||||
/** Vorgeschlagenes Datum der Wiedervorlage, ISO-Tag oder leer. */
|
||||
wiedervorlageAm: string
|
||||
/** Woran haengt das Schreiben? */
|
||||
vertragId: string | null
|
||||
vorgangId: string | null
|
||||
/** Was vor dem Abschicken zu klaeren ist - aus dem Kuendigungsassistenten. */
|
||||
warnungen: string[]
|
||||
}
|
||||
|
||||
function tagAlsIsoText(datum: Date): string {
|
||||
return datum.toISOString().slice(0, 10)
|
||||
}
|
||||
|
||||
function wiedervorlageVorschlag(art: SchreibenArt, heute: Date): string {
|
||||
const tage = SCHREIBEN_EIGENSCHAFTEN[art].wiedervorlageTage
|
||||
if (tage === null) return ''
|
||||
const ziel = new Date(heute)
|
||||
ziel.setUTCDate(ziel.getUTCDate() + tage)
|
||||
return tagAlsIsoText(ziel)
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Rumpf eines freien Schreibens.
|
||||
*
|
||||
* Bewusst kurz und mit sichtbaren Luecken in eckigen Klammern. Ein
|
||||
* vorformulierter Text, der fast passt, wird abgeschickt, ohne gelesen zu
|
||||
* werden; eine offensichtliche Luecke nicht.
|
||||
*
|
||||
* Der Bestellungsabsatz steht drin und nicht zur Wahl: Ohne den Nachweis
|
||||
* der Vertretungsmacht kommt die Auskunft nicht, und das faellt erst nach
|
||||
* vier Wochen auf.
|
||||
*/
|
||||
function freierEntwurf(kopf: Briefkopf, empfaenger: Empfaenger, heute: Date): string {
|
||||
return [
|
||||
absenderBlock(kopf),
|
||||
'',
|
||||
anschriftBlock(empfaenger),
|
||||
'',
|
||||
datumsZeile(kopf.betreuerOrt, heute),
|
||||
'',
|
||||
betreffZeile('[Betreff eintragen]', null, kopf.betreuteName, kopf.betreuteGeburtsdatum),
|
||||
'',
|
||||
'Sehr geehrte Damen und Herren,',
|
||||
'',
|
||||
bestellungsAbsatz(kopf),
|
||||
'',
|
||||
'[Hier steht dein Anliegen.]',
|
||||
'',
|
||||
'Für Rückfragen stehe ich gerne zur Verfügung.',
|
||||
'',
|
||||
grussformel(kopf.betreuerName),
|
||||
'',
|
||||
'Anlage: Kopie der Bestellungsurkunde',
|
||||
].join('\n')
|
||||
}
|
||||
|
||||
/** Zieht die Betreffzeile aus einem fertigen Brieftext. */
|
||||
export function betreffAusText(text: string): string {
|
||||
const zeile = text.split('\n').find((z) => /^Betreff:/i.test(z.trim()))
|
||||
return zeile ? zeile.replace(/^Betreff:\s*/i, '').trim() : ''
|
||||
}
|
||||
|
||||
export type EntwurfEingabe = {
|
||||
betreuteId: string
|
||||
benutzerName: string
|
||||
art: SchreibenArt
|
||||
vertragId?: string | null
|
||||
vorgangId?: string | null
|
||||
/** Fuer den Test ueberschreibbar. */
|
||||
heute?: Date
|
||||
}
|
||||
|
||||
export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEntwurf> {
|
||||
const heute = eingabe.heute ?? heuteAlsTag()
|
||||
|
||||
const betreute = await db.betreute.findFirst({
|
||||
where: { id: eingabe.betreuteId, ...nichtGeloescht },
|
||||
})
|
||||
if (!betreute) throw new Error('Die betreute Person gibt es nicht (mehr).')
|
||||
|
||||
const kopf = briefkopfBauen({
|
||||
betreute: oeffnen('Betreute', betreute),
|
||||
benutzer: { name: eingabe.benutzerName },
|
||||
})
|
||||
|
||||
const gemeinsam = {
|
||||
art: eingabe.art,
|
||||
wiedervorlageAm: wiedervorlageVorschlag(eingabe.art, heute),
|
||||
vertragId: eingabe.vertragId ?? null,
|
||||
vorgangId: eingabe.vorgangId ?? null,
|
||||
warnungen: [] as string[],
|
||||
}
|
||||
|
||||
// --- Vertragsbezogene Schreiben -------------------------------------------
|
||||
if (eingabe.art === 'RUECKKAUFSWERT' || eingabe.art === 'KUENDIGUNG') {
|
||||
if (!eingabe.vertragId) throw new Error('Für dieses Schreiben fehlt der Vertrag.')
|
||||
|
||||
const vertrag = await db.vertrag.findFirst({
|
||||
where: { id: eingabe.vertragId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
|
||||
})
|
||||
if (!vertrag) throw new Error('Diesen Vertrag gibt es nicht (mehr).')
|
||||
|
||||
const offen = oeffnen('Vertrag', vertrag)
|
||||
const empfaenger: Empfaenger = { gesellschaft: vertrag.gesellschaft, anschrift: null }
|
||||
const bezeichnung = `${VERTRAG_ART_BESCHRIFTUNG[vertrag.art]} — ${vertrag.bezeichnung}`
|
||||
|
||||
if (eingabe.art === 'RUECKKAUFSWERT') {
|
||||
const text = rueckkaufswertAnschreiben({
|
||||
kopf,
|
||||
empfaenger,
|
||||
vertragsbezeichnung: bezeichnung,
|
||||
vertragsnummer: offen.vertragsnummer,
|
||||
stichtag: heute,
|
||||
heute,
|
||||
})
|
||||
return {
|
||||
...gemeinsam,
|
||||
text,
|
||||
betreff: betreffAusText(text),
|
||||
empfaengerName: vertrag.gesellschaft ?? '',
|
||||
empfaengerAnschrift: '',
|
||||
}
|
||||
}
|
||||
|
||||
const paket = kuendigungsassistent({
|
||||
kopf,
|
||||
empfaenger,
|
||||
vertragsbezeichnung: bezeichnung,
|
||||
vertragsnummer: offen.vertragsnummer,
|
||||
art: vertrag.art,
|
||||
laufzeit: {
|
||||
beginnAm: vertrag.beginnAm,
|
||||
endeAm: vertrag.endeAm,
|
||||
laufzeitJahre: laufzeitAusVertrag(vertrag.beginnAm, vertrag.endeAm),
|
||||
kuendigungsfristMonate: vertrag.kuendigungsfristMonate,
|
||||
},
|
||||
kuendigungZum: vertrag.kuendigungZum,
|
||||
heute,
|
||||
})
|
||||
|
||||
return {
|
||||
...gemeinsam,
|
||||
text: paket.schreiben,
|
||||
betreff: betreffAusText(paket.schreiben),
|
||||
empfaengerName: vertrag.gesellschaft ?? '',
|
||||
empfaengerAnschrift: '',
|
||||
warnungen: paket.warnungen,
|
||||
}
|
||||
}
|
||||
|
||||
// --- Sachstandsanfrage zum Vorgang ----------------------------------------
|
||||
if (eingabe.art === 'SACHSTAND') {
|
||||
if (!eingabe.vorgangId) throw new Error('Für dieses Schreiben fehlt der Vorgang.')
|
||||
|
||||
const vorgang = await db.vorgang.findFirst({
|
||||
where: { id: eingabe.vorgangId, betreuteId: eingabe.betreuteId, ...nichtGeloescht },
|
||||
include: {
|
||||
kontakte: { select: { name: true, organisation: true }, take: 1 },
|
||||
},
|
||||
})
|
||||
if (!vorgang) throw new Error('Diesen Vorgang gibt es nicht (mehr).')
|
||||
|
||||
const anfrage = sachstandsanfrageErzeugen({
|
||||
vorgangTitel: vorgang.titel,
|
||||
gegenstelle: vorgang.gegenstelle,
|
||||
aktenzeichen: vorgang.aktenzeichen,
|
||||
letzterKontaktAm: vorgang.letzterKontaktAm,
|
||||
betreute: {
|
||||
vorname: betreute.vorname,
|
||||
nachname: betreute.nachname,
|
||||
geburtsdatum: betreute.geburtsdatum,
|
||||
},
|
||||
betreuer: {
|
||||
name: eingabe.benutzerName,
|
||||
aktenzeichenGericht: betreute.aktenzeichenGericht,
|
||||
betreuungsgericht: betreute.betreuungsgericht,
|
||||
},
|
||||
heute,
|
||||
})
|
||||
|
||||
return {
|
||||
...gemeinsam,
|
||||
text: anfrage.text,
|
||||
betreff: anfrage.betreff,
|
||||
empfaengerName: vorgang.gegenstelle ?? '',
|
||||
empfaengerAnschrift: '',
|
||||
}
|
||||
}
|
||||
|
||||
// --- Freies Schreiben ------------------------------------------------------
|
||||
const text = freierEntwurf(kopf, { gesellschaft: null, anschrift: null }, heute)
|
||||
return {
|
||||
...gemeinsam,
|
||||
text,
|
||||
betreff: '',
|
||||
empfaengerName: '',
|
||||
empfaengerAnschrift: '',
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
import 'server-only'
|
||||
import * as React from 'react'
|
||||
import { Document, Page, StyleSheet, Text, View } from '@react-pdf/renderer'
|
||||
import { fuerStandardschrift, pdfErzeugen } from '@/lib/pdf/erzeugen'
|
||||
|
||||
/**
|
||||
* Das Schreiben als PDF - die Fassung, die in die Akte geht.
|
||||
*
|
||||
* Warum PDF und nicht die Word-Datei?
|
||||
*
|
||||
* Erstens der Ablageschutz: src/lib/speicher/dateityp.ts laesst nur PDF und
|
||||
* Bilder in den Objektspeicher, und zwar nach den Magic Bytes, nicht nach
|
||||
* Endung oder gemeldetem Typ. Eine .docx ist ein ZIP-Archiv; sie
|
||||
* durchzulassen hiesse, jedes ZIP durchzulassen. Diese Pruefung ist eine
|
||||
* bewusste Zusage der Anwendung, und sie fuer eine Bequemlichkeit
|
||||
* aufzuweichen waere der falsche Handel.
|
||||
*
|
||||
* Zweitens die Sache selbst: In der Akte liegt der Nachweis, was
|
||||
* hinausgegangen ist. Dafuer ist ein Format, das sich nicht mehr aendert,
|
||||
* das richtige. Die .docx ist die Arbeitsfassung zum Ausdrucken und
|
||||
* Unterschreiben - sie liegt beim Benutzer, nicht in der Akte.
|
||||
*
|
||||
* Zu beachten: Abgelegt wird der Text, wie er beim Ablegen im Browser
|
||||
* stand. Wer die Word-Datei danach noch aendert, hat in der Akte eine
|
||||
* andere Fassung als im Briefkasten. Die Oberflaeche sagt das dazu.
|
||||
*/
|
||||
|
||||
const stile = StyleSheet.create({
|
||||
seite: {
|
||||
paddingTop: 70,
|
||||
paddingBottom: 56,
|
||||
paddingLeft: 71, // 25 mm - da wird gelocht
|
||||
paddingRight: 57,
|
||||
fontSize: 10.5,
|
||||
lineHeight: 1.45,
|
||||
fontFamily: 'Helvetica',
|
||||
color: '#111111',
|
||||
},
|
||||
zeile: { marginBottom: 0 },
|
||||
leer: { height: 9 },
|
||||
betreff: { fontFamily: 'Helvetica-Bold', marginBottom: 4 },
|
||||
datum: { textAlign: 'right' },
|
||||
fuss: {
|
||||
position: 'absolute',
|
||||
bottom: 28,
|
||||
left: 71,
|
||||
right: 57,
|
||||
fontSize: 7.5,
|
||||
color: '#777777',
|
||||
textAlign: 'center',
|
||||
},
|
||||
})
|
||||
|
||||
function istBetreff(zeile: string): boolean {
|
||||
return /^Betreff:/i.test(zeile.trim())
|
||||
}
|
||||
|
||||
function istDatumszeile(zeile: string): boolean {
|
||||
return /^([A-Za-zÄÖÜäöüß .-]+,\s*)?\d{1,2}\.\d{1,2}\.\d{4}$/.test(zeile.trim())
|
||||
}
|
||||
|
||||
export function Briefdokument({
|
||||
text,
|
||||
erzeugtAm,
|
||||
}: {
|
||||
text: string
|
||||
erzeugtAm: Date
|
||||
}): React.JSX.Element {
|
||||
const zeilen = text.split('\n')
|
||||
|
||||
return (
|
||||
<Document>
|
||||
<Page size="A4" style={stile.seite}>
|
||||
{zeilen.map((zeile, i) => {
|
||||
if (zeile.trim() === '') return <View key={i} style={stile.leer} />
|
||||
|
||||
const stil = istBetreff(zeile)
|
||||
? [stile.zeile, stile.betreff]
|
||||
: istDatumszeile(zeile)
|
||||
? [stile.zeile, stile.datum]
|
||||
: stile.zeile
|
||||
|
||||
return (
|
||||
<Text key={i} style={stil}>
|
||||
{fuerStandardschrift(zeile)}
|
||||
</Text>
|
||||
)
|
||||
})}
|
||||
|
||||
<Text style={stile.fuss} fixed>
|
||||
{fuerStandardschrift(
|
||||
`Aus dem Betreuungs-Cockpit erzeugt am ${erzeugtAm.toLocaleDateString('de-DE')}. ` +
|
||||
'Diese Fassung liegt in der Akte.',
|
||||
)}
|
||||
</Text>
|
||||
</Page>
|
||||
</Document>
|
||||
)
|
||||
}
|
||||
|
||||
/** Fertiges PDF als Buffer, fuer die Ablage im Objektspeicher. */
|
||||
export async function briefPdfErzeugen(text: string, erzeugtAm: Date): Promise<Buffer> {
|
||||
return pdfErzeugen(<Briefdokument text={text} erzeugtAm={erzeugtAm} />)
|
||||
}
|
||||
+1
-1
@@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
/** Muss zur "version" in der package.json passen. */
|
||||
export const VERSION = '1.3.0'
|
||||
export const VERSION = '1.4.0'
|
||||
|
||||
/**
|
||||
* Kurzer Git-Stand, beim Bauen hineingereicht:
|
||||
|
||||
@@ -0,0 +1,291 @@
|
||||
'use server'
|
||||
|
||||
import { revalidatePath } from 'next/cache'
|
||||
import { z } from 'zod'
|
||||
import { db, nichtGeloescht } from '@/lib/db'
|
||||
import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
|
||||
import { protokollieren } from '@/lib/audit'
|
||||
import { ablegenMitTyp } from '@/lib/speicher'
|
||||
import { heuteAlsTag } from '@/lib/fristen/datum'
|
||||
import { tagAusText } from '@/lib/finanzen/datum'
|
||||
import {
|
||||
SCHREIBEN_EIGENSCHAFTEN,
|
||||
dateinameFuerSchreiben,
|
||||
istSchreibenArt,
|
||||
type SchreibenArt,
|
||||
} from '@/lib/schreiben/arten'
|
||||
import { briefPdfErzeugen } from '@/lib/schreiben/pdf'
|
||||
|
||||
/**
|
||||
* Server Actions rund um erzeugte Schreiben.
|
||||
*
|
||||
* Der Kern ist "In die Akte legen". Bisher endete ein Schreiben beim Text
|
||||
* zum Kopieren; alles danach - ausdrucken, abschicken, als Dokument
|
||||
* nachtragen, Wiedervorlage setzen - war Handarbeit, und der letzte
|
||||
* Schritt wurde am haeufigsten vergessen. Dann fehlt der Nachweis genau
|
||||
* dort, wo er gebraucht wird: im Bericht ans Gericht.
|
||||
*
|
||||
* Hier passiert alles in einem Zug, und zwar so, dass ein Abbruch nichts
|
||||
* Halbes hinterlaesst.
|
||||
*/
|
||||
|
||||
export type SchreibenZustand = {
|
||||
fehler?: string
|
||||
erfolg?: string
|
||||
/** Kurze Aufzaehlung dessen, was angelegt wurde. */
|
||||
meldung?: string[]
|
||||
}
|
||||
|
||||
function zugriffsfehler(ausnahme: unknown): SchreibenZustand | null {
|
||||
if (ausnahme instanceof ZugriffVerweigert) return { fehler: ausnahme.message }
|
||||
return null
|
||||
}
|
||||
|
||||
const ablegenSchema = z.object({
|
||||
betreuteId: z.string().min(1),
|
||||
art: z.string().refine(istSchreibenArt, 'Unbekannte Art von Schreiben.'),
|
||||
betreff: z.string().trim().min(1, 'Bitte einen Betreff eintragen.').max(200),
|
||||
text: z.string().trim().min(30, 'Der Text ist zu kurz für ein Schreiben.').max(50_000),
|
||||
empfaengerName: z.string().trim().max(200).default(''),
|
||||
versandAm: z.string().trim().default(''),
|
||||
wiedervorlageAm: z.string().trim().default(''),
|
||||
vertragId: z.string().trim().default(''),
|
||||
vorgangId: z.string().trim().default(''),
|
||||
})
|
||||
|
||||
/**
|
||||
* Legt das Schreiben als Ausgangsdokument in die Akte und setzt die
|
||||
* Wiedervorlage.
|
||||
*
|
||||
* Reihenfolge mit Absicht: Erst die Datei in den Objektspeicher, dann der
|
||||
* Datensatz. Bricht das Ablegen ab, gibt es keinen Dokumentdatensatz, der
|
||||
* auf eine Datei zeigt, die es nicht gibt. Umgekehrt bliebe im
|
||||
* schlimmsten Fall eine verwaiste Datei liegen - die kostet Platz, aber
|
||||
* sie luegt niemanden an.
|
||||
*/
|
||||
export async function schreibenAblegen(
|
||||
_zustand: SchreibenZustand,
|
||||
daten: FormData,
|
||||
): Promise<SchreibenZustand> {
|
||||
const gelesen = ablegenSchema.safeParse({
|
||||
betreuteId: daten.get('betreuteId'),
|
||||
art: daten.get('art'),
|
||||
betreff: daten.get('betreff'),
|
||||
text: daten.get('text'),
|
||||
empfaengerName: daten.get('empfaengerName') ?? '',
|
||||
versandAm: daten.get('versandAm') ?? '',
|
||||
wiedervorlageAm: daten.get('wiedervorlageAm') ?? '',
|
||||
vertragId: daten.get('vertragId') ?? '',
|
||||
vorgangId: daten.get('vorgangId') ?? '',
|
||||
})
|
||||
|
||||
if (!gelesen.success) {
|
||||
return { fehler: gelesen.error.issues[0]?.message ?? 'Bitte prüfe deine Eingaben.' }
|
||||
}
|
||||
|
||||
const werte = gelesen.data
|
||||
const art = werte.art as SchreibenArt
|
||||
const betreuteId = werte.betreuteId
|
||||
|
||||
try {
|
||||
const { benutzer } = await erfordereZugang(betreuteId, 'DOKUMENTE', 'schreiben')
|
||||
|
||||
const versandAm = tagAusText(werte.versandAm) ?? heuteAlsTag()
|
||||
|
||||
// --- Bezuege pruefen, bevor irgendetwas geschrieben wird ---------------
|
||||
const vertrag = werte.vertragId
|
||||
? await db.vertrag.findFirst({
|
||||
where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
|
||||
select: { id: true, bezeichnung: true },
|
||||
})
|
||||
: null
|
||||
if (werte.vertragId && !vertrag) return { fehler: 'Diesen Vertrag gibt es nicht (mehr).' }
|
||||
|
||||
const vorgang = werte.vorgangId
|
||||
? await db.vorgang.findFirst({
|
||||
where: { id: werte.vorgangId, betreuteId, ...nichtGeloescht },
|
||||
select: { id: true, titel: true },
|
||||
})
|
||||
: null
|
||||
if (werte.vorgangId && !vorgang) return { fehler: 'Diesen Vorgang gibt es nicht (mehr).' }
|
||||
|
||||
// --- Datei zuerst -------------------------------------------------------
|
||||
const pdf = await briefPdfErzeugen(werte.text, versandAm)
|
||||
const dateiname = dateinameFuerSchreiben(art, werte.empfaengerName || null, versandAm, 'pdf')
|
||||
const ablage = await ablegenMitTyp(betreuteId, 'dokumente', dateiname, pdf, 'application/pdf')
|
||||
|
||||
// --- Dann der Datensatz -------------------------------------------------
|
||||
const dokument = await db.dokument.create({
|
||||
data: {
|
||||
betreuteId,
|
||||
titel: werte.betreff.slice(0, 200),
|
||||
art: 'SCHREIBEN',
|
||||
richtung: 'AUSGANG',
|
||||
schreibenVom: versandAm,
|
||||
versandAm,
|
||||
empfaenger: werte.empfaengerName || null,
|
||||
objektSchluessel: ablage.schluessel,
|
||||
dateiname: ablage.dateiname,
|
||||
mimeTyp: ablage.typ.mimeTyp,
|
||||
groesseBytes: ablage.groesseBytes,
|
||||
pruefsumme: ablage.pruefsumme,
|
||||
// Was wir selbst gesetzt haben, muss nicht erkannt werden.
|
||||
ocrStatus: 'nicht_verfuegbar',
|
||||
// Ein eigenes Schreiben gehoert nicht in den Posteingang - es ist
|
||||
// ja nichts angekommen, das noch zuzuordnen waere.
|
||||
posteingangStatus: 'ZUGEORDNET',
|
||||
...(vertrag || vorgang
|
||||
? {
|
||||
verknuepfungen: {
|
||||
create: [
|
||||
{
|
||||
betreuteId,
|
||||
...(vertrag ? { vertragId: vertrag.id } : {}),
|
||||
...(vorgang ? { vorgangId: vorgang.id } : {}),
|
||||
},
|
||||
],
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
select: { id: true, titel: true },
|
||||
})
|
||||
|
||||
const meldung = [`Als Ausgangsdokument abgelegt: „${dokument.titel}“.`]
|
||||
|
||||
// --- Wiedervorlage ------------------------------------------------------
|
||||
const wiedervorlage = tagAusText(werte.wiedervorlageAm)
|
||||
if (wiedervorlage) {
|
||||
const frist = await db.frist.create({
|
||||
data: {
|
||||
betreuteId,
|
||||
vorgangId: vorgang?.id ?? null,
|
||||
titel: `Antwort abwarten: ${werte.betreff}`.slice(0, 200),
|
||||
beschreibung:
|
||||
`Am ${versandAm.toLocaleDateString('de-DE')} verschickt` +
|
||||
(werte.empfaengerName ? ` an ${werte.empfaengerName}` : '') +
|
||||
'. Kommt bis zu diesem Tag nichts, nachfassen.',
|
||||
datum: wiedervorlage,
|
||||
typ: 'WIEDERVORLAGE',
|
||||
verknuepfungen: { create: [{ betreuteId, dokumentId: dokument.id }] },
|
||||
},
|
||||
select: { id: true },
|
||||
})
|
||||
meldung.push(
|
||||
`Wiedervorlage zum ${wiedervorlage.toLocaleDateString('de-DE')} angelegt.`,
|
||||
)
|
||||
void frist
|
||||
} else if (SCHREIBEN_EIGENSCHAFTEN[art].wiedervorlageTage !== null) {
|
||||
meldung.push('Ohne Wiedervorlage abgelegt — es erinnert dich also nichts daran.')
|
||||
}
|
||||
|
||||
// --- Beim Vorgang festhalten, dass wir gerade geschrieben haben --------
|
||||
if (vorgang) {
|
||||
await db.vorgang.update({
|
||||
where: { id: vorgang.id },
|
||||
data: { letzterKontaktAm: versandAm },
|
||||
})
|
||||
}
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'ERSTELLT',
|
||||
entitaet: 'Dokument',
|
||||
entitaetId: dokument.id,
|
||||
bezeichnung: `Schreiben ausgegangen: ${dokument.titel}`,
|
||||
betreuteId,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
})
|
||||
|
||||
revalidatePath('/dokumente')
|
||||
revalidatePath('/fristen')
|
||||
revalidatePath('/heute')
|
||||
if (vertrag) revalidatePath(`/vertraege/${vertrag.id}`)
|
||||
if (vorgang) revalidatePath(`/vorgaenge/${vorgang.id}`)
|
||||
|
||||
return { erfolg: 'Das Schreiben liegt in der Akte.', meldung }
|
||||
} catch (ausnahme) {
|
||||
const verweigert = zugriffsfehler(ausnahme)
|
||||
if (verweigert) return verweigert
|
||||
console.error('[schreiben] Ablegen fehlgeschlagen:', ausnahme)
|
||||
return { fehler: 'Das Schreiben konnte nicht abgelegt werden.' }
|
||||
}
|
||||
}
|
||||
|
||||
const kontaktSchema = z.object({
|
||||
betreuteId: z.string().min(1),
|
||||
name: z.string().trim().min(1, 'Bitte einen Namen eintragen.').max(200),
|
||||
anschrift: z.string().trim().max(500).default(''),
|
||||
})
|
||||
|
||||
/**
|
||||
* Legt aus einer frei eingegebenen Anschrift einen Kontakt an.
|
||||
*
|
||||
* Damit man dieselbe Stelle beim naechsten Mal aus der Liste waehlen kann,
|
||||
* statt sie erneut abzutippen. Genau so waechst das Adressbuch einer
|
||||
* Betreuung: nicht durch Pflege, sondern nebenbei beim Schreiben.
|
||||
*/
|
||||
export async function kontaktAusAnschrift(
|
||||
_zustand: SchreibenZustand,
|
||||
daten: FormData,
|
||||
): Promise<SchreibenZustand> {
|
||||
const gelesen = kontaktSchema.safeParse({
|
||||
betreuteId: daten.get('betreuteId'),
|
||||
name: daten.get('empfaengerName'),
|
||||
anschrift: daten.get('empfaengerAnschrift') ?? '',
|
||||
})
|
||||
|
||||
if (!gelesen.success) {
|
||||
return { fehler: gelesen.error.issues[0]?.message ?? 'Bitte prüfe deine Eingaben.' }
|
||||
}
|
||||
|
||||
const { betreuteId, name, anschrift } = gelesen.data
|
||||
|
||||
try {
|
||||
const { benutzer } = await erfordereZugang(betreuteId, 'KONTAKTE', 'schreiben')
|
||||
|
||||
// Die freie Anschrift kommt als Block; die erste Zeile ist die Strasse,
|
||||
// die zweite PLZ und Ort. Mehr wird nicht geraten - was nicht sicher
|
||||
// zuzuordnen ist, landet in den Notizen.
|
||||
const zeilen = anschrift
|
||||
.split('\n')
|
||||
.map((z) => z.trim())
|
||||
.filter(Boolean)
|
||||
const strasse = zeilen[0] ?? null
|
||||
const ortszeile = zeilen[1] ?? ''
|
||||
const treffer = ortszeile.match(/^(\d{5})\s+(.+)$/)
|
||||
|
||||
const kontakt = await db.kontakt.create({
|
||||
data: {
|
||||
betreuteId,
|
||||
name: name.slice(0, 200),
|
||||
organisation: name.slice(0, 200),
|
||||
rolle: 'SONSTIGES',
|
||||
strasse,
|
||||
plz: treffer?.[1] ?? null,
|
||||
ort: treffer?.[2] ?? (treffer ? null : ortszeile || null),
|
||||
},
|
||||
select: { id: true, name: true },
|
||||
})
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'ERSTELLT',
|
||||
entitaet: 'Kontakt',
|
||||
entitaetId: kontakt.id,
|
||||
bezeichnung: kontakt.name,
|
||||
betreuteId,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
})
|
||||
|
||||
revalidatePath('/kontakte')
|
||||
return { erfolg: `„${kontakt.name}“ steht jetzt in den Kontakten.` }
|
||||
} catch (ausnahme) {
|
||||
const verweigert = zugriffsfehler(ausnahme)
|
||||
if (verweigert) return verweigert
|
||||
console.error('[schreiben] Kontakt konnte nicht angelegt werden:', ausnahme)
|
||||
return { fehler: 'Der Kontakt konnte nicht angelegt werden.' }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user