feat: Stammdaten, Ersteinrichtung, Zweitfaktor und Protokollansicht
Damit ist Etappe 1 fachlich vollstaendig. Ersteinrichtung in drei Schritten, bewusst ausserhalb des Anwendungsrahmens: der setzt Benutzer, zweiten Faktor UND eine betreute Person voraus - beim allerersten Start gibt es nichts davon. Die Aktion fuer den ersten Zugang sperrt sich selbst, sobald ein Benutzer existiert. Zweiter Faktor: Das Geheimnis wird zuerst nur abgelegt, ohne totpAktiviertAm. Erst ein echter Code aus der App schaltet ihn scharf. Wer sich beim Abtippen vertut oder die falsche App nimmt, wuerde sich sonst dauerhaft aussperren. Erst danach gibt es die Wiederherstellungscodes - einmal angezeigt, danach nur noch als Hash. Betreuungsjahr (src/lib/stammdaten/betreuungsjahr.ts): laeuft ab dem Tag der Bestellung, nicht ab dem Kalenderjahr. Schrittweise vorwaerts gerechnet statt ueber eine Differenz, damit Schaltjahre und der 29. Februar von selbst stimmen. Daran haengen Jahresbericht, Rechnungslegung und die Ausschlussfrist der Aufwandspauschale. Aendert sich das Bestellungsdatum, werden die Pflichtfristen neu abgeleitet - ueber einen dynamischen Import, damit die Stammdaten auch dann speicherbar bleiben, wenn das Fristenmodul fehlt. Protokollansicht zeigt je Eintrag die geaenderten Felder als alt -> neu. Die Aenderungen liegen verschluesselt, weil dort Diagnosen und Kontostaende stehen koennen. Seed legt bewusst keine echten Personendaten an, nur den ersten Zugang. Mit SEED_DEMO=true kommt ein vollstaendiger Beispielfall dazu - Erika Musterfrau, COPD GOLD III, Pflegegrad 3, Heimeinzug Januar 2026, leerstehendes Haus, zwei Versicherungen, laufender Antrag beim Bezirk mit acht Nachforderungen. Nur ausserhalb der Produktion. Docker Compose ohne Reverse Proxy - der ist auf dem Zielserver vorhanden. Die Datenbank hat keine Portfreigabe und ist nur ueber das interne Netz erreichbar; die Anwendung horcht auf 127.0.0.1. Etappe: 1 Phase: Fundament
This commit is contained in:
Florian Wilde
@@ -0,0 +1,398 @@
|
||||
import { z } from 'zod'
|
||||
import { betragParsen, BetragFehler } from '@/lib/finanzen/betrag'
|
||||
import { tagAusText } from '@/lib/finanzen/datum'
|
||||
import { bicGueltig, ibanNormalisieren, ibanPruefen } from '@/lib/finanzen/iban'
|
||||
|
||||
/**
|
||||
* Eingabepruefung fuer Konten, Buchungen und Vermoegensposten.
|
||||
*
|
||||
* Alles laeuft serverseitig; das Formular im Browser ist Bequemlichkeit.
|
||||
* Betraege werden hier - und nur hier - aus Text zu Cent. Danach gibt es
|
||||
* im ganzen Modul keine Zeichenkette mehr, die Geld bedeutet.
|
||||
*/
|
||||
|
||||
const KONTO_ARTEN_WERTE = [
|
||||
'GIRO',
|
||||
'SPAR',
|
||||
'TAGESGELD',
|
||||
'FESTGELD',
|
||||
'DEPOT',
|
||||
'VERWAHRGELD_HEIM',
|
||||
'BARKASSE',
|
||||
'SONSTIGES',
|
||||
] as const
|
||||
|
||||
const RICHTUNGEN_WERTE = ['EINNAHME', 'AUSGABE', 'UMBUCHUNG'] as const
|
||||
|
||||
const KATEGORIEN_WERTE = [
|
||||
'RENTE',
|
||||
'PFLEGEKASSE',
|
||||
'SOZIALHILFE',
|
||||
'LANDESPFLEGEGELD',
|
||||
'ZINSEN',
|
||||
'MIETEINNAHME',
|
||||
'SONSTIGE_EINNAHME',
|
||||
'HEIMKOSTEN',
|
||||
'BARBETRAG',
|
||||
'BEKLEIDUNG',
|
||||
'ARZT_UND_MEDIKAMENTE',
|
||||
'ZUZAHLUNG',
|
||||
'VERSICHERUNG',
|
||||
'IMMOBILIE_BETRIEBSKOSTEN',
|
||||
'IMMOBILIE_INSTANDHALTUNG',
|
||||
'GRUNDSTEUER',
|
||||
'STEUERN',
|
||||
'GEBUEHREN_GERICHT',
|
||||
'PORTO_UND_KOPIEN',
|
||||
'FAHRTKOSTEN',
|
||||
'TELEFON_INTERNET',
|
||||
'RUNDFUNKBEITRAG',
|
||||
'BESTATTUNGSVORSORGE',
|
||||
'BANKGEBUEHREN',
|
||||
'SONSTIGE_AUSGABE',
|
||||
'UMBUCHUNG',
|
||||
] as const
|
||||
|
||||
const VERMOEGENS_ARTEN_WERTE = [
|
||||
'KONTO',
|
||||
'IMMOBILIE',
|
||||
'VERSICHERUNG',
|
||||
'FAHRZEUG',
|
||||
'WERTGEGENSTAND',
|
||||
'FORDERUNG',
|
||||
'VERBINDLICHKEIT',
|
||||
'SONSTIGES',
|
||||
] as const
|
||||
|
||||
const BEWERTUNGEN_WERTE = ['UNGEPRUEFT', 'VERWERTBAR', 'GESCHUETZT', 'STRITTIG'] as const
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Bausteine
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
const optionalerText = (max = 200) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.max(max, `Bitte höchstens ${max} Zeichen.`)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.default(null)
|
||||
|
||||
const optionaleId = z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.default(null)
|
||||
|
||||
const optionalesDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.default('')
|
||||
.transform((wert, ctx) => {
|
||||
if (wert === '') return null
|
||||
const datum = tagAusText(wert)
|
||||
if (!datum) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Bitte ein gültiges Datum wählen.' })
|
||||
return z.NEVER
|
||||
}
|
||||
return datum
|
||||
})
|
||||
|
||||
const pflichtDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert, ctx) => {
|
||||
const datum = tagAusText(wert)
|
||||
if (!datum) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Bitte ein Datum angeben.' })
|
||||
return z.NEVER
|
||||
}
|
||||
return datum
|
||||
})
|
||||
|
||||
/** Ein Formularfeld mit Geldbetrag wird hier zu Cent - und nie woanders. */
|
||||
const betragFeld = (optionen: { nurPositiv?: boolean } = {}) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert, ctx) => {
|
||||
try {
|
||||
const cent = betragParsen(wert)
|
||||
if (optionen.nurPositiv && cent <= 0n) {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
message: 'Bitte einen Betrag größer als 0,00 € angeben. Die Richtung wählst du daneben.',
|
||||
})
|
||||
return z.NEVER
|
||||
}
|
||||
return cent
|
||||
} catch (ausnahme) {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
message:
|
||||
ausnahme instanceof BetragFehler
|
||||
? ausnahme.message
|
||||
: 'Bitte einen Betrag im Format 1.234,56 angeben.',
|
||||
})
|
||||
return z.NEVER
|
||||
}
|
||||
})
|
||||
|
||||
/** Checkbox: vorhanden heisst an, fehlend heisst aus. */
|
||||
const schalter = z
|
||||
.union([z.literal('on'), z.literal('true'), z.literal('1'), z.literal(''), z.undefined()])
|
||||
.transform((wert) => wert === 'on' || wert === 'true' || wert === '1')
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Konto
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const kontoSchema = z
|
||||
.object({
|
||||
bezeichnung: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(1, 'Bitte einen Namen für das Konto angeben, z.B. „Girokonto Sparkasse“.')
|
||||
.max(120, 'Bitte höchstens 120 Zeichen.'),
|
||||
bank: optionalerText(120),
|
||||
art: z.enum(KONTO_ARTEN_WERTE, { message: 'Bitte eine Kontoart wählen.' }),
|
||||
iban: z
|
||||
.string()
|
||||
.trim()
|
||||
.default('')
|
||||
.transform((wert, ctx) => {
|
||||
if (wert === '') return null
|
||||
const pruefung = ibanPruefen(wert)
|
||||
if (!pruefung.gueltig) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: pruefung.meldung })
|
||||
return z.NEVER
|
||||
}
|
||||
return pruefung.iban
|
||||
}),
|
||||
bic: z
|
||||
.string()
|
||||
.trim()
|
||||
.default('')
|
||||
.transform((wert, ctx) => {
|
||||
if (wert === '') return null
|
||||
if (!bicGueltig(wert)) {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
message: 'Ein BIC hat 8 oder 11 Stellen, z.B. BYLADEM1SBT.',
|
||||
})
|
||||
return z.NEVER
|
||||
}
|
||||
return wert.replace(/\s+/g, '').toUpperCase()
|
||||
}),
|
||||
istBetreuerkonto: schalter,
|
||||
eroeffnetAm: optionalesDatum,
|
||||
geschlossenAm: optionalesDatum,
|
||||
})
|
||||
.superRefine((werte, ctx) => {
|
||||
if (werte.eroeffnetAm && werte.geschlossenAm && werte.geschlossenAm < werte.eroeffnetAm) {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
path: ['geschlossenAm'],
|
||||
message: 'Das Konto kann nicht vor seiner Eröffnung geschlossen worden sein.',
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
export type KontoEingabe = z.infer<typeof kontoSchema>
|
||||
|
||||
export const saldostandSchema = z.object({
|
||||
kontoId: z.string().trim().min(1, 'Bitte ein Konto wählen.'),
|
||||
stichtag: pflichtDatum,
|
||||
betrag: betragFeld(),
|
||||
quelle: optionalerText(160),
|
||||
})
|
||||
|
||||
export type SaldostandEingabe = z.infer<typeof saldostandSchema>
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Buchung
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const buchungSchema = z
|
||||
.object({
|
||||
kontoId: optionaleId,
|
||||
vorgangId: optionaleId,
|
||||
datum: pflichtDatum,
|
||||
wertstellung: optionalesDatum,
|
||||
betrag: betragFeld({ nurPositiv: true }),
|
||||
richtung: z.enum(RICHTUNGEN_WERTE, { message: 'Bitte Einnahme, Ausgabe oder Umbuchung wählen.' }),
|
||||
kategorie: z.enum(KATEGORIEN_WERTE, { message: 'Bitte eine Kategorie wählen.' }),
|
||||
gegenstelle: optionalerText(160),
|
||||
verwendungszweck: optionalerText(500),
|
||||
belegId: optionaleId,
|
||||
belegFehltBegruendung: optionalerText(300),
|
||||
betrifftBetreute: schalter,
|
||||
vermoegenswirksam: schalter,
|
||||
})
|
||||
.superRefine((werte, ctx) => {
|
||||
if (werte.richtung === 'UMBUCHUNG' && werte.kategorie !== 'UMBUCHUNG') {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
path: ['kategorie'],
|
||||
message: 'Eine Umbuchung bekommt die Kategorie „Umbuchung zwischen eigenen Konten“.',
|
||||
})
|
||||
}
|
||||
if (werte.richtung !== 'UMBUCHUNG' && werte.kategorie === 'UMBUCHUNG') {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
path: ['kategorie'],
|
||||
message: 'Die Kategorie „Umbuchung“ gehört zur Richtung Umbuchung.',
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
export type BuchungEingabeFormular = z.infer<typeof buchungSchema>
|
||||
|
||||
/** Filter der Buchungsliste - alle Felder optional, alles aus der URL. */
|
||||
export const buchungsfilterSchema = z.object({
|
||||
kontoId: optionaleId,
|
||||
kategorie: z
|
||||
.string()
|
||||
.trim()
|
||||
.default('')
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.pipe(z.enum(KATEGORIEN_WERTE).nullable()),
|
||||
richtung: z
|
||||
.string()
|
||||
.trim()
|
||||
.default('')
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.pipe(z.enum(RICHTUNGEN_WERTE).nullable()),
|
||||
von: optionalesDatum,
|
||||
bis: optionalesDatum,
|
||||
suche: optionalerText(120),
|
||||
nurOhneBeleg: schalter,
|
||||
nurEigeneAuslagen: schalter,
|
||||
})
|
||||
|
||||
export type Buchungsfilter = z.infer<typeof buchungsfilterSchema>
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Vermoegensposten und Wertstand
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const vermoegenspostenSchema = z.object({
|
||||
bezeichnung: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(1, 'Bitte den Posten benennen, z.B. „Hausgrundstück Bayreuther Str. 4“.')
|
||||
.max(160, 'Bitte höchstens 160 Zeichen.'),
|
||||
art: z.enum(VERMOEGENS_ARTEN_WERTE, { message: 'Bitte eine Art wählen.' }),
|
||||
kontoId: optionaleId,
|
||||
immobilieId: optionaleId,
|
||||
vertragId: optionaleId,
|
||||
bewertungSozialhilfe: z.enum(BEWERTUNGEN_WERTE).default('UNGEPRUEFT'),
|
||||
bewertungBegruendung: optionalerText(1000),
|
||||
notizen: optionalerText(1000),
|
||||
})
|
||||
|
||||
export type VermoegenspostenEingabe = z.infer<typeof vermoegenspostenSchema>
|
||||
|
||||
/**
|
||||
* Der Wertstand. wertquelle ist Pflicht - ohne Herkunftsangabe ist eine
|
||||
* Zahl im Vermoegensverzeichnis wertlos, weil sich beim Nachfragen nicht
|
||||
* mehr klaeren laesst, woher sie stammt.
|
||||
*/
|
||||
export const wertstandSchema = z.object({
|
||||
vermoegenspostenId: z.string().trim().min(1, 'Bitte einen Posten wählen.'),
|
||||
stichtag: pflichtDatum,
|
||||
wert: betragFeld(),
|
||||
wertquelle: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(
|
||||
3,
|
||||
'Bitte angeben, woher der Wert stammt – z.B. „Rückkaufswertmitteilung vom 12.03.2026“ oder „Bodenrichtwert“.',
|
||||
)
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.'),
|
||||
nachweisDokumentId: optionaleId,
|
||||
bemerkung: optionalerText(500),
|
||||
})
|
||||
|
||||
export type WertstandEingabeFormular = z.infer<typeof wertstandSchema>
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Berichte
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const vermoegensverzeichnisSchema = z.object({
|
||||
stichtag: pflichtDatum,
|
||||
monateRueckblick: z
|
||||
.string()
|
||||
.trim()
|
||||
.default('12')
|
||||
.transform((wert, ctx) => {
|
||||
const zahl = Number.parseInt(wert === '' ? '12' : wert, 10)
|
||||
if (!Number.isFinite(zahl) || zahl < 1 || zahl > 60) {
|
||||
ctx.addIssue({
|
||||
code: z.ZodIssueCode.custom,
|
||||
message: 'Der Rückblick für die laufenden Einnahmen liegt zwischen 1 und 60 Monaten.',
|
||||
})
|
||||
return z.NEVER
|
||||
}
|
||||
return zahl
|
||||
}),
|
||||
})
|
||||
|
||||
export const rechnungslegungSchema = z.object({
|
||||
jahr: z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert, ctx) => {
|
||||
const zahl = Number.parseInt(wert, 10)
|
||||
if (!Number.isInteger(zahl) || zahl < 1) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Bitte ein Betreuungsjahr wählen.' })
|
||||
return z.NEVER
|
||||
}
|
||||
return zahl
|
||||
}),
|
||||
variante: z.enum(['UEBERSICHT_1859', 'VOLL_1865'], {
|
||||
message: 'Bitte eine Variante wählen.',
|
||||
}),
|
||||
})
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Import
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const importSchema = z.object({
|
||||
kontoId: z.string().trim().min(1, 'Bitte das Konto wählen, zu dem die Datei gehört.'),
|
||||
betrifftBetreute: schalter,
|
||||
/** Sollen erkannte Dubletten trotzdem angelegt werden? Standard: nein. */
|
||||
dublettenUebernehmen: schalter,
|
||||
})
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Hilfen fuer die Server Actions
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/** FormData in ein einfaches Objekt - Zod erwartet keine FormData. */
|
||||
export function formularZuObjekt(daten: FormData): Record<string, string> {
|
||||
const objekt: Record<string, string> = {}
|
||||
for (const [schluessel, wert] of daten.entries()) {
|
||||
if (typeof wert === 'string') objekt[schluessel] = wert
|
||||
}
|
||||
return objekt
|
||||
}
|
||||
|
||||
/** Zod-Fehler in die Form, die <Feld fehler={...}> erwartet. */
|
||||
export function fehlerAuflisten(fehler: z.ZodError): Record<string, string> {
|
||||
const felder: Record<string, string> = {}
|
||||
for (const ausgabe of fehler.issues) {
|
||||
const feld = ausgabe.path.join('.') || 'formular'
|
||||
if (!felder[feld]) felder[feld] = ausgabe.message
|
||||
}
|
||||
return felder
|
||||
}
|
||||
|
||||
/** Fuer die Anzeige einer bereits gespeicherten IBAN im Formular. */
|
||||
export function ibanFuerFormular(iban: string | null | undefined): string {
|
||||
return ibanNormalisieren(iban)
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
import { z } from 'zod'
|
||||
import { ausIsoTag } from '@/lib/fristen/datum'
|
||||
import { rruleGueltig } from '@/lib/fristen/wiederholung'
|
||||
|
||||
/**
|
||||
* Eingabepruefung fuer Fristen.
|
||||
*
|
||||
* Die Pruefung laeuft immer serverseitig; das Formular im Browser ist nur
|
||||
* Bequemlichkeit. Alle Meldungen sagen, was zu tun ist - nicht, welche
|
||||
* Regel verletzt wurde.
|
||||
*/
|
||||
|
||||
export const FRIST_TYPEN = ['GESETZLICH', 'BEHOERDLICH', 'SELBST_GESETZT', 'WIEDERVORLAGE'] as const
|
||||
export const FRIST_STATUS = ['OFFEN', 'ERLEDIGT', 'VERSCHOBEN', 'ENTFALLEN'] as const
|
||||
|
||||
export type FristTypWert = (typeof FRIST_TYPEN)[number]
|
||||
export type FristStatusWert = (typeof FRIST_STATUS)[number]
|
||||
|
||||
export const FRIST_TYP_BESCHRIFTUNG: Record<FristTypWert, string> = {
|
||||
GESETZLICH: 'Gesetzliche Frist',
|
||||
BEHOERDLICH: 'Von Gericht oder Behörde gesetzt',
|
||||
SELBST_GESETZT: 'Selbst gesetzt',
|
||||
WIEDERVORLAGE: 'Wiedervorlage',
|
||||
}
|
||||
|
||||
export const FRIST_TYP_ERKLAERUNG: Record<FristTypWert, string> = {
|
||||
GESETZLICH: 'Steht so im Gesetz — läuft sie ab, hat das Folgen.',
|
||||
BEHOERDLICH: 'Aus einem Bescheid oder einer Verfügung, z. B. eine Widerspruchsfrist.',
|
||||
SELBST_GESETZT: 'Eigene Planung, kein Zwang von außen.',
|
||||
WIEDERVORLAGE: 'Nur eine Erinnerung, noch einmal hinzuschauen.',
|
||||
}
|
||||
|
||||
export const FRIST_STATUS_BESCHRIFTUNG: Record<FristStatusWert, string> = {
|
||||
OFFEN: 'Offen',
|
||||
ERLEDIGT: 'Erledigt',
|
||||
VERSCHOBEN: 'Verschoben',
|
||||
ENTFALLEN: 'Entfallen',
|
||||
}
|
||||
|
||||
/** Was das Formular an Vorwarnstufen anbietet. */
|
||||
export const VORWARNUNG_STUFEN = [90, 60, 30, 14, 7, 3, 1] as const
|
||||
|
||||
const pflichtDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.min(1, 'Bitte ein Datum angeben.')
|
||||
.transform((wert, ctx) => {
|
||||
const datum = ausIsoTag(wert)
|
||||
if (!datum) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Bitte ein gültiges Datum wählen.' })
|
||||
return z.NEVER
|
||||
}
|
||||
return datum
|
||||
})
|
||||
|
||||
const optionalesDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert, ctx) => {
|
||||
if (wert === '') return null
|
||||
const datum = ausIsoTag(wert)
|
||||
if (!datum) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Bitte ein gültiges Datum wählen.' })
|
||||
return z.NEVER
|
||||
}
|
||||
return datum
|
||||
})
|
||||
|
||||
const optionalerText = (max: number) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.max(max, `Bitte höchstens ${max} Zeichen.`)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
|
||||
const wiederholung = z
|
||||
.string()
|
||||
.trim()
|
||||
.max(300, 'Die Wiederholungsregel ist zu lang.')
|
||||
.transform((wert) => (wert === '' ? null : wert.toUpperCase()))
|
||||
.refine((wert) => wert === null || rruleGueltig(wert), {
|
||||
message:
|
||||
'Diese Wiederholungsregel versteht der Kalender nicht. ' +
|
||||
'Beispiel für jährlich: FREQ=YEARLY;INTERVAL=1',
|
||||
})
|
||||
|
||||
export const FristSchema = z.object({
|
||||
titel: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(3, 'Bitte gib der Frist einen Titel, an dem du sie wiedererkennst.')
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.'),
|
||||
beschreibung: optionalerText(4000),
|
||||
datum: pflichtDatum,
|
||||
typ: z.enum(FRIST_TYPEN, {
|
||||
errorMap: () => ({ message: 'Bitte eine Art der Frist wählen.' }),
|
||||
}),
|
||||
rechtsgrundlage: optionalerText(120),
|
||||
vorwarnungTage: z
|
||||
.array(z.coerce.number().int().min(0).max(400))
|
||||
.transform((werte) => [...new Set(werte.filter((w) => w > 0))].sort((a, b) => b - a))
|
||||
.default([60, 30, 7, 1]),
|
||||
wiederholungRrule: wiederholung.nullable().default(null),
|
||||
ausschlussfrist: z.coerce.boolean().default(false),
|
||||
vorgangId: optionalerText(40),
|
||||
})
|
||||
|
||||
export type FristEingabe = z.infer<typeof FristSchema>
|
||||
|
||||
export const FristVerschiebenSchema = z.object({
|
||||
datum: pflichtDatum,
|
||||
grund: optionalerText(500),
|
||||
})
|
||||
|
||||
export const FristErledigenSchema = z.object({
|
||||
erledigtAm: optionalesDatum,
|
||||
notiz: optionalerText(500),
|
||||
})
|
||||
|
||||
/**
|
||||
* Liest ein FormData-Objekt in die Struktur, die das Schema erwartet.
|
||||
* Kontrollkaestchen liefern "on" oder gar nichts, Mehrfachauswahlen
|
||||
* kommen als wiederholter Schluessel.
|
||||
*/
|
||||
export function fristFormularLesen(formular: FormData): Record<string, unknown> {
|
||||
const vorwarnung = formular.getAll('vorwarnungTage').map(String).filter(Boolean)
|
||||
|
||||
// "Eigene Regel" schlaegt die Auswahlliste - so laesst sich auch etwas
|
||||
// eintragen, das in der Liste nicht steht.
|
||||
const eigeneRegel = String(formular.get('wiederholungEigene') ?? '').trim()
|
||||
const ausListe = String(formular.get('wiederholungRrule') ?? '').trim()
|
||||
|
||||
return {
|
||||
titel: formular.get('titel') ?? '',
|
||||
beschreibung: formular.get('beschreibung') ?? '',
|
||||
datum: formular.get('datum') ?? '',
|
||||
typ: formular.get('typ') ?? 'SELBST_GESETZT',
|
||||
rechtsgrundlage: formular.get('rechtsgrundlage') ?? '',
|
||||
vorwarnungTage: vorwarnung.length > 0 ? vorwarnung : [60, 30, 7, 1],
|
||||
wiederholungRrule: eigeneRegel !== '' ? eigeneRegel : ausListe,
|
||||
ausschlussfrist: formular.get('ausschlussfrist') === 'on',
|
||||
vorgangId: formular.get('vorgangId') ?? '',
|
||||
}
|
||||
}
|
||||
|
||||
/** Rueckgabeform aller Formularaktionen, passend zu useActionState. */
|
||||
export type FristZustand = {
|
||||
fehler?: string
|
||||
hinweis?: string
|
||||
felder?: Partial<Record<keyof FristEingabe, string>>
|
||||
werte?: Record<string, string | string[]>
|
||||
}
|
||||
@@ -0,0 +1,284 @@
|
||||
import { z } from 'zod'
|
||||
import type { KontaktArt, KontaktRolle } from '@prisma/client'
|
||||
|
||||
/**
|
||||
* Eingabepruefung fuer Kontakte und Kontaktprotokolle.
|
||||
*
|
||||
* Die Pruefung laeuft immer serverseitig; das Formular im Browser ist nur
|
||||
* Bequemlichkeit. Meldungen sagen, was zu tun ist - nicht, was falsch war.
|
||||
*
|
||||
* Diese Datei kommt ohne "server-only" aus: die Beschriftungen der Rollen
|
||||
* und Kontaktarten werden auch im Browser gebraucht.
|
||||
*/
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Bausteine
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/** Leere Zeichenketten aus einem Formular werden zu null, nicht zu "". */
|
||||
const optionalerText = (max = 200) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.max(max, `Bitte höchstens ${max} Zeichen.`)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.default(null)
|
||||
|
||||
const optionaleEmail = z
|
||||
.string()
|
||||
.trim()
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.')
|
||||
.transform((wert) => (wert === '' ? null : wert.toLowerCase()))
|
||||
.nullable()
|
||||
.default(null)
|
||||
.refine((wert) => wert === null || /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(wert), {
|
||||
message: 'Bitte eine gültige E-Mail-Adresse angeben – oder das Feld leer lassen.',
|
||||
})
|
||||
|
||||
/**
|
||||
* Ein Tag aus einem HTML-Datumsfeld ("2026-08-22").
|
||||
*
|
||||
* Gespeichert wird 12:00 UTC, nicht Mitternacht: Ein Kontaktprotokoll ist
|
||||
* fachlich ein Tag, und um die Mittagszeit herum kippt keine Zeitzone der
|
||||
* Welt den Eintrag auf den Vor- oder Folgetag.
|
||||
*/
|
||||
const TAG_MUSTER = /^\d{4}-\d{2}-\d{2}$/
|
||||
|
||||
const pflichtTag = z
|
||||
.string()
|
||||
.trim()
|
||||
.min(1, 'Bitte ein Datum angeben.')
|
||||
.refine((wert) => TAG_MUSTER.test(wert), {
|
||||
message: 'Bitte ein Datum im Format TT.MM.JJJJ wählen.',
|
||||
})
|
||||
.transform((wert) => new Date(`${wert}T12:00:00.000Z`))
|
||||
.refine((datum) => !Number.isNaN(datum.getTime()), {
|
||||
message: 'Dieses Datum gibt es nicht.',
|
||||
})
|
||||
|
||||
const optionaleId = z
|
||||
.string()
|
||||
.trim()
|
||||
.max(40)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.default(null)
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Kontaktrollen
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Reihenfolge im Verzeichnis: wer im Alltag am haeufigsten gebraucht wird,
|
||||
* steht oben. Gericht und Bezirk zuerst - dort entscheidet sich das meiste.
|
||||
*/
|
||||
export const KONTAKT_ROLLEN = [
|
||||
'RECHTSPFLEGER',
|
||||
'RICHTER',
|
||||
'BETREUUNGSBEHOERDE',
|
||||
'SACHBEARBEITER_BEZIRK',
|
||||
'SACHBEARBEITER_SOZIALAMT',
|
||||
'HEIMLEITUNG',
|
||||
'PFLEGEDIENSTLEITUNG',
|
||||
'SOZIALDIENST_HEIM',
|
||||
'HAUSARZT',
|
||||
'FACHARZT',
|
||||
'KRANKENKASSE',
|
||||
'PFLEGEKASSE',
|
||||
'RENTENVERSICHERUNG',
|
||||
'NOTAR',
|
||||
'RECHTSANWALT',
|
||||
'STEUERBERATER',
|
||||
'BANK',
|
||||
'VERSICHERUNG',
|
||||
'VERSICHERUNGSMAKLER',
|
||||
'MAKLER',
|
||||
'HANDWERKER',
|
||||
'ANGEHOERIGER',
|
||||
'SONSTIGES',
|
||||
] as const satisfies readonly KontaktRolle[]
|
||||
|
||||
export const KONTAKT_ROLLE_BESCHRIFTUNG: Record<KontaktRolle, string> = {
|
||||
RECHTSPFLEGER: 'Rechtspfleger',
|
||||
RICHTER: 'Richter',
|
||||
BETREUUNGSBEHOERDE: 'Betreuungsbehörde',
|
||||
SACHBEARBEITER_BEZIRK: 'Sachbearbeiter Bezirk',
|
||||
SACHBEARBEITER_SOZIALAMT: 'Sachbearbeiter Sozialamt',
|
||||
HEIMLEITUNG: 'Heimleitung',
|
||||
PFLEGEDIENSTLEITUNG: 'Pflegedienstleitung',
|
||||
SOZIALDIENST_HEIM: 'Sozialdienst im Heim',
|
||||
HAUSARZT: 'Hausarzt',
|
||||
FACHARZT: 'Facharzt',
|
||||
KRANKENKASSE: 'Krankenkasse',
|
||||
PFLEGEKASSE: 'Pflegekasse',
|
||||
RENTENVERSICHERUNG: 'Rentenversicherung',
|
||||
NOTAR: 'Notar',
|
||||
MAKLER: 'Makler',
|
||||
VERSICHERUNGSMAKLER: 'Versicherungsmakler',
|
||||
VERSICHERUNG: 'Versicherung',
|
||||
STEUERBERATER: 'Steuerberater',
|
||||
RECHTSANWALT: 'Rechtsanwalt',
|
||||
BANK: 'Bank',
|
||||
HANDWERKER: 'Handwerker',
|
||||
ANGEHOERIGER: 'Angehöriger',
|
||||
SONSTIGES: 'Sonstiges',
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Kontaktarten
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const KONTAKT_ARTEN = [
|
||||
'BESUCH',
|
||||
'TELEFONAT',
|
||||
'EMAIL',
|
||||
'BRIEF',
|
||||
'VIDEOCALL',
|
||||
'FAX',
|
||||
'VORSPRACHE',
|
||||
] as const satisfies readonly KontaktArt[]
|
||||
|
||||
export const KONTAKT_ART_BESCHRIFTUNG: Record<KontaktArt, string> = {
|
||||
BESUCH: 'Besuch',
|
||||
TELEFONAT: 'Telefonat',
|
||||
EMAIL: 'E-Mail',
|
||||
BRIEF: 'Brief',
|
||||
VIDEOCALL: 'Videocall',
|
||||
FAX: 'Fax',
|
||||
VORSPRACHE: 'Vorsprache',
|
||||
}
|
||||
|
||||
/** Die fünf Arten, die in der Schnellerfassung als grosse Knopfreihe stehen. */
|
||||
export const KONTAKT_ARTEN_SCHNELLWAHL = [
|
||||
'BESUCH',
|
||||
'TELEFONAT',
|
||||
'EMAIL',
|
||||
'BRIEF',
|
||||
'VIDEOCALL',
|
||||
] as const satisfies readonly KontaktArt[]
|
||||
|
||||
/** Dauer-Schnellwahl in Minuten. Ein freies Feld gibt es zusaetzlich. */
|
||||
export const DAUER_SCHNELLWAHL = [15, 30, 45, 60] as const
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Kontakt
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const KontaktSchema = z.object({
|
||||
name: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(2, 'Bitte den Namen angeben – mindestens zwei Zeichen.')
|
||||
.max(150, 'Bitte höchstens 150 Zeichen.'),
|
||||
organisation: optionalerText(150),
|
||||
rolle: z.enum(KONTAKT_ROLLEN, {
|
||||
errorMap: () => ({ message: 'Bitte eine Rolle aus der Liste wählen.' }),
|
||||
}),
|
||||
telefon: optionalerText(50),
|
||||
mobil: optionalerText(50),
|
||||
fax: optionalerText(50),
|
||||
email: optionaleEmail,
|
||||
strasse: optionalerText(150),
|
||||
plz: optionalerText(10),
|
||||
ort: optionalerText(100),
|
||||
aktenzeichen: optionalerText(80),
|
||||
notizen: optionalerText(4000),
|
||||
})
|
||||
|
||||
export type KontaktEingabe = z.infer<typeof KontaktSchema>
|
||||
|
||||
/** Diese Felder wandern verschluesselt in die Datenbank. */
|
||||
export const KONTAKT_GEHEIME_FELDER = ['notizen'] as const
|
||||
|
||||
export function kontaktFormularLesen(formular: FormData): Record<string, unknown> {
|
||||
const roh: Record<string, unknown> = {}
|
||||
for (const feld of [
|
||||
'name',
|
||||
'organisation',
|
||||
'rolle',
|
||||
'telefon',
|
||||
'mobil',
|
||||
'fax',
|
||||
'email',
|
||||
'strasse',
|
||||
'plz',
|
||||
'ort',
|
||||
'aktenzeichen',
|
||||
'notizen',
|
||||
]) {
|
||||
const wert = formular.get(feld)
|
||||
if (wert !== null) roh[feld] = wert
|
||||
}
|
||||
return roh
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Kontaktprotokoll
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/** Laenger als ein voller Tag ist kein einzelner Kontakt. */
|
||||
const DAUER_MAX_MINUTEN = 1440
|
||||
|
||||
export const KontaktprotokollSchema = z.object({
|
||||
datum: pflichtTag,
|
||||
art: z.enum(KONTAKT_ARTEN, {
|
||||
errorMap: () => ({ message: 'Bitte auswählen, wie der Kontakt stattgefunden hat.' }),
|
||||
}),
|
||||
dauerMinuten: z
|
||||
.union([z.literal(''), z.coerce.number()])
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.default(null)
|
||||
.refine((wert) => wert === null || (Number.isInteger(wert) && wert > 0), {
|
||||
message: 'Bitte die Dauer in ganzen Minuten angeben.',
|
||||
})
|
||||
.refine((wert) => wert === null || wert <= DAUER_MAX_MINUTEN, {
|
||||
message: 'Mehr als 24 Stunden sind kein einzelner Kontakt – bitte aufteilen.',
|
||||
}),
|
||||
gespraechspartner: optionalerText(150),
|
||||
mitBetreuter: z.coerce.boolean().default(false),
|
||||
kontaktId: optionaleId,
|
||||
vorgangId: optionaleId,
|
||||
inhalt: optionalerText(8000),
|
||||
wuensche: optionalerText(4000),
|
||||
folgeaufgaben: optionalerText(4000),
|
||||
})
|
||||
|
||||
export type KontaktprotokollEingabe = z.infer<typeof KontaktprotokollSchema>
|
||||
|
||||
/** Diese Felder wandern verschluesselt in die Datenbank. */
|
||||
export const PROTOKOLL_GEHEIME_FELDER = ['inhalt', 'wuensche', 'folgeaufgaben'] as const
|
||||
|
||||
export function protokollFormularLesen(formular: FormData): Record<string, unknown> {
|
||||
const roh: Record<string, unknown> = {}
|
||||
for (const feld of [
|
||||
'datum',
|
||||
'art',
|
||||
'dauerMinuten',
|
||||
'gespraechspartner',
|
||||
'kontaktId',
|
||||
'vorgangId',
|
||||
'inhalt',
|
||||
'wuensche',
|
||||
'folgeaufgaben',
|
||||
]) {
|
||||
const wert = formular.get(feld)
|
||||
if (wert !== null) roh[feld] = wert
|
||||
}
|
||||
// Ein Kontrollkaestchen liefert "on" oder gar nichts.
|
||||
roh.mitBetreuter = formular.get('mitBetreuter') === 'on'
|
||||
return roh
|
||||
}
|
||||
|
||||
/**
|
||||
* Ein gespeicherter Zeitstempel zurueck in den Wert eines HTML-Datumsfelds.
|
||||
* Gegenstueck zu pflichtTag - beide rechnen in UTC, damit das Bearbeiten
|
||||
* eines Protokolls es nicht auf den Vortag schiebt.
|
||||
*/
|
||||
export function tagFuerFormular(datum: Date): string {
|
||||
const jahr = datum.getUTCFullYear()
|
||||
const monat = String(datum.getUTCMonth() + 1).padStart(2, '0')
|
||||
const tag = String(datum.getUTCDate()).padStart(2, '0')
|
||||
return `${jahr}-${monat}-${tag}`
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
import { z } from 'zod'
|
||||
import type { VorgangKategorie, VorgangStatus } from '@prisma/client'
|
||||
import { GENEHMIGUNGSKETTE, SEITENAUSGANG } from '@/lib/vorgaenge/genehmigungskette'
|
||||
import { VORLAGEN_SCHLUESSEL } from '@/lib/vorgaenge/vorlagen'
|
||||
|
||||
/**
|
||||
* Eingabeprüfung für Vorgänge, Aufgaben und Genehmigungen.
|
||||
*
|
||||
* Wie überall gilt: Die Prüfung läuft serverseitig, das Formular im
|
||||
* Browser ist nur Bequemlichkeit. Meldungen sagen, was zu tun ist.
|
||||
*/
|
||||
|
||||
/** Leere Formularfelder sollen zu null werden, nicht zu "". */
|
||||
const optionalerText = (max = 200) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.max(max, `Bitte höchstens ${max} Zeichen.`)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
|
||||
const optionalesDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.refine((wert) => wert === null || /^\d{4}-\d{2}-\d{2}$/.test(wert), {
|
||||
message: 'Bitte ein Datum im Format TT.MM.JJJJ wählen.',
|
||||
})
|
||||
// Mitternacht UTC: Faelligkeiten sind @db.Date, ohne Uhrzeit. Sonst
|
||||
// verschiebt die Zeitzone einen Termin um einen Tag.
|
||||
.transform((wert) => (wert === null ? null : new Date(`${wert}T00:00:00.000Z`)))
|
||||
|
||||
export const VORGANG_KATEGORIEN = [
|
||||
'GERICHT',
|
||||
'SOZIALHILFE',
|
||||
'IMMOBILIE',
|
||||
'VERSICHERUNG',
|
||||
'HEIM_PFLEGE',
|
||||
'VERTRAEGE',
|
||||
'STEUERN',
|
||||
'SONSTIGES',
|
||||
] as const satisfies readonly VorgangKategorie[]
|
||||
|
||||
export const VORGANG_STATUS = [
|
||||
'OFFEN',
|
||||
'IN_ARBEIT',
|
||||
'WARTET_AUF_DRITTE',
|
||||
'WARTET_AUF_GENEHMIGUNG',
|
||||
'ERLEDIGT',
|
||||
] as const satisfies readonly VorgangStatus[]
|
||||
|
||||
export const KATEGORIE_BESCHRIFTUNG: Record<VorgangKategorie, string> = {
|
||||
GERICHT: 'Betreuungsgericht',
|
||||
SOZIALHILFE: 'Sozialhilfe',
|
||||
IMMOBILIE: 'Immobilie',
|
||||
VERSICHERUNG: 'Versicherung',
|
||||
HEIM_PFLEGE: 'Heim & Pflege',
|
||||
VERTRAEGE: 'Verträge',
|
||||
STEUERN: 'Steuern',
|
||||
SONSTIGES: 'Sonstiges',
|
||||
}
|
||||
|
||||
export const PRIORITAET_BESCHRIFTUNG: Record<number, string> = {
|
||||
1: 'Hoch',
|
||||
2: 'Normal',
|
||||
3: 'Niedrig',
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Vorgang
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const VorgangSchema = z.object({
|
||||
titel: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(3, 'Bitte gib dem Vorgang einen Titel, an dem du ihn wiedererkennst.')
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.'),
|
||||
kategorie: z.enum(VORGANG_KATEGORIEN, {
|
||||
errorMap: () => ({ message: 'Bitte eine Kategorie wählen.' }),
|
||||
}),
|
||||
status: z.enum(VORGANG_STATUS).default('OFFEN'),
|
||||
prioritaet: z.coerce
|
||||
.number()
|
||||
.int()
|
||||
.min(1, 'Die Priorität liegt zwischen 1 (hoch) und 3 (niedrig).')
|
||||
.max(3, 'Die Priorität liegt zwischen 1 (hoch) und 3 (niedrig).')
|
||||
.default(2),
|
||||
beschreibung: optionalerText(4000),
|
||||
gegenstelle: optionalerText(150),
|
||||
aktenzeichen: optionalerText(80),
|
||||
verantwortlich: optionalerText(120),
|
||||
naechsterSchritt: optionalerText(300),
|
||||
faelligAm: optionalesDatum,
|
||||
letzterKontaktAm: optionalesDatum,
|
||||
genehmigungspflichtig: z.coerce.boolean().default(false),
|
||||
})
|
||||
|
||||
export type VorgangEingabe = z.infer<typeof VorgangSchema>
|
||||
|
||||
/**
|
||||
* Anlegen aus einer Vorlage. Der Schlüssel muss eine bekannte Vorlage sein
|
||||
* oder fehlen (leerer Vorgang) - erfundene Schlüssel würden sonst still
|
||||
* einen Vorgang ohne Aufgaben erzeugen.
|
||||
*/
|
||||
export const VorgangAnlegenSchema = VorgangSchema.extend({
|
||||
vorlageSchluessel: z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable()
|
||||
.refine((wert) => wert === null || VORLAGEN_SCHLUESSEL.includes(wert), {
|
||||
message: 'Diese Vorlage gibt es nicht.',
|
||||
}),
|
||||
})
|
||||
|
||||
export type VorgangAnlegenEingabe = z.infer<typeof VorgangAnlegenSchema>
|
||||
|
||||
export const VorgangStatusSchema = z.object({
|
||||
vorgangId: z.string().min(1),
|
||||
status: z.enum(VORGANG_STATUS, {
|
||||
errorMap: () => ({ message: 'Diesen Status gibt es nicht.' }),
|
||||
}),
|
||||
})
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Aufgaben
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const AufgabeSchema = z.object({
|
||||
vorgangId: z.string().min(1),
|
||||
titel: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(3, 'Bitte beschreibe den Handgriff in ein paar Worten.')
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.'),
|
||||
beschreibung: optionalerText(2000),
|
||||
faelligAm: optionalesDatum,
|
||||
})
|
||||
|
||||
export const AufgabeAbhakenSchema = z.object({
|
||||
aufgabeId: z.string().min(1),
|
||||
erledigt: z.coerce.boolean(),
|
||||
})
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Genehmigungen
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
export const GENEHMIGUNG_STATUS_WERTE = [...GENEHMIGUNGSKETTE, SEITENAUSGANG] as [
|
||||
string,
|
||||
...string[],
|
||||
]
|
||||
|
||||
export const GenehmigungSchema = z.object({
|
||||
vorgangId: z.string().min(1),
|
||||
titel: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(3, 'Bitte benenne das Geschäft, das genehmigt werden soll.')
|
||||
.max(200, 'Bitte höchstens 200 Zeichen.'),
|
||||
rechtsgrundlage: z
|
||||
.string()
|
||||
.trim()
|
||||
.min(3, 'Bitte die Vorschrift angeben, z. B. „§ 1850 BGB“.')
|
||||
.max(120, 'Bitte höchstens 120 Zeichen.'),
|
||||
notizen: optionalerText(4000),
|
||||
mitteilungAm: optionalesDatum,
|
||||
antragAm: optionalesDatum,
|
||||
anhoerungAm: optionalesDatum,
|
||||
beschlussAm: optionalesDatum,
|
||||
rechtskraftAm: optionalesDatum,
|
||||
vollzugAm: optionalesDatum,
|
||||
})
|
||||
|
||||
export type GenehmigungEingabe = z.infer<typeof GenehmigungSchema>
|
||||
|
||||
export const GenehmigungStatusSchema = z.object({
|
||||
genehmigungId: z.string().min(1),
|
||||
status: z.enum(GENEHMIGUNG_STATUS_WERTE, {
|
||||
errorMap: () => ({ message: 'Diesen Status gibt es in der Genehmigungskette nicht.' }),
|
||||
}),
|
||||
/** Datum der neuen Stufe, sonst wird das heutige gesetzt. */
|
||||
datum: optionalesDatum,
|
||||
})
|
||||
|
||||
export const GenehmigungBeschlussSchema = z.object({
|
||||
genehmigungId: z.string().min(1),
|
||||
/** Leerer Wert löst die Verknüpfung wieder. */
|
||||
dokumentId: z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.nullable(),
|
||||
})
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
/** Gemeinsamer Rückgabetyp aller Formular-Aktionen (useActionState). */
|
||||
export type Formularzustand = {
|
||||
fehler?: string
|
||||
felder?: Record<string, string>
|
||||
werte?: Record<string, string>
|
||||
/** Gesetzt, wenn alles geklappt hat - die Oberfläche kann es melden. */
|
||||
erfolg?: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Liest ein FormData-Objekt in die Struktur, die die Schemata erwarten.
|
||||
* Kontrollkästchen liefern "on" oder gar nichts.
|
||||
*/
|
||||
export function formularLesen(
|
||||
formular: FormData,
|
||||
kontrollkaestchen: string[] = [],
|
||||
): Record<string, unknown> {
|
||||
const roh: Record<string, unknown> = {}
|
||||
for (const [name, wert] of formular.entries()) {
|
||||
if (kontrollkaestchen.includes(name)) continue
|
||||
roh[name] = wert
|
||||
}
|
||||
for (const name of kontrollkaestchen) {
|
||||
roh[name] = formular.get(name) === 'on' || formular.get(name) === 'true'
|
||||
}
|
||||
return roh
|
||||
}
|
||||
|
||||
/** Zod-Fehler in die flache Feldkarte des Formularzustands übersetzen. */
|
||||
export function felderAusFehler(fehler: z.ZodError): Record<string, string> {
|
||||
const flach = fehler.flatten().fieldErrors
|
||||
const felder: Record<string, string> = {}
|
||||
for (const [name, meldungen] of Object.entries(flach)) {
|
||||
const erste = meldungen?.[0]
|
||||
if (erste) felder[name] = erste
|
||||
}
|
||||
return felder
|
||||
}
|
||||
Reference in New Issue
Block a user