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,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} />)
|
||||
}
|
||||
Reference in New Issue
Block a user