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,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