Add educator leave management and working time accounts

This commit is contained in:
t.indorf
2026-10-07 15:25:55 +02:00
parent ec3f4f933d
commit 043fed2e46
19 changed files with 5631 additions and 200 deletions
+254
View File
@@ -0,0 +1,254 @@
-- Einmalige additive Änderung gegen Ausgangscommit ec3f4f9.
-- Alternativ zum bestehenden prisma db push, nicht danach erneut ausführen.
BEGIN;
-- CreateEnum
CREATE TYPE "StaffRequestStatus" AS ENUM ('PENDING', 'APPROVED', 'REJECTED', 'CANCEL_REQUESTED', 'CANCELLED');
-- CreateEnum
CREATE TYPE "StaffLeaveKind" AS ENUM ('VACATION', 'TIME_OFF', 'SICKNESS');
-- CreateEnum
CREATE TYPE "StaffWeekStatus" AS ENUM ('DRAFT', 'SUBMITTED', 'APPROVED');
-- CreateTable
CREATE TABLE "staff_profiles" (
"id" TEXT NOT NULL,
"kitaId" TEXT NOT NULL,
"educatorId" TEXT NOT NULL,
"userId" TEXT,
"employmentStart" DATE NOT NULL,
"employmentEnd" DATE,
"trackingStart" DATE NOT NULL,
"openingMinutes" INTEGER NOT NULL DEFAULT 0,
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "staff_profiles_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_work_patterns" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"effectiveFrom" DATE NOT NULL,
"dailyMinutes" INTEGER[],
CONSTRAINT "staff_work_patterns_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_day_overrides" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"date" DATE NOT NULL,
"minutes" INTEGER NOT NULL,
"reason" TEXT NOT NULL,
CONSTRAINT "staff_day_overrides_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_holidays" (
"id" TEXT NOT NULL,
"kitaId" TEXT NOT NULL,
"date" DATE NOT NULL,
"name" TEXT NOT NULL,
CONSTRAINT "staff_holidays_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_leave_accounts" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"year" INTEGER NOT NULL,
"entitlementUnits" INTEGER NOT NULL,
"carryUnits" INTEGER NOT NULL DEFAULT 0,
CONSTRAINT "staff_leave_accounts_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_leaves" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"kind" "StaffLeaveKind" NOT NULL,
"status" "StaffRequestStatus" NOT NULL DEFAULT 'PENDING',
"startDate" DATE NOT NULL,
"endDate" DATE NOT NULL,
"halfDay" BOOLEAN NOT NULL DEFAULT false,
"minutes" INTEGER,
"note" TEXT,
"decisionNote" TEXT,
"requestedById" TEXT NOT NULL,
"reviewedById" TEXT,
"reviewedAt" TIMESTAMP(3),
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "staff_leaves_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_leave_days" (
"id" TEXT NOT NULL,
"leaveId" TEXT NOT NULL,
"date" DATE NOT NULL,
"vacationUnits" INTEGER NOT NULL DEFAULT 0,
"creditMinutes" INTEGER NOT NULL,
CONSTRAINT "staff_leave_days_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_time_entries" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"date" DATE NOT NULL,
"startMinute" INTEGER NOT NULL,
"endMinute" INTEGER NOT NULL,
"breakMinutes" INTEGER NOT NULL DEFAULT 0,
"note" TEXT,
CONSTRAINT "staff_time_entries_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_weeks" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"weekStart" DATE NOT NULL,
"status" "StaffWeekStatus" NOT NULL DEFAULT 'DRAFT',
"submittedAt" TIMESTAMP(3),
"reviewedAt" TIMESTAMP(3),
"reviewedById" TEXT,
"decisionNote" TEXT,
"dailySnapshot" JSONB,
CONSTRAINT "staff_weeks_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_adjustments" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"date" DATE NOT NULL,
"minutes" INTEGER NOT NULL,
"reason" TEXT NOT NULL,
"actorId" TEXT NOT NULL,
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "staff_adjustments_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_history" (
"id" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"actorId" TEXT NOT NULL,
"action" TEXT NOT NULL,
"details" TEXT NOT NULL,
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "staff_history_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "staff_notifications" (
"id" TEXT NOT NULL,
"userId" TEXT NOT NULL,
"profileId" TEXT NOT NULL,
"message" TEXT NOT NULL,
"readAt" TIMESTAMP(3),
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "staff_notifications_pkey" PRIMARY KEY ("id")
);
-- CreateIndex
CREATE UNIQUE INDEX "staff_profiles_educatorId_key" ON "staff_profiles"("educatorId");
-- CreateIndex
CREATE UNIQUE INDEX "staff_profiles_userId_key" ON "staff_profiles"("userId");
-- CreateIndex
CREATE INDEX "staff_profiles_kitaId_idx" ON "staff_profiles"("kitaId");
-- CreateIndex
CREATE UNIQUE INDEX "staff_work_patterns_profileId_effectiveFrom_key" ON "staff_work_patterns"("profileId", "effectiveFrom");
-- CreateIndex
CREATE UNIQUE INDEX "staff_day_overrides_profileId_date_key" ON "staff_day_overrides"("profileId", "date");
-- CreateIndex
CREATE UNIQUE INDEX "staff_holidays_kitaId_date_key" ON "staff_holidays"("kitaId", "date");
-- CreateIndex
CREATE UNIQUE INDEX "staff_leave_accounts_profileId_year_key" ON "staff_leave_accounts"("profileId", "year");
-- CreateIndex
CREATE INDEX "staff_leaves_profileId_status_startDate_idx" ON "staff_leaves"("profileId", "status", "startDate");
-- CreateIndex
CREATE UNIQUE INDEX "staff_leave_days_leaveId_date_key" ON "staff_leave_days"("leaveId", "date");
-- CreateIndex
CREATE INDEX "staff_time_entries_profileId_date_idx" ON "staff_time_entries"("profileId", "date");
-- CreateIndex
CREATE UNIQUE INDEX "staff_weeks_profileId_weekStart_key" ON "staff_weeks"("profileId", "weekStart");
-- CreateIndex
CREATE INDEX "staff_adjustments_profileId_date_idx" ON "staff_adjustments"("profileId", "date");
-- CreateIndex
CREATE INDEX "staff_history_profileId_createdAt_idx" ON "staff_history"("profileId", "createdAt");
-- CreateIndex
CREATE INDEX "staff_notifications_userId_readAt_createdAt_idx" ON "staff_notifications"("userId", "readAt", "createdAt");
-- AddForeignKey
ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_educatorId_fkey" FOREIGN KEY ("educatorId") REFERENCES "educators"("id") ON DELETE NO ACTION ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_profiles" ADD CONSTRAINT "staff_profiles_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_work_patterns" ADD CONSTRAINT "staff_work_patterns_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_day_overrides" ADD CONSTRAINT "staff_day_overrides_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_holidays" ADD CONSTRAINT "staff_holidays_kitaId_fkey" FOREIGN KEY ("kitaId") REFERENCES "kitas"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_leave_accounts" ADD CONSTRAINT "staff_leave_accounts_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_leaves" ADD CONSTRAINT "staff_leaves_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_leave_days" ADD CONSTRAINT "staff_leave_days_leaveId_fkey" FOREIGN KEY ("leaveId") REFERENCES "staff_leaves"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_time_entries" ADD CONSTRAINT "staff_time_entries_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_weeks" ADD CONSTRAINT "staff_weeks_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_adjustments" ADD CONSTRAINT "staff_adjustments_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_history" ADD CONSTRAINT "staff_history_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_notifications" ADD CONSTRAINT "staff_notifications_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "staff_notifications" ADD CONSTRAINT "staff_notifications_profileId_fkey" FOREIGN KEY ("profileId") REFERENCES "staff_profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
COMMIT;
+438
View File
@@ -0,0 +1,438 @@
# Kita-Planer – Funktionsübersicht und aktueller Stand
Stand: **07.10.2026**
Geprüfter Ausgangsbranch: `codex/notdienst-swaps`
Geprüfter Commit: `ec3f4f933d42068c9d8446dc95de9815d5779238`
Dokumentationsbranch: `codex/funktionsinventar`
**Ergänzung vom 07.10.2026:** Auf `codex/personalbereich` wurde anschließend der Personalbereich für Arbeitszeit, Urlaub und Freizeitausgleich umgesetzt. Diese Bestandsaufnahme bleibt als Beschreibung des Ausgangsstands erhalten; der neue Umfang, Berechnungsregeln, Einrichtung und aktuelle Prüfungen stehen in [PERSONALBEREICH.md](PERSONALBEREICH.md). Die Aussagen unten zu fehlender Zeiterfassung, Accountverknüpfung und Tests beziehen sich auf den Ausgangscommit.
## 1. Grundlage der Prüfung
Diese Bestandsaufnahme beschreibt die im Repository vorhandenen Produktfunktionen. Geprüft wurden Seiten und Navigation, Formulare und Dialoge, Server Actions, API-Routen, Datenmodell, E-Mail-Anbindung und Betriebsdateien. Die Planung in `planung.md`, die UI-Liste in `UI-TODO.md` und der frühere Live-Testplan wurden mit dem aktuellen Code abgeglichen.
**„Vorhanden“ bedeutet hier: Oberfläche und zugehörige Verarbeitung sind im Code angebunden. Es bedeutet keine Bestätigung durch einen aktuellen Live-Test.** Es wurden keine Produktionsdaten verändert, keine E-Mails verschickt und keine Datenbankänderungen ausgeführt. Die tatsächliche Zustellung von E-Mails, das Verhalten im Browser und die produktive Konfiguration bleiben gesondert zu prüfen.
Status:
| Kennzeichnung | Bedeutung |
| --- | --- |
| Vorhanden | Im aktuellen Code als erreichbarer Ablauf umgesetzt. |
| Teilweise | Funktion vorhanden, aber mit konkreten Einschränkungen oder fehlender Anbindung. |
| Vorbereitet | Datenmodell, Komponente oder Aktion vorhanden; vollständiger Nutzerablauf fehlt. |
| Offen | In der Planung vorgesehen, im geprüften Code nicht umgesetzt. |
## 2. Gesamtüberblick
Die Anwendung besitzt bereits eine breite MVP-Grundlage für mehrere unabhängige Kitas: Registrierung, Einrichtung, Familien und Kinder, Notdienst-Verfügbarkeiten und Planung, Diensttausch, Kalender, Mitbringlisten, Abwesenheiten, Kontaktdaten und Superadmin-Support. Einige beworbene Abläufe sind jedoch noch nicht vollständig nutzbar, insbesondere Alarmierung, Eltern-Rückmeldungen zu Events und die Anzeige des Schwarzen Bretts für Eltern.
| Bereich | Stand | Wichtigste Einschränkung |
| --- | --- | --- |
| Öffentliche Website und Kontakt | Vorhanden | Impressum und Datenschutz enthalten Platzhalter. |
| Registrierung, Login, Kita-Einrichtung | Vorhanden | Kein selbstständiger Passwort-Reset; Modulschalter wirken nur teilweise. |
| Dashboard | Vorhanden | News-, RSVP- und Alarm-Komponenten sind nicht eingebunden. |
| Profil und eigene Kinder | Vorhanden | Persönlicher Name, E-Mail und Rolle sind im Profil nur lesbar. |
| Familienverwaltung und feste Ämter | Vorhanden | Kein vollständiger Einladungs-Support mit erneutem Versand/Widerruf. |
| Notdienst-Verfügbarkeiten | Vorhanden | Wochenenden und Schließtage werden nur in der Oberfläche ausgeschlossen. |
| Notdienst-Planung | Vorhanden | Keine automatische Erinnerung und keine E-Mail bei Erstveröffentlichung. |
| Notdienst-Tausch | Vorhanden | Nur Elternrolle kann neue Tauschanfragen starten. |
| Notdienst-Alarmierung | Vorbereitet | Auslösebutton ist auf keiner Seite eingebunden. |
| Kalender und Mitbringlisten | Vorhanden | Keine Kollisionsprüfung für Raumbuchungen; Mitbringsel nicht direkt bearbeitbar. |
| Event-Teilnahme/RSVP | Teilweise | Verwaltung vorhanden, Eltern-Eingabe nicht in eine Seite eingebunden. |
| Abwesenheiten | Vorhanden | Gruppenfilter verwendet eine künstliche Zuordnung. |
| Schwarzes Brett | Teilweise | Veröffentlichung vorhanden, Elternanzeige und Lesestatus fehlen im aktuellen Dashboard. |
| Adressbuch | Vorhanden | Opt-in gilt für Kontaktdaten; weitere Haushaltsdaten bleiben sichtbar. |
| ErzieherInnen-Stammdaten | Vorhanden | Stammdatensatz und Benutzerrolle `ERZIEHER` sind getrennte Konzepte. |
| Superadmin-Verwaltung | Vorhanden | Einladungszähler verwenden ein anderes Modell als der reale Einladungsablauf. |
| Betrieb und Qualität | Teilweise | TypeScript erfolgreich, ESLint mit Fehlern; keine automatisierte Testsuite gefunden. |
## 3. Rollen und Zugriffsbereiche
| Rolle | Aktuelle Möglichkeiten |
| --- | --- |
| `SUPERADMIN` | Systemweite Kita-Übersicht, Kita-Diagnosen, Support-Aktionen und Audit-Protokoll. Standardmäßig ohne Kita-Zuordnung und mit eigener Oberfläche unter `/admin`. |
| `ADMIN` | Verwaltung der eigenen Kita: Familien, Ämter, ErzieherInnen, Dienste, Meldungen, Kalender und Notdienst. Mit eigenem Haushalt auch Elternfunktionen nutzbar. |
| `KOORDINATOR` | Notdienstplanung, Kalenderverwaltung, Event-Anmeldungen und Abwesenheitsübersicht. Mit eigenem Haushalt auch Verfügbarkeiten eintragbar. |
| `ERZIEHER` | Dashboard, Kalender, Adressbuch, Profil und Abwesenheitsübersicht. Kein Zugriff auf die Notdienst-Eingabeseite. |
| `ELTERN` | Eigener Haushalt/Kinder, Verfügbarkeiten, Kalender, Terminanfragen, Mitbringsel, Diensttausch, Abwesenheitsmeldungen und Adressbuch. |
Navigation und serverseitige Rollenprüfungen sind vorhanden. Die Rolle `ERZIEHER` existiert im Datenmodell und wird in Berechtigungen verwendet. Die ErzieherInnen-Verwaltung erstellt jedoch nur Namen als Stammdaten und keine Benutzerkonten. Ein regulärer Dialog zur Einladung von Erzieher-Accounts oder zur Vergabe von Admin-/Koordinatorrollen wurde nicht gefunden.
Quellen: [Navigation](../src/components/dashboard/sidebar-nav.tsx), [Zugriffsprüfungen](../src/lib/auth-utils.ts), [Datenmodell](../prisma/schema.prisma).
## 4. Funktionsinventar nach Bereich
### 4.1 Öffentliche Website und Kontakt
- Startseite mit Produktbeschreibung, Funktionsvorschauen, Rollenbeschreibung, Einstieg in Registrierung und Login sowie Kontaktbereich.
- Fünf öffentliche Detailseiten: Notdienst-Planer, Kita-Kalender, Eltern-Adressbuch, Krankmeldung und Schwarzes Brett.
- Kontaktformular für allgemeine Fragen, Demo-Anfragen und individuelles Setup.
- Eingaben: Name, optionale Kita, E-Mail-Adresse, Anfrageart und Nachricht.
- Versand einer Anfrage an den konfigurierten Kontakt-Empfänger und einer Bestätigung an die anfragende Person; passende Antwortadressen werden gesetzt.
- Bot-Schutz durch ein unsichtbares Zusatzfeld und ein Limit von fünf Kontaktanfragen je IP-Adresse pro Stunde. Das Limit liegt im Arbeitsspeicher des jeweiligen Prozesses.
- Sitemap, Robots-Datei und Metadaten für öffentliche Seiten.
- Optionales Umami-Tracking über Umgebungsvariablen, auf eine Liste öffentlicher Seiten beschränkt. Suchparameter und URL-Fragmente werden ausgeschlossen; Do-Not-Track wird berücksichtigt.
- Impressum und Datenschutzerklärung sind als Seiten vorhanden, enthalten aber noch Betreiber-, Hosting- und weitere Platzhalter.
Quellen: [Startseite](../src/app/page.tsx), [Feature-Inhalte](../src/lib/marketing/features.ts), [Kontaktaktion](../src/actions/contact.ts), [Analytics](../src/components/analytics/umami-analytics.tsx), [Impressum](../src/app/impressum/page.tsx), [Datenschutz](../src/app/datenschutz/page.tsx).
### 4.2 Registrierung, Anmeldung und Einrichtung
- Gründerregistrierung mit Vorname, Nachname, E-Mail-Adresse, Passwort und verpflichtender Datenschutzannahme.
- Prüfung auf bereits verwendete E-Mail-Adressen und Passwort-Hashing mit bcrypt.
- Gründer erhält zunächst die Adminrolle ohne Kita-Zuordnung und wird direkt angemeldet.
- Kita-Einrichtung mit Name, eindeutigem Slug, Aktivierung von Notdienst/Kalender/Adressbuch und Mindestzahl an Verfügbarkeiten pro Kind.
- Bei aktivem Notdienstmodul ist mindestens ein Verfügbarkeitstag erforderlich; die Einrichtung erlaubt höchstens 31.
- Kita-Anlage und Zuordnung des Gründers erfolgen in einer Datenbanktransaktion; erneute Einrichtung desselben Kontos wird abgefangen.
- Login mit E-Mail und Passwort, Rückleitung zu einer internen Zielseite und allgemeine Fehlermeldung bei falschen Zugangsdaten.
- Abmeldung über Desktop-Navigation und mobiles Menü.
- Nach zehn Fehlversuchen wird das betreffende Konto für 15 Minuten gesperrt; erfolgreicher Login setzt den Zähler zurück.
- JWT-basierte Sessions mit Benutzer-, Kita-, Familien- und Rolleninformationen. Rolle und Zuordnungen werden bei weiteren Session-Aufrufen mit der Datenbank abgeglichen.
- Geschützte Seiten leiten nicht angemeldete Personen zum Login und Gründer ohne Kita zur Einrichtung weiter.
- Datenschutzannahme wird mit Zeitpunkt und Versionskennung gespeichert. Die Sonderseite für fehlende Zustimmung verweist auf Support; sie enthält kein Formular zum Nachholen der Zustimmung.
**Einschränkungen:** Kein Passwort-vergessen-/Passwort-ändern-Ablauf. Die Gründerregistrierung setzt `emailVerifiedAt` unmittelbar, ohne Bestätigungsmail. Ein allgemeines IP-Limit für Login oder Registrierung ist nicht angebunden; das Kontaktformular hat sein eigenes Limit.
Quellen: [Registrierung](../src/app/register/actions.ts), [Einrichtung](../src/app/onboarding/actions.ts), [Login](../src/app/login/actions.ts), [Authentifizierung](../src/auth.ts), [Proxy](../src/proxy.ts), [Consent-Seite](../src/app/onboarding/consent/page.tsx).
### 4.3 Dashboard und Navigation
- Begrüßung mit Kita-Namen, Benutzernamen und aktuellem Datum.
- Kennzahlen zu Familien, aktiven Kindern, eingetragenen Notdienst-Verfügbarkeiten des Folgemonats und rechnerisch heute anwesenden Kindern.
- Direktes Melden einer Kinderabwesenheit und Übersicht der laufenden/bevorstehenden eigenen Abwesenheiten.
- Schnellzugriffe auf Familienverwaltung, Kalender, Notdienstplanung und Adressbuch. Die drei letztgenannten berücksichtigen die Modulschalter bei der Anzeige.
- Hinweisdialog bei unvollständigem Profil: Telefon, Adresse sowie gegebenenfalls Haushalt und Kinder. Fortschritt wird angezeigt; der Hinweis kann im lokalen Browser dauerhaft ausgeblendet werden.
- Rollenabhängige Seitenleiste und ein auf kleinen Bildschirmen aufklappbares Menü.
**Einschränkungen:** Die Notdienstkennzahl zählt Verfügbarkeitseinträge, keine tatsächlich besetzten Plantage. Schnellzugriffe auf Verwaltung werden nicht vollständig nach Rolle ausgeblendet; die Zielseiten besitzen Rollenprüfungen. Die Notdienst-Badge `4` in der Seitenleiste ist fest hinterlegt.
Quellen: [Dashboard](../src/app/dashboard/page.tsx), [Profilhinweis](../src/components/OnboardingDialog.tsx), [Dashboard-Rahmen](../src/components/dashboard/dashboard-shell.tsx).
### 4.4 Profil, Haushalt und eigene Kinder
- Anzeige von Name, E-Mail-Adresse, Rolle, Kita, Haushalt, angelegtem Konto und zugewiesenen festen Ämtern.
- Bearbeiten von Telefonnummer, Straße, Postleitzahl und Ort.
- Adressbuchfreigabe erteilen oder zurückziehen; Zeitpunkt der Freigabe wird gespeichert.
- Eigenen Haushalt anlegen, wenn noch keiner zugeordnet ist.
- Eigene Kinder anlegen, bearbeiten und löschen; Vor-/Nachname sowie optionales Geburtsdatum.
- Bei Eingabe eines Geburtsdatums: gültiges Datum, nicht in der Zukunft, höchstens sieben Jahre zurück.
- Datenänderungen an Kindern werden auf den eigenen Haushalt und die eigene Kita begrenzt.
- Eigenes Konto nach Bestätigung löschen. Bestehen aktuelle oder zukünftige veröffentlichte Notdienstpflichten des Haushalts, wird die Selbstlöschung abgelehnt.
- Beim letzten Benutzer eines Haushalts wird die Familie samt abhängigen Kindern gelöscht; bei weiteren Benutzern bleibt der Haushalt bestehen.
**Einschränkungen:** Name, E-Mail und Rolle lassen sich im persönlichen Profil nicht ändern. Eine Sperre der Kinderlöschung bei bestehenden Notdienstpflichten ist in `deleteMyChild` nicht vorhanden, obwohl die Kontolöschung diese Pflichten prüft.
Quellen: [Profilseite](../src/app/dashboard/profil/page.tsx), [Profilaktionen](../src/app/dashboard/profil/actions.ts).
### 4.5 Familienverwaltung, Eltern-Einladungen und feste Ämter
- Adminübersicht aller Familien mit Eltern und Kindern; Suche nach Familie, Eltern, E-Mail und Kindern.
- Umschalten zwischen Tabelle und Karten.
- Neue Familie mit einem oder zwei Elternteilen sowie einem bis zehn Kindern anlegen.
- Familienname, Namen/E-Mail-Adressen der Eltern und Kindernamen bearbeiten.
- Zweiten Elternteil ergänzen, neue Kinder hinzufügen und Kinder entfernen. Der Bearbeitungsablauf verlangt mindestens ein verbleibendes Kind und höchstens zwei Elternteile.
- Neue Elternkonten erhalten die Rolle `ELTERN` und einen Einladungslink zur Passwortvergabe mit sieben Tagen Gültigkeit.
- Aktivierung prüft Link, Ablaufdatum, Passwortlänge, Passwortbestätigung und Datenschutzannahme; optionales Adressbuch-Opt-in.
- Nach Aktivierung werden Passwort und Zustimmungen gespeichert, der Token gelöscht und die Person direkt angemeldet.
- Die Familienliste zeigt anhand der Kontoverifikation, ob eine Einladung noch offen ist.
- Feste Ämter mit Name und optionaler Beschreibung anlegen und löschen.
- Ein oder mehrere Ämter an einzelne Benutzer vergeben und Zuordnungen entfernen; doppelte identische Zuordnungen werden verhindert.
- Ämter sind im Profil und Adressbuch sichtbar.
**Einschränkungen:** Kein regulärer Dialog zum erneuten Versand oder Widerruf einer Einladung. Einladungen werden im tatsächlichen Ablauf in `VerificationToken` gespeichert. Das separate Modell `Invitation` ist dafür nicht angebunden. Scheitert der Mailversand nach der Datenanlage, bleibt die Familie angelegt und eine Fehlermeldung wird zurückgegeben. Eine vollständige Familienlöschung durch Kita-Admins ist nicht angeboten.
Quellen: [Familienaktionen](../src/app/dashboard/families/actions.ts), [Familienliste](../src/app/dashboard/families/_components/families-list-client.tsx), [Einladungsaktivierung](../src/app/invite/%5Btoken%5D/actions.ts), [Ämter](../src/app/dashboard/families/duty-actions.ts).
### 4.6 Notdienst-Verfügbarkeiten für Eltern
- Eingabe für den Folgemonat, bezogen auf aktive Kinder des eigenen Haushalts.
- Mindestzahl an ausgewählten Tagen entspricht Anzahl der Kinder × Kita-Einstellung.
- Bereits gespeicherte Haushaltseinträge werden geladen und können erneut gespeichert werden.
- Monatskalender mit Terminen, Kategorien, Veranstaltungsdetails und auswählbaren Verfügbarkeitstagen.
- Die Oberfläche lässt Montag bis Freitag zu und sperrt bestätigte Schließtage.
- Auswahlfortschritt und Rückmeldung bei zu wenigen Tagen.
- Die ausgewählten verschiedenen Tage werden beim Speichern reihum auf die angegebenen Kinder verteilt; bestehende Einträge dieser Kinder im Zielmonat werden ersetzt.
- Eingabefrist ist im Code fest: bis einschließlich 26. des aktuellen Monats, gesperrt ab dem 27.
- Ohne aktive eigene Kinder erscheint ein Hinweis mit Verweis zum Profil.
**Einschränkungen:** Die Server Action prüft Datumsformat, Zielmonat, Mindestzahl und Haushaltszugehörigkeit, aber keine Wochenenden oder Schließtage. Die Frist ist nicht im Einstellungsdialog konfigurierbar. Abwesenheitsmeldungen werden bei den Verfügbarkeiten nicht automatisch berücksichtigt.
Quellen: [Elternseite](../src/app/dashboard/notdienst/page.tsx), [Kalendereingabe](../src/app/dashboard/notdienst/notdienst-form.tsx), [Speichern](../src/app/dashboard/notdienst/actions.ts), [Fristregel](../src/lib/date-utils.ts).
### 4.7 Notdienst-Planungszentrale
- Admins und Koordinatoren können über Monat/Jahr navigieren; Vorgabe ist der Folgemonat.
- Übersicht von Haushalten, Kindern, Verfügbarkeitstagen, Haushalten mit/ohne Rückmeldung und Planstatus.
- Automatische Erzeugung eines monatlichen Entwurfs; ein bestehender Monatsplan verhindert erneute Generierung.
- Für jeden Montag bis Freitag wird aus verfügbaren Kindern ein Haushalt ausgewählt, der im bisherigen Monatsdurchlauf möglichst selten eingeteilt wurde. Bei Gleichstand kommt Zufall zum Einsatz; der Zähler startet jeden Monat neu.
- Tage ohne Verfügbarkeiten bleiben unbesetzt.
- Vorschau und manuelle Zuordnung zu einem aktiven Kind der Kita; Tage können auch geleert werden.
- Entwurf veröffentlichen; veröffentlichte Einteilungen erscheinen im Kalender.
- Veröffentlichte Pläne nachbearbeiten, solange der betreffende Tag nicht vergangen ist.
- Nach manuellen Änderungen eines veröffentlichten Plans werden E-Mails an betroffene Elternkonten der Rolle `ELTERN` angestoßen; betroffene offene Tauschanfragen werden ungültig.
- Entwurfsplan mit Bestätigungsdialog zurücksetzen und löschen. Veröffentlichte Pläne werden serverseitig vom Reset ausgeschlossen.
- Kita-Einstellungen für Mindestverfügbarkeiten und Erinnerungs-Vorlauf speichern.
- Manuell Erinnerungen an Haushalte versenden, die im ausgewählten Monat gar keinen Verfügbarkeitseintrag haben.
- „Als PDF exportieren“ öffnet den Browser-Druckdialog (`window.print()`); die PDF-Datei entsteht über die Druckfunktion des Browsers.
**Einschränkungen:** Keine garantierte optimale oder über mehrere Monate ausgeglichene Verteilung. Die Generierung berücksichtigt keine Feiertage, Schließtage, Teamtage oder Kinderabwesenheiten. Ein Erinnerungs-Vorlauf wird gespeichert, aber kein zeitgesteuerter Job verwendet ihn. Haushalte mit zu wenigen Einträgen erhalten über diese Erinnerungsaktion keine Erinnerung, sobald wenigstens ein Eintrag vorliegt. Beim erstmaligen Veröffentlichen wird keine Zuteilungsmail versendet; die entsprechende E-Mail-Vorlage allein ist kein angebundener Versand.
Quellen: [Planungsseite](../src/app/dashboard/notdienst/plan/page.tsx), [Planaktionen](../src/app/dashboard/notdienst/plan/actions.ts), [Planoberfläche](../src/app/dashboard/notdienst/plan/plan-view.tsx).
### 4.8 Notdienst-Tausch zwischen Familien
- Eltern können im Kalender einen fremden Notdienst anfragen und einen eigenen veröffentlichten Dienst zum Tausch anbieten; optionale Nachricht bis 500 Zeichen.
- Beide Dienste müssen derselben Kita angehören, veröffentlicht und heute oder zukünftig sein. Ein Tausch im eigenen Haushalt wird abgewiesen.
- Dienste mit wartender oder bestätigter Alarmierung sind vom Tausch ausgeschlossen.
- Bereits beteiligte Dienste mit offenen Tauschanfragen können keine weitere offene Anfrage erhalten.
- Der angefragte Haushalt erhält eine E-Mail und sieht die offene Anfrage im Kalender.
- Angefragter Haushalt kann annehmen oder ablehnen; anfragender Haushalt kann zurückziehen.
- Annahme vertauscht beide Kinder-Zuordnungen in einer Transaktion, speichert die Entscheidung und storniert weitere betroffene offene Anfragen.
- Annahme und Ablehnung lösen Benachrichtigungen an beide Familien aus; Rücknahme speichert den Status ohne eigenen Mailversand.
- Kalender und Notdienstansichten werden nach Änderungen neu validiert.
**Einschränkungen:** Neue Anfragen sind auf die exakte Rolle `ELTERN` beschränkt; Eltern mit Admin-/Koordinatorrolle können sie nicht starten. Die Oberfläche zeigt offene Anfragen, keine vollständige abgeschlossene Tauschhistorie. Eine erneute Verfügbarkeitsprüfung für die getauschten Tage erfolgt nicht.
Quellen: [Tauschaktionen](../src/app/dashboard/kalender/actions.ts), [Kalender und Anfragen](../src/app/dashboard/kalender/_components/calendar-overview-client.tsx), [Tauschdialog](../src/app/dashboard/kalender/_components/termin-list.tsx).
### 4.9 Notdienst-Alarmierung
Vorbereitet sind:
- Server Action zum Auslösen eines Alarms durch Admin/Koordinator für eine Einteilung.
- Kita-Prüfung und Abweisung einer bereits alarmierten Einteilung.
- Eigene Alarmdatensätze und E-Mails für die Elternkonten der eingeteilten Familie mit Rolle `ELTERN`.
- Bestätigungsseite unter `/alert/[token]`; der Link erlaubt die Bestätigung ohne Login.
- Statuswechsel von `PENDING` auf `CONFIRMED` mit Zeitstempel; erneute Bestätigung wird abgewiesen.
- Vorbereitete Button-Komponente für das Auslösen.
**Aktueller Stand:** `AlertButton` wird von keiner Seite eingebunden. Ein erreichbarer Auslöseablauf und eine laufende Statusübersicht für die Koordination fehlen damit in der aktuellen Oberfläche. Das Datenmodell kann eine erkrankte Fachkraft und Notizen speichern, aber die Aktion nimmt nur die Einteilungs-ID entgegen. Eine Auswahl der Fachkraft, Alarmstornierung, Eskalation oder zeitliche Token-Gültigkeit ist nicht angebunden.
Quellen: [Alarmaktion](../src/app/dashboard/actions.ts), [ungebundener Alarmbutton](../src/app/dashboard/alert-button.tsx), [Bestätigung](../src/app/alert/%5Btoken%5D/actions.ts).
### 4.10 Kalender, Terminanfragen und Mitbringlisten
- Gemeinsamer Kalender für bestätigte Termine, eigene ausstehende Terminanfragen, geplante Elterndienste und veröffentlichte Notdienste.
- Listen-, Monats- und Agendaansicht; Monatsnavigation und Sprung zu heute.
- Tagesdialog mit Termindetails, Diensten und Mitbringlisten.
- Suche nach Titel/Beschreibung und bei Diensten nach Familie beziehungsweise Kind.
- Kategorienfilter und Umschaltung zwischen eigenen und allen Diensten; reguläre Kita-Termine bleiben auch im eigenen Filter sichtbar.
- Kategorien: Kita-Fest, Schließtag, Teamtag, Mitmach-Tag, Elternabend, Mitgliederversammlung, Elterncafé, interner/externer Geburtstag und Sonstiges.
- Terminanfrage mit Titel, Beschreibung, Kategorie, Anfang/Ende und Ganztagsangabe.
- Eigene Anfragen werden als ausstehend angezeigt; Admins/Koordinatoren können ausstehende Anfragen bestätigen oder mit Begründung ablehnen.
- Admins/Koordinatoren können bestätigte Termine direkt anlegen, bearbeiten und endgültig löschen.
- Datumsprüfung: Beginn nicht in der Vergangenheit, Ende nicht vor Beginn.
- Mitbringliste je Termin aktivieren/deaktivieren; Textbeiträge hinzufügen.
- Eigene Beiträge löschen; Admins/Koordinatoren können auch fremde Beiträge löschen.
- Verweise aus Dienst-/Notdienstterminen in die entsprechenden Verwaltungsseiten; Diensttausch über den Kalender.
**Einschränkungen:** Ausstehende Anfragen blockieren keinen Zeitraum durch eine serverseitige Kollisionsprüfung. Eine Anfrage ist für andere Eltern nicht allgemein als reservierter Slot sichtbar. Mitbringbeiträge lassen sich nicht direkt bearbeiten, sondern nur löschen und neu anlegen. Es wurde kein Kalenderabo, ICS-Export oder Serientermin-Ablauf gefunden.
Quellen: [Kalenderseite](../src/app/dashboard/kalender/page.tsx), [Kalenderansichten](../src/app/dashboard/kalender/_components/calendar-overview-client.tsx), [Terminaktionen](../src/app/dashboard/kalender/actions.ts), [Mitbringliste](../src/app/dashboard/kalender/_components/mitbringsel-list.tsx).
### 4.11 Event-Anmeldungen und RSVP
- Admins/Koordinatoren können Termine mit Teilnahmeabfrage, optionaler Rückmeldefrist und Hinweisen für Teilnehmende anlegen/bearbeiten.
- Verwaltungsseite listet Termine samt Status und zeigt pro Event Zusagen, Absagen und ausstehende Antworten.
- Kindbezogene Teilnehmerliste über alle aktiven Kinder der Kita.
- Server Action für Zu-/Absage eines eigenen aktiven Kindes, inklusive Prüfung von Kita, Haushalt, bestätigtem Termin und Frist.
- Fehlt eine eigene Frist, gilt der Eventbeginn als Rückmeldeschluss. Eine bestehende Antwort kann bis dahin überschrieben werden.
- Teilnehmerhinweise werden im Kalender bei Admin/Koordinator und bei einem Haushalt mit mindestens einer Zusage angezeigt.
**Aktueller Stand:** Die Eltern-Eingabekomponente `RsvpActionCard` existiert, wird aber von keiner Seite verwendet. Eltern besitzen deshalb im aktuellen Seitenaufbau keinen eingebundenen Zu-/Absagedialog. Außerdem wird `participantInfo` bereits an den Kalender-Client übertragen und nur bei der Darstellung ausgeblendet; die Anzeigeprüfung ist keine serverseitige Zugriffsbeschränkung für diese Information.
Quellen: [RSVP-Aktionen](../src/actions/rsvp.ts), [Event-Verwaltung](../src/app/dashboard/admin/kalender/admin-calendar-manager.tsx), [ungebundene Elternkomponente](../src/app/dashboard/rsvp-action-card.tsx), [Kalenderdaten](../src/app/dashboard/kalender/page.tsx).
### 4.12 Krank- und Abwesenheitsmeldungen
- Eigenes aktives Kind aus dem Haushalt auswählen und für einen Tag oder Zeitraum abmelden.
- Gründe: Krankheit, Urlaub und Sonstiges; optionale Notiz bis 500 Zeichen.
- Ende darf nicht vor dem Beginn liegen; sich überschneidende Meldungen desselben Kindes werden abgewiesen.
- Eigene laufende/bevorstehende Meldungen anzeigen und löschen.
- Tagesübersicht für Admin, Koordinator und Erzieherrolle mit Kind, Familie, Grund, Zeitraum und Notiz.
- Tagesnavigation zurück/vor/heute und freie Datumswahl.
- Grundfilter, Kennzahlen und Hinweise zu Wochenende, Schließtag/Teamtag sowie Tagen mehr als 30 Tage in der Zukunft.
- Abwesenheiten sind nicht als echte Anwesenheitserfassung mit Check-in/Check-out implementiert; „anwesend“ ist aus Kinderzahl minus Meldungen abgeleitet.
**Einschränkungen:** Gruppen „Krippe“ und „Elementar“ werden aus dem ersten Zeichen des Kindernamens künstlich abgeleitet (`mockGroup`). Das Datenmodell hat keine echte Gruppenzuordnung. Die Anwesenheitszahl dieser Ansicht verwendet die gefilterten Fehlmeldungen bei weiterhin gesamter Kinderzahl und kann deshalb bei aktivem Filter irreführend sein. Eine bestehende Abwesenheit kann nur gelöscht und neu gemeldet, nicht direkt bearbeitet werden.
Quellen: [Abwesenheitsaktionen](../src/actions/absences.ts), [Elternformular](../src/app/dashboard/absence-card.tsx), [Tagesübersicht](../src/app/dashboard/admin/abwesenheiten/page.tsx), [Filter](../src/app/dashboard/admin/abwesenheiten/_components/absences-client.tsx).
### 4.13 Wöchentlicher Dienstplan
- Separater Dienstplan für Haushalte, unabhängig von festen personenbezogenen Ämtern und Notdienst.
- Diensttypen mit Name/Beschreibung anlegen und löschen.
- Wochenraster mit wählbarem Beginn und Zeitraum; Standard zwölf Wochen, maximal 104 Wochen.
- Haushalt je Diensttyp/Kalenderwoche auswählen oder Zuordnung entfernen; Änderungen werden direkt gespeichert.
- Kita-Zugehörigkeit von Diensttyp und Familie wird geprüft.
- Einteilungen erscheinen im gemeinsamen Kalender.
- Manuelle Erinnerungsaktion für noch nicht erinnerte geplante Dienste, deren Beginn in der aktuellen Woche liegt.
- Versand an verifizierte Benutzer der Familie; erfolgreicher Versand wird mit `reminderSentAt` gespeichert. Erneute Zuordnung setzt diesen Wert zurück.
**Einschränkungen:** Kein automatisch laufender Erinnerungsjob. Status `DONE` und `CANCELLED` existieren im Datenmodell, aber ein regulärer Abschluss-/Stornoablauf ist nicht eingebunden. Eine Änderung setzt den Dienst wieder auf `PLANNED`. Das Löschen eines Diensttyps löscht durch die Datenrelationen auch dessen Einteilungen.
Quellen: [Dienstplanseite](../src/app/dashboard/admin/dienste/page.tsx), [Raster](../src/app/dashboard/admin/dienste/duty-planner.tsx), [Dienstaktionen](../src/app/dashboard/admin/dienste/actions.ts).
### 4.14 Schwarzes Brett, E-Mail und Anhänge
- Admins können eine Ankündigung mit Titel und Markdown-Inhalt erstellen; Vorschau ist im Formular vorhanden.
- PDF-, JPG- und PNG-Anhänge bis zehn MB je Datei.
- Speicherung der Anhangdateien auf dem Server und der Metadaten in der Datenbank.
- Abruf über geschützte API mit Prüfung auf angemeldeten Benutzer und dieselbe Kita; keine Auslieferung über ein öffentliches Uploadverzeichnis.
- Optionaler E-Mail-Versand an verifizierte Haushaltskonten, Erzieherkonten oder beide Gruppen. Die Auswahl betrifft E-Mail-Empfänger und wird nicht als Sichtbarkeitsgruppe der Meldung gespeichert.
- Adminseite zeigt die letzten acht veröffentlichten Meldungen mit Autor, Zeitpunkt und Anhanganzahl.
- Bei Dateischreibfehlern werden die neue Meldung und angefangene Dateien zurückgenommen; bei Mailfehlern bleibt die Meldung gespeichert und eine Warnung wird zurückgegeben.
- Lesestatusmodell und Aktion zum Markieren als gelesen sind vorhanden; `NewsTicker` enthält einen vorbereiteten Meldungsdialog.
**Aktueller Stand:** `NewsTicker` ist nicht in das Dashboard oder eine andere Seite eingebunden. Eltern können neue Meldungen daher derzeit über den optionalen Mailversand erhalten, besitzen aber keine eingebundene Meldungsliste in der App. Eine Adminauswertung der Lesebestätigungen sowie Bearbeiten/Löschen von Meldungen sind nicht umgesetzt.
Quellen: [Meldungsaktionen](../src/actions/announcements.ts), [Adminseite](../src/app/dashboard/admin/news/page.tsx), [Formular](../src/app/dashboard/admin/news/news-form.tsx), [ungebundener Ticker](../src/app/dashboard/news-ticker.tsx), [Anhang-API](../src/app/api/announcements/attachments/%5Bid%5D/route.ts).
### 4.15 Adressbuch
- Interne Übersicht der Haushalte, bei denen mindestens ein Benutzer der Kontaktfreigabe zugestimmt hat.
- Anzeige von Haushaltsname, Kindern, Elternnamen und festen Ämtern; alphabetische Gruppierung nach Haushaltsnamen.
- E-Mail, Telefon und Adresse werden nur für den jeweiligen Benutzer mit Opt-in geladen.
- Suche nach Familienname, Eltern-/Kindernamen oder sichtbarer E-Mail.
- Filter für Telefonnummer, Ämter und Haushalte mit Opt-in aller zugeordneten Benutzer.
- Detaildialog je Familie; E-Mail- und Telefonlinks starten den jeweiligen Mail-/Telefonhandler.
- Sichtbarkeitsdialog erklärt die Freigabe und führt zum eigenen Profil.
- Optionales Geburtsdatum eines Kindes ist im Detaildialog sichtbar.
**Einschränkung:** Namen und Ämter eines zweiten Elternteils ohne Kontaktfreigabe sowie Kinderinformationen sind innerhalb eines sichtbaren Haushalts weiterhin sichtbar. Die Freigabe ist technisch kein Opt-in für sämtliche Haushaltsinformationen.
Quellen: [Adressbuchdaten](../src/app/dashboard/adressbuch/page.tsx), [Adressbuchoberfläche](../src/app/dashboard/adressbuch/_components/directory-client.tsx).
### 4.16 ErzieherInnen-Stammdaten
- Admins können Fachkräfte mit Vor- und Nachname anlegen, bearbeiten und löschen.
- Aktivstatus wird gepflegt und dargestellt.
- Diese Datensätze sind keine Login-Konten; die separate Benutzerrolle `ERZIEHER` ist hiervon unabhängig.
- Referenz für Notdienstalarme im Datenmodell vorhanden, aber derzeit keine Fachkraftauswahl im Alarmauslöser.
Quellen: [Erzieheraktionen](../src/app/dashboard/erzieher/actions.ts), [Erzieheroberfläche](../src/app/dashboard/erzieher/_components/erzieher-list.tsx).
### 4.17 Systemweite Superadmin-Verwaltung
- Übersicht aller Kitas mit Slug, Modulstatus, Benutzer-/Familien-/Kinderzahlen, Terminen, Abwesenheiten, Meldungen, offenen Einladungen und letztem Login.
- Hinweise auf Benutzer ohne Kita, Kontosperren, fehlende Datenschutzzustimmung und Familien ohne Benutzer.
- Kita-Diagnose mit Benutzerliste, Rollen, Familien, Verifikationsstatus, Consent, Fehlversuchen und Sperren; zusätzlich Zähler für Konten ohne Passwort und abgelaufene Einladungen.
- Diagnoseaufrufe werden im Audit-Protokoll gespeichert.
- Kita endgültig löschen nach exakter Namensbestätigung, mit kaskadierender Löschung abhängiger Datenbankdatensätze.
- Kita-gebundene Benutzer löschen nach Bestätigung ihrer E-Mail-Adresse; dabei zugehörige Verifikationstokens entfernen.
- Benutzer für weitere Logins sperren, entsperren oder Fehlversuche zurücksetzen. Sperrung setzt `lockedUntil` weit in die Zukunft; Entsperren löscht die Sperre und setzt den Zähler zurück.
- Eigene und andere Superadmin-Konten sowie Konten ohne Kita werden durch diese Support-Aktionen nicht verändert.
- Auditansicht zeigt die neuesten 200 Einträge samt Akteur, Ziel, Zeitpunkt, Aktion und Metadaten. Protokolle können auch nach Löschung der Zielobjekte bestehen bleiben.
**Einschränkungen:** Offene und abgelaufene Einladungen werden über `Invitation` gezählt, während die tatsächlichen Familien-Einladungen `VerificationToken` nutzen. Eine Superadmin-Benutzerlöschung entfernt nicht automatisch einen nun leeren Haushalt. Eine Sperre wird bei der Anmeldung geprüft; das sofortige Beenden bereits bestehender Sessions ist nicht umgesetzt.
Quellen: [Adminübersicht und Diagnose-Daten](../src/app/admin/_lib/data.ts), [Support-Aktionen](../src/app/admin/actions.ts), [Auditseite](../src/app/admin/audit/page.tsx).
## 5. Datenmodell und technische Querschnittsfunktionen
- PostgreSQL mit Prisma. Eine Kita ist ein Mandant; fachliche Daten sind über `kitaId` zugeordnet.
- Datenmodelle für Kitas, Benutzer, Haushalte, Kinder, Fachkräfte, feste Ämter, Diensttypen/-einteilungen, Abwesenheiten, Meldungen, Anhänge, Lesestatus, Termine, Teilnahme, Mitbringsel, Notdienstpläne/-verfügbarkeiten/-einteilungen/-alarme/-tausche sowie Auditprotokolle und Tokens.
- Eindeutigkeitsregeln unter anderem für E-Mail, Kita-Slug, Monatsplan, Einteilung je Plantag, Verfügbarkeit je Kind/Tag, Teilnahme je Event/Kind und Amt je Benutzer.
- Eingabeprüfung überwiegend mit Zod, Schreibabläufe teilweise als Datenbanktransaktionen, Aktualisierung von Seiten nach Änderungen.
- Gemeinsamer E-Mail-Versand über Resend mit Fehlerbehandlung. Ohne API-Key werden E-Mails nur in der Entwicklungsumgebung simuliert; diese Simulation bestätigt keine Zustellung.
- Vorlagen für Einladung, Alarm, Verfügbarkeitserinnerung, Einteilungsänderung, Diensttausch, Wochen-Diensterinnerung, News und Kontakt. Eine weitere Vorlage für erstmalige Notdienst-Zuteilung ist vorhanden, aber nicht an die Veröffentlichung angebunden.
- Rollen-, Kita- und Consent-Prüfungen über gemeinsame Helfer. Geschützte Dashboard-/Adminlayouts, Seiten und Aktionen setzen Zugriffsprüfungen ein; nicht jede Aktion verwendet denselben Consent-Helfer.
- Viele Datenbankrelationen löschen abhängige Datensätze mit. Das ist nicht gleichbedeutend mit vollständiger Bereinigung von Dateien, allgemeinen Verifikationstokens oder Audit-Snapshots.
- Der Hilfsmodus `TEST_MODE=true` liefert in `requireRole` und `requireKitaSession` künstliche Sessions und umgeht dort die regulären Prüfungen. Er ist nicht auf die Entwicklungsumgebung begrenzt.
Quelle: [Schema](../prisma/schema.prisma), [Mail](../src/lib/mail.ts), [Auth-Helfer](../src/lib/auth-utils.ts).
## 6. Seiten- und Schnittstellenverzeichnis
| Route | Zweck/Zugriff |
| --- | --- |
| `/` | Öffentliche Startseite und Kontakt. |
| `/features/notdienst-planer` | Öffentliche Notdienst-Beschreibung. |
| `/features/kita-kalender` | Öffentliche Kalender-Beschreibung. |
| `/features/eltern-adressbuch` | Öffentliche Adressbuch-Beschreibung. |
| `/features/krankmeldung` | Öffentliche Abwesenheits-Beschreibung. |
| `/features/schwarzes-brett` | Öffentliche Meldungs-Beschreibung. |
| `/impressum`, `/datenschutz` | Öffentliche Informationsseiten mit noch offenen Platzhaltern. |
| `/register`, `/login` | Gründerregistrierung und Anmeldung. |
| `/onboarding` | Kita einrichten nach Anmeldung. |
| `/onboarding/consent` | Hinweis bei fehlender Datenschutzannahme. |
| `/invite/[token]` | Elternkonto über Einladungslink aktivieren. |
| `/alert/[token]` | Notdienstalarm über Link bestätigen. |
| `/forbidden` | Hinweis bei verweigertem Zugriff. |
| `/dashboard` | Kita-Übersicht und eigene Abwesenheiten. |
| `/dashboard/profil` | Eigener Haushalt, Kinder, Kontakte und Kontolöschung. |
| `/dashboard/notdienst` | Verfügbarkeiten; Eltern, Admin, Koordinator. |
| `/dashboard/notdienst/plan` | Planung; Admin, Koordinator. |
| `/dashboard/kalender` | Kita-Kalender und Diensttausch. |
| `/dashboard/adressbuch` | Internes Adressbuch. |
| `/dashboard/families` | Familien und feste Ämter; Admin. |
| `/dashboard/erzieher` | Fachkraft-Stammdaten; Admin. |
| `/dashboard/admin/dienste` | Wochen-Dienstplan; Kita-Admin. Die Aktion erlaubt zusätzlich Superadmin mit Kita-Kontext. |
| `/dashboard/admin/news` | Meldungen veröffentlichen; Admin. |
| `/dashboard/admin/kalender` | Termine und Event-Anmeldungen; Admin, Koordinator. |
| `/dashboard/admin/abwesenheiten` | Tagesübersicht; Admin, Koordinator, Erzieherrolle. |
| `/admin` | Systemweite Kita-Übersicht; Superadmin. |
| `/admin/kitas/[kitaId]` | Kita-Diagnose und Benutzersupport; Superadmin. |
| `/admin/audit` | Systemweites Audit-Protokoll; Superadmin. |
| `/api/auth/[...nextauth]` | Auth.js-Endpunkte. |
| `/api/announcements/attachments/[id]` | Geschützter Anhangdownload. |
| `/sitemap.xml`, `/robots.txt` | Suchmaschinensteuerung. |
## 7. Betrieb, Entwicklung und Prüfstand
- Stack laut `package.json`: Next.js 16.2.4, React 19.2.4, TypeScript, Prisma 6, Auth.js/NextAuth v5 beta, PostgreSQL, Tailwind CSS und Resend.
- Lokaler Entwicklungsstart führt vor Next.js automatisch `prisma db push` und den Seed aus.
- Seed legt Demonstrationsdaten mit mehreren Rollen und fachlichen Beispielen an; regulärer Seed ist bei bereits befüllter Datenbank zurückhaltend. Ein separater Reset-Modus existiert.
- Docker-Build und Produktionsstart sind vorhanden; Produktionsstart wendet das Schema über `prisma db push --skip-generate` an. Versionierte Prisma-Migrationen liegen nicht im geprüften Dateibestand.
- Lokale Compose-Datei stellt PostgreSQL bereit; Coolify-Compose enthält App, PostgreSQL, pgAdmin und persistente Datenbank-/Uploadvolumes.
- Umgebungsvariablen-Vorlage und Produktionscheckliste sind vorhanden; ihre tatsächliche Erfüllung wurde nicht auf einem Server geprüft.
- `UPLOAD_DIR` ist persistent vorgesehen. Die Dateihilfsfunktionen hängen noch `announcements` an diesen Pfad an; bei der aktuellen Compose-Konfiguration ergibt sich `/app/uploads/announcements/announcements`.
- Kein Testskript und keine automatisierte Testdateisuite im geprüften Repository gefunden. Demo-Seed und manueller Live-Testplan ersetzen keine automatisierten Tests.
### Ausgeführte technische Prüfungen
Die Prüfungen liefen auf dem unveränderten Ausgangscheckout mit den dort bereits installierten Abhängigkeiten. Es wurden keine Bibliotheken installiert und keine Builds oder Datenbankoperationen ausgeführt.
| Prüfung | Ergebnis |
| --- | --- |
| `./node_modules/.bin/tsc --noEmit --incremental false` | Erfolgreich, Exit-Code 0. |
| `npm run lint` | Fehlgeschlagen, Exit-Code 1: zwei Fehler und neun Warnungen. |
| Quellenprüfung von Seiten, Aktionen, Komponenten und Schema | Durchführung für die oben beschriebenen Funktionsbereiche. |
| Aktueller Browser-/End-to-End-Test | Nicht durchgeführt. |
| Mailzustellung und produktives Deployment | Nicht geprüft. |
Beide ESLint-Fehler betreffen `as any` im Testmodus von `src/lib/auth-utils.ts` (Zeilen 57 und 91). Die Warnungen betreffen ungenutzte Variablen/Imports im Seed, Kalender, Adressbuch und Abwesenheiten. Diese Bestandsaufnahme ändert keinen Anwendungscode.
Der vorhandene [Live-Testplan](live-testplan.md) vom 17.05.2026 dokumentiert erfolgreiche Tests von Landingpage/Kontakt, Gründerregistrierung, Einrichtung, Dashboard, Familienanlage und Teilen des Login-Ablaufs. Eltern-Einladungsaktivierung und anschließende Bereinigung sind dort noch offen. Dies sind historische Einträge, keine aktuellen Testnachweise für den geprüften Commit. Die abgehakten Punkte in [UI-TODO.md](../UI-TODO.md) sind ebenfalls historische Angaben; viele der dort ehemals fehlenden Handler sind inzwischen im Code vorhanden.
Quellen: [Paket und Skripte](../package.json), [Deployment](../deploy/README.md), [Produktionscheckliste](../deploy/production-checklist.md), [Seed](../prisma/seed.ts), [Coolify-Compose](../docker-compose.coolify.yml).
## 8. Konkrete offene Punkte für die weitere Arbeit
Die Reihenfolge ist ein Vorschlag aus der Bestandsaufnahme; es wurde nichts davon umgesetzt.
| Reihenfolge | Thema | Konkreter nächster Schritt |
| --- | --- | --- |
| 1 | Fehlende Elternabläufe | NewsTicker und RSVP-Eingabe an eine erreichbare Seite anbinden; Daten dafür laden. |
| 2 | Notdienstalarm | Auslösebutton, Fachkraftauswahl und Statusanzeige in den aktuellen Seitenaufbau integrieren. |
| 3 | Moduldeaktivierung | Modulschalter in Navigation, Seiten und Server Actions einheitlich prüfen; spätere Einstellungen anbieten. |
| 4 | Notdienstregeln | Wochenenden/Schließtage serverseitig ausschließen und Generierung um Schließtage ergänzen; Abwesenheitsregel festlegen. |
| 5 | Erinnerungen | Automatische Ausführung ergänzen und unterscheiden, ob gar keine oder zu wenige Verfügbarkeiten vorliegen. |
| 6 | Erstveröffentlichung | Zuteilungsmails beim Veröffentlichen anbinden und Mailfehler sichtbar behandeln. |
| 7 | Einladungssupport | Tokenmodell und Superadmin-Zähler vereinheitlichen; erneuten Versand, Ablauf und Widerruf erreichbar machen. |
| 8 | Rechtevergabe | Regulären Ablauf für Koordinator-/Erzieherkonten und Rollenänderungen ergänzen. |
| 9 | Abwesenheitsgruppen | Echte Gruppenzuordnung einführen oder den künstlichen Gruppenfilter entfernen; Kennzahlen konsistent berechnen. |
| 10 | Buchungskonflikte | Fachliche Reservierungsregeln definieren und Überschneidungen serverseitig prüfen. |
| 11 | Selbstverwaltung | Passwort-Reset/-Änderung und direkte Bearbeitung von Abwesenheiten/Mitbringbeiträgen ergänzen. |
| 12 | Löschabläufe | Kinderlöschung bei bestehenden Verpflichtungen prüfen; Anhangdateien und Tokens bei Kita-/Kontolöschungen bereinigen; Audit-Aufbewahrung gesondert definieren. |
| 13 | Zugriffsprüfungen | Testmodus an Entwicklungsumgebung binden; Consent-/Session-Prüfungen und Teilnehmerhinweise serverseitig vereinheitlichen. |
| 14 | Technischer Zustand | Zwei ESLint-Fehler beheben, Migrationsablauf einführen und aussagekräftige Tests für die zentralen Abläufe ergänzen. |
| 15 | Aktuelle Abnahme | Rollenbasierte Browserprüfung, Mailzustellung, Elternaktivierung und Bereinigung anhand eines aktualisierten Testplans durchführen. |
| 16 | Öffentliche Texte | Platzhalter in Impressum/Datenschutz mit den tatsächlichen Betriebsangaben vervollständigen und Marketingversprechen mit dem implementierten Verhalten abgleichen. |
## 9. Nicht als fertige Produktfunktion vorhanden
Im geprüften Code wurden kein Abonnement-/Zahlungsablauf, keine Import-/Exportverwaltung für Familien, kein externer Kalenderabgleich, keine Push-/SMS-Alarmierung, keine echte Kita-Gruppenverwaltung und keine Zeiterfassung/Check-in-Funktion gefunden. Vorhandene Planungs- oder Marketingtexte sind dafür kein Umsetzungsnachweis.
+97
View File
@@ -0,0 +1,97 @@
# Personalbereich: Arbeitszeit, Urlaub und Zeitkonto
Stand: 07.10.2026 · Branch `codex/personalbereich`
## Einstieg und Zuständigkeiten
Der Bereich liegt unter `/dashboard/personal`. Kita-Admins (einschließlich Vorstand mit Rolle `ADMIN`) verwalten alle Personalprofile ihrer Kita. ErzieherInnen bearbeiten eigene Zeiten und Anträge. Eltern und Koordination haben keinen Zugriff. Der interne Teamkalender ist nur für Admins und ErzieherInnen zugänglich.
Bestehende ErzieherInnen-Stammdaten bleiben erhalten. Ein Admin öffnet beim Personalstamm das **Personalprofil** und hinterlegt:
1. Beschäftigungsbeginn, optionales Ende, Beginn der Zeiterfassung und Anfangssaldo.
2. Ein datiertes Wochenmodell mit Netto-Sollstunden für Montag bis Sonntag; 0 bedeutet frei.
3. Jahresurlaub und ausdrücklich festgelegten Übertrag, individuell für die Arbeitstage dieser Person.
4. Einen passenden ErzieherInnen-Account. Bestehende verifizierte Accounts derselben Kita können verknüpft werden. Für neue Accounts wird ein persönlicher, einmal verwendbarer Aktivierungslink mit sieben Tagen Gültigkeit erzeugt. Ein neuer Link ersetzt den alten.
5. Die örtlichen Feiertage unter **Teamkalender**. Feiertage gelten separat von den Schließtagen des allgemeinen Kalenders.
Der Aktivierungsablauf verwendet die bestehende Passwort- und Consent-Einrichtung unter `/invite/[token]`. Aktivierungslinks werden nur dem berechtigten Admin angezeigt und persönlich weitergegeben. Automatischer E-Mail-Versand ist in dieser Umsetzung nicht angebunden.
## Arbeitszeit und Überstunden
Pro Tag sind mehrere Arbeitsblöcke mit Beginn, Ende und Pause möglich. Zeitblöcke dürfen nicht überlappen. Die Pause wird in Minuten vom Block abgezogen. Zeiten werden für heutige oder vergangene Tage innerhalb der Beschäftigung und ab Erfassungsbeginn erfasst. Blöcke über Mitternacht werden auf zwei Tage aufgeteilt.
Die Tagesbilanz ist **Istzeit + Urlaub/Krankheit − Sollzeit**. Arbeit an einem freien Tag oder Feiertag zählt als zusätzliche Istzeit. Die Wochenansicht zeigt alle sieben Tage; in einer laufenden Woche fehlen zukünftige Arbeitszeiten noch, deshalb ist ihre Differenz vorläufig.
Die Fachkraft reicht ihre Woche nach dem letzten vorgesehenen Arbeitstag ein. Offene Abwesenheiten im Zeitraum müssen zuerst geklärt sein. Der Admin prüft die einzelnen Zeiten, genehmigt die Woche oder gibt sie mit Rückmeldung zurück. Eingereichte und genehmigte Wochen sperren Zeitänderungen. Eigene Wochen und eigene Anträge können nicht selbst freigegeben werden.
Beim Genehmigen wird die Tagesberechnung gespeichert. Nur genehmigte Wochen, der Anfangssaldo und wirksame manuelle Korrekturen zählen zum bestätigten Zeitkonto. Offene oder eingereichte Wochen wirken noch nicht auf dieses Konto. Eine Rückgabe entfernt die Wochenbuchung bis zur erneuten Freigabe. Fehler in manuellen Korrekturen werden durch eine begründete Gegenbuchung behoben.
## Feste Wochentage und seltene Wechsel
Wochenmodelle gelten ab ihrem Datum. Eine spätere Änderung überschreibt kein früheres Modell. Seltene Tausche werden über zwei Tagesausnahmen erfasst: der bisherige Arbeitstag erhält 0 Sollstunden, der Ersatztermin die vorgesehenen Stunden.
Genehmigte Abwesenheiten sowie eingereichte oder genehmigte Wochen schützen ihren Zeitraum auch vor Änderungen an Modellen, Ausnahmen und Feiertagen. Betroffene Freigaben müssen vor einer solchen Änderung zurückgegeben bzw. storniert werden. Grunddaten und Anfangssaldo werden nach der ersten Erfassung geschützt; das Beschäftigungsende bleibt über einen eigenen Ablauf verwaltbar, sofern bestehende Zeiten und Anträge nicht verletzt werden.
## Urlaub
Urlaub ist ganztägig oder für einen einzelnen halben Tag möglich. Nur vorgesehene Arbeitstage verbrauchen Urlaub. Wochenenden sind nicht pauschal frei: Entscheidend sind Wochenmodell und Tagesausnahmen. Feiertage verbrauchen keinen Urlaub und erzeugen keine Sollzeit. Ein halber Urlaubstag schreibt die Hälfte der Tages-Sollzeit gut; bei ungerader Minutenzahl wird auf eine ganze Minute gerundet.
Ein Jahreskonto führt Anspruch plus Übertrag, genommenen Urlaub, genehmigten geplanten Urlaub, offene Anträge und verfügbaren Rest. Offene Anträge werden bei weiteren Anträgen berücksichtigt. Abgelehnte und stornierte Anträge verbrauchen nichts. Zeiträume über den Jahreswechsel werden auf die jeweiligen Jahreskonten verteilt. Anspruch und Übertrag werden nicht automatisch anteilig berechnet oder zum Jahreswechsel übertragen.
Offene Anträge können geändert oder zurückgezogen werden. Bei genehmigten Anträgen wird eine Stornierung beantragt. Bis zur Entscheidung bleibt die Abwesenheit gebucht. Krankheit hinterlegt der Admin; sie entlastet die Sollzeit, ohne Urlaub zu verbrauchen. KollegInnen sehen Krankheit im Teamkalender nur als **Abwesend**, ohne persönliche Notizen oder Kontodaten.
## Freizeitausgleich
Freizeitausgleich wird für einen einzelnen vorgesehenen Arbeitstag in Stunden beantragt. Das bestätigte verfügbare Guthaben muss ausreichen; weitere offene Anträge werden dabei berücksichtigt.
Nach Genehmigung wird die Zeit reserviert. Freizeitausgleich erzeugt keine zusätzliche Istzeit oder Urlaubsgutschrift. Beispiel: 6 Stunden Soll, 5 Stunden Arbeit und 1 Stunde Freizeitausgleich ergeben eine Tagesbilanz von −1 Stunde. Mit der Wochenfreigabe wird diese Stunde im Zeitkonto gebucht und die Reservierung entfällt. Dadurch wird die Stunde genau einmal abgezogen. Bei offenen Stornierungen bleibt die Reservierung erhalten.
## Hinweise und Nachvollziehbarkeit
Neue Anträge und eingereichte Wochen erzeugen interne Hinweise für Kita-Admins. Entscheidungen und Rückgaben erzeugen Hinweise für die betroffene Fachkraft. Hinweise lassen sich als gelesen markieren; jede Person kann ausschließlich eigene Hinweise quittieren. Das Personalprofil zeigt die letzten 30 Änderungen. Im Datenmodell werden sämtliche Änderungen mit Zeitpunkt und handelnder User-ID gespeichert.
Parallele Änderungen laufen in serialisierbaren Datenbanktransaktionen mit Wiederholung bei Schreibkonflikten. Rollen, Accountstatus, Eigentümer und Kita-Zugehörigkeit werden serverseitig geprüft. Das Löschen von Fachkräften mit Personalprofil wird verhindert; sie können auf inaktiv gesetzt werden. Bei Accountlöschung bleiben Personalaufzeichnungen ohne Accountverknüpfung erhalten. Die Löschung einer Kita entfernt auch ihren Personalbereich.
## Einführung und Schema
Das Projekt verwendet weiterhin seinen vorhandenen Ablauf mit `prisma db push`. Es gibt keine vollständige versionierte Prisma-Migrationshistorie. Die neuen Tabellen sind additiv; vorhandene Personen erhalten noch kein automatisch befülltes Beschäftigungsprofil.
- Lokal: Abhängigkeiten installieren, Prisma-Client generieren, Schema gegen eine dafür vorgesehene Datenbank anwenden, App starten und Profile einrichten.
- Im vorhandenen Docker-Ablauf erzeugt `npm run build:prod` den Client; `scripts/start-production.sh` wendet das Schema vor App-Start an.
- [Prüfbares SQL](../deploy/sql/personalbereich.sql) beschreibt dieselbe additive Änderung gegen den dokumentierten Ausgangsstand. Es ist einmalig und nicht idempotent. Entweder den vorhandenen Schemaabgleich **oder** dieses SQL verwenden; das SQL nicht nach bereits erfolgtem Schemaabgleich erneut ausführen.
Die reale Projekt- und Produktionsdatenbank wurde bei dieser Umsetzung nicht verändert. Alle DB- und Browserprüfungen liefen mit synthetischen Daten in einer separaten lokalen PostgreSQL-Datenbank.
## Prüfungen
- `npm run test:staff`: Berechnungstests für Teilzeit, halbe Tage, Feiertage, Jahreswechsel, Statuswechsel, Pausen, Snapshots und Freizeitausgleich.
- `npm run test:staff:integration`: echte Datenbankabläufe für Mandantentrennung, Rollen und Eigentümer, Anträge, Freigaben, parallele Änderungen, Sperren, Rückgaben, Aktivierungslinks und Beschäftigungsende.
- Integrationstests akzeptieren ausschließlich `127.0.0.1:55439/kita_staff_test`. Beispiel: `DATABASE_URL=postgresql://USER@127.0.0.1:55439/kita_staff_test npm run test:staff:integration`. Die leere Testdatenbank vorher mit dem aktuellen Schema einrichten. Tests bereinigen nur ihre eigens erzeugten Testkitas.
- Browserprüfung: Admin richtet Profil, 18-Stunden-Woche und 18 Urlaubstage ein; Erzieherin erfasst drei Blöcke mit Pausen, reicht eine 19-Stunden-Woche ein und beantragt einen Urlaubstag. Nach Adminfreigabe zeigt das Zeitkonto 11 Stunden (10 Stunden Anfangssaldo + 1 Stunde Wochenplus) und das Urlaubskonto 17 Tage. Der Urlaub erscheint im Teamkalender.
Ergebnisse der abschließenden Prüfung:
| Prüfung | Ergebnis |
| --- | --- |
| Berechnungstests | 9 bestanden. |
| Integrationstests | 12 bestanden; Testkitas danach bereinigt. |
| TypeScript | Erfolgreich. |
| ESLint für sämtliche geänderten Anwendungsteile und neue Tests | Erfolgreich, ohne Warnungen. |
| Projektweites ESLint | Die bereits vorhandenen zwei `as any`-Fehler in `src/lib/auth-utils.ts` und neun Warnungen bestehen weiterhin. |
| Endgültiger Produktionsbuild | Erfolgreich, einschließlich `/dashboard/personal`. |
| SQL-Skript gegen Ausgangsschema | Erfolgreich im isolierten Prüfschema; anschließend kein Unterschied zum Prisma-Schema. |
| Browser | Admin- und ErzieherInnen-Ablauf einschließlich Freigaben erfolgreich. Mobile Ansicht und Arbeitszeitdialog ohne Seitenüberlauf geprüft. |
Die vom bestehenden Build gemeldete Warnung zu mehreren Lockfiles bzw. dem Turbopack-Arbeitsverzeichnis und die bestehende Prisma-Konfigurationswarnung sind unabhängig vom Personalbereich. Eine produktive Bereitstellung oder Mailzustellung wurde nicht durchgeführt.
## E-Mail-Erweiterung zur gesonderten Freigabe
Die automatische Freigabeprüfung hat neue ausgehende E-Mails mit Einladungstokens und Personaldaten abgelehnt, weil eine ausdrückliche Zustimmung für diese Daten und Ziele fehlt. Interne Hinweise und Aktivierungslinks sind umgesetzt. Für einen späteren Versand wäre folgender begrenzter Umfang vorgesehen:
| Nachricht | Empfänger | Inhalt |
| --- | --- | --- |
| Accountaktivierung | Vom Kita-Admin eingetragene E-Mail-Adresse der Fachkraft | Kita, Name, persönlicher Aktivierungslink mit sieben Tagen Gültigkeit. |
| Antrag oder Arbeitswoche eingereicht | Account-Adressen der Kita-Admins derselben Kita | Name, Zeitraum und Hinweis auf Prüfung im geschützten Personalbereich. |
| Entscheidung / Rückgabe | Account-Adresse der betroffenen Fachkraft | Art, Zeitraum und Status mit Link in den geschützten Personalbereich. |
Krankheitsdetails, private Notizen, Zeit- und Urlaubskontostände würden nicht per E-Mail übertragen. Hierfür wurde kein Live-Versandcode hinzugefügt und keine Nachricht verschickt.
+2
View File
@@ -9,6 +9,8 @@
"start": "next start", "start": "next start",
"start:prod": "next start", "start:prod": "next start",
"lint": "eslint", "lint": "eslint",
"test:staff": "tsx --test tests/staff-calculations.test.ts",
"test:staff:integration": "tsx --test tests/staff-service.test.ts",
"prisma:generate": "prisma generate", "prisma:generate": "prisma generate",
"prisma:migrate": "prisma migrate dev", "prisma:migrate": "prisma migrate dev",
"prisma:studio": "prisma studio", "prisma:studio": "prisma studio",
+206
View File
@@ -144,6 +144,8 @@ model Kita {
notdienstAssignments NotdienstAssignment[] notdienstAssignments NotdienstAssignment[]
notdienstAlerts NotdienstAlert[] notdienstAlerts NotdienstAlert[]
notdienstSwapRequests NotdienstSwapRequest[] notdienstSwapRequests NotdienstSwapRequest[]
staffProfiles StaffProfile[]
staffHolidays StaffHoliday[]
@@map("kitas") @@map("kitas")
} }
@@ -239,6 +241,8 @@ model User {
mitbringselItems MitbringselItem[] mitbringselItems MitbringselItem[]
invitationsCreated Invitation[] @relation("InvitationCreator") invitationsCreated Invitation[] @relation("InvitationCreator")
auditLogsAuthored AuditLog[] @relation("AuditLogActor") auditLogsAuthored AuditLog[] @relation("AuditLogActor")
staffProfile StaffProfile?
staffNotifications StaffNotification[]
@@index([kitaId]) @@index([kitaId])
@@index([familyId]) @@index([familyId])
@@ -295,11 +299,213 @@ model Educator {
updatedAt DateTime @updatedAt updatedAt DateTime @updatedAt
notdienstAlerts NotdienstAlert[] notdienstAlerts NotdienstAlert[]
staffProfile StaffProfile?
@@index([kitaId]) @@index([kitaId])
@@map("educators") @@map("educators")
} }
// Personalbereich: Tage als UTC-Datum, Zeiten als Minuten, Anspruch in halben Tagen.
enum StaffRequestStatus {
PENDING
APPROVED
REJECTED
CANCEL_REQUESTED
CANCELLED
}
enum StaffLeaveKind {
VACATION
TIME_OFF
SICKNESS
}
enum StaffWeekStatus {
DRAFT
SUBMITTED
APPROVED
}
model StaffProfile {
id String @id @default(cuid())
kitaId String
kita Kita @relation(fields: [kitaId], references: [id], onDelete: Cascade)
educatorId String @unique
educator Educator @relation(fields: [educatorId], references: [id], onDelete: NoAction)
userId String? @unique
user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
employmentStart DateTime @db.Date
employmentEnd DateTime? @db.Date
trackingStart DateTime @db.Date
openingMinutes Int @default(0)
createdAt DateTime @default(now())
workPatterns StaffWorkPattern[]
dayOverrides StaffDayOverride[]
leaveAccounts StaffLeaveAccount[]
leaves StaffLeave[]
timeEntries StaffTimeEntry[]
weeks StaffWeek[]
adjustments StaffAdjustment[]
history StaffHistory[]
notifications StaffNotification[]
@@index([kitaId])
@@map("staff_profiles")
}
model StaffWorkPattern {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
effectiveFrom DateTime @db.Date
// Montag bis Sonntag; 0 bedeutet arbeitsfrei.
dailyMinutes Int[]
@@unique([profileId, effectiveFrom])
@@map("staff_work_patterns")
}
model StaffDayOverride {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
date DateTime @db.Date
minutes Int
reason String
@@unique([profileId, date])
@@map("staff_day_overrides")
}
model StaffHoliday {
id String @id @default(cuid())
kitaId String
kita Kita @relation(fields: [kitaId], references: [id], onDelete: Cascade)
date DateTime @db.Date
name String
@@unique([kitaId, date])
@@map("staff_holidays")
}
model StaffLeaveAccount {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
year Int
entitlementUnits Int
carryUnits Int @default(0)
@@unique([profileId, year])
@@map("staff_leave_accounts")
}
model StaffLeave {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
kind StaffLeaveKind
status StaffRequestStatus @default(PENDING)
startDate DateTime @db.Date
endDate DateTime @db.Date
halfDay Boolean @default(false)
minutes Int?
note String?
decisionNote String?
requestedById String
reviewedById String?
reviewedAt DateTime?
createdAt DateTime @default(now())
days StaffLeaveDay[]
@@index([profileId, status, startDate])
@@map("staff_leaves")
}
model StaffLeaveDay {
id String @id @default(cuid())
leaveId String
leave StaffLeave @relation(fields: [leaveId], references: [id], onDelete: Cascade)
date DateTime @db.Date
vacationUnits Int @default(0)
creditMinutes Int
@@unique([leaveId, date])
@@map("staff_leave_days")
}
model StaffTimeEntry {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
date DateTime @db.Date
startMinute Int
endMinute Int
breakMinutes Int @default(0)
note String?
@@index([profileId, date])
@@map("staff_time_entries")
}
model StaffWeek {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
weekStart DateTime @db.Date
status StaffWeekStatus @default(DRAFT)
submittedAt DateTime?
reviewedAt DateTime?
reviewedById String?
decisionNote String?
// Snapshot von Soll-, Ist- und Abwesenheitsminuten bei Genehmigung.
dailySnapshot Json?
@@unique([profileId, weekStart])
@@map("staff_weeks")
}
model StaffAdjustment {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
date DateTime @db.Date
minutes Int
reason String
actorId String
createdAt DateTime @default(now())
@@index([profileId, date])
@@map("staff_adjustments")
}
model StaffHistory {
id String @id @default(cuid())
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
actorId String
action String
details String
createdAt DateTime @default(now())
@@index([profileId, createdAt])
@@map("staff_history")
}
model StaffNotification {
id String @id @default(cuid())
userId String
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
profileId String
profile StaffProfile @relation(fields: [profileId], references: [id], onDelete: Cascade)
message String
readAt DateTime?
createdAt DateTime @default(now())
@@index([userId, readAt, createdAt])
@@map("staff_notifications")
}
// ===================================================================== // =====================================================================
// PARENT DUTIES (Feste Ämter / Elterndienste, Modul 3) // PARENT DUTIES (Feste Ämter / Elterndienste, Modul 3)
// ===================================================================== // =====================================================================
@@ -1,6 +1,7 @@
"use client"; "use client";
import { useState, useTransition } from "react"; import { useState, useTransition } from "react";
import Link from "next/link";
import { Plus, Pencil, Search, Trash2 } from "lucide-react"; import { Plus, Pencil, Search, Trash2 } from "lucide-react";
import { toast } from "sonner"; import { toast } from "sonner";
@@ -40,7 +41,9 @@ type EducatorDto = {
export function ErzieherList({ educators }: { educators: EducatorDto[] }) { export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
const [openCreate, setOpenCreate] = useState(false); const [openCreate, setOpenCreate] = useState(false);
const [editingEducator, setEditingEducator] = useState<EducatorDto | null>(null); const [editingEducator, setEditingEducator] = useState<EducatorDto | null>(
null,
);
const [educatorToDelete, setEducatorToDelete] = useState<EducatorDto | null>( const [educatorToDelete, setEducatorToDelete] = useState<EducatorDto | null>(
null, null,
); );
@@ -132,8 +135,16 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
</div> </div>
</div> </div>
<DialogFooter> <DialogFooter>
<Button type="button" variant="ghost" onClick={() => setOpenCreate(false)}>Abbrechen</Button> <Button
<Button type="submit" disabled={isPending}>Speichern</Button> type="button"
variant="ghost"
onClick={() => setOpenCreate(false)}
>
Abbrechen
</Button>
<Button type="submit" disabled={isPending}>
Speichern
</Button>
</DialogFooter> </DialogFooter>
</form> </form>
</DialogContent> </DialogContent>
@@ -182,7 +193,9 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
) : ( ) : (
educators.map((ed) => ( educators.map((ed) => (
<TableRow key={ed.id}> <TableRow key={ed.id}>
<TableCell className="pl-6 font-medium">{ed.firstName}</TableCell> <TableCell className="pl-6 font-medium">
{ed.firstName}
</TableCell>
<TableCell>{ed.lastName}</TableCell> <TableCell>{ed.lastName}</TableCell>
<TableCell> <TableCell>
<Badge variant={ed.active ? "success" : "secondary"}> <Badge variant={ed.active ? "success" : "secondary"}>
@@ -190,7 +203,23 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
</Badge> </Badge>
</TableCell> </TableCell>
<TableCell className="pr-6 text-right"> <TableCell className="pr-6 text-right">
<Button variant="ghost" size="icon" onClick={() => setEditingEducator(ed)}> <Button
variant="outline"
size="sm"
asChild
className="mr-2"
>
<Link
href={`/dashboard/personal?tab=verwaltung&educator=${ed.id}`}
>
Personalprofil
</Link>
</Button>
<Button
variant="ghost"
size="icon"
onClick={() => setEditingEducator(ed)}
>
<Pencil className="h-4 w-4 [stroke-width:1.7]" /> <Pencil className="h-4 w-4 [stroke-width:1.7]" />
</Button> </Button>
<Button <Button
@@ -213,7 +242,10 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
</Card> </Card>
{/* Edit Dialog */} {/* Edit Dialog */}
<Dialog open={!!editingEducator} onOpenChange={(open) => !open && setEditingEducator(null)}> <Dialog
open={!!editingEducator}
onOpenChange={(open) => !open && setEditingEducator(null)}
>
<DialogContent> <DialogContent>
<form action={handleUpdate}> <form action={handleUpdate}>
<DialogHeader> <DialogHeader>
@@ -223,21 +255,43 @@ export function ErzieherList({ educators }: { educators: EducatorDto[] }) {
<div className="grid gap-4 py-4"> <div className="grid gap-4 py-4">
<div className="grid gap-2"> <div className="grid gap-2">
<Label htmlFor="edit-firstName">Vorname</Label> <Label htmlFor="edit-firstName">Vorname</Label>
<Input id="edit-firstName" name="firstName" defaultValue={editingEducator.firstName} required /> <Input
id="edit-firstName"
name="firstName"
defaultValue={editingEducator.firstName}
required
/>
</div> </div>
<div className="grid gap-2"> <div className="grid gap-2">
<Label htmlFor="edit-lastName">Nachname</Label> <Label htmlFor="edit-lastName">Nachname</Label>
<Input id="edit-lastName" name="lastName" defaultValue={editingEducator.lastName} required /> <Input
id="edit-lastName"
name="lastName"
defaultValue={editingEducator.lastName}
required
/>
</div> </div>
<div className="flex items-center gap-2 mt-2"> <div className="flex items-center gap-2 mt-2">
<Switch id="edit-active" name="active" defaultChecked={editingEducator.active} /> <Switch
id="edit-active"
name="active"
defaultChecked={editingEducator.active}
/>
<Label htmlFor="edit-active">Aktiv</Label> <Label htmlFor="edit-active">Aktiv</Label>
</div> </div>
</div> </div>
)} )}
<DialogFooter> <DialogFooter>
<Button type="button" variant="ghost" onClick={() => setEditingEducator(null)}>Abbrechen</Button> <Button
<Button type="submit" disabled={isPending}>Aktualisieren</Button> type="button"
variant="ghost"
onClick={() => setEditingEducator(null)}
>
Abbrechen
</Button>
<Button type="submit" disabled={isPending}>
Aktualisieren
</Button>
</DialogFooter> </DialogFooter>
</form> </form>
</DialogContent> </DialogContent>
+8
View File
@@ -84,6 +84,14 @@ export async function deleteEducator(id: string) {
} }
try { try {
const profile = await prisma.staffProfile.findFirst({
where: { educatorId: id, kitaId },
});
if (profile)
return {
error:
"Diese Fachkraft hat ein Personalprofil. Bitte auf inaktiv setzen, damit Zeiten und Konten erhalten bleiben.",
};
await prisma.educator.delete({ await prisma.educator.delete({
where: { where: {
id, id,
+2 -2
View File
@@ -36,8 +36,8 @@ export default async function ErzieherPage() {
</em> </em>
</h1> </h1>
<p className="mt-2 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]"> <p className="mt-2 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
Stammdaten des Kita-Personals für interne Planung und spätere Stammdaten des Teams und Zugang zu Beschäftigungsprofilen,
Notdienst-Alarmierung. Urlaubsansprüchen und Arbeitszeitmodellen.
</p> </p>
</div> </div>
<div className="flex shrink-0 flex-wrap gap-2"> <div className="flex shrink-0 flex-wrap gap-2">
+28 -4
View File
@@ -191,8 +191,7 @@ export default async function DashboardPage() {
</h1> </h1>
<p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]"> <p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
Heute, {format(now, "EEEE, d. MMMM yyyy", { locale: de })}. Hier Heute, {format(now, "EEEE, d. MMMM yyyy", { locale: de })}. Hier
siehst du auf einen Blick, was bei {kita.name} ansteht und kannst siehst du auf einen Blick, was bei {kita.name} ansteht.
dein Kind schnell für Abwesenheiten melden.
</p> </p>
</div> </div>
<div className="mt-9 inline-flex shrink-0 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-4 py-2 text-[13px] font-semibold text-[var(--ink-soft)]"> <div className="mt-9 inline-flex shrink-0 items-center gap-2 rounded-full border border-[var(--hairline)] bg-[var(--surface)] px-4 py-2 text-[13px] font-semibold text-[var(--ink-soft)]">
@@ -203,6 +202,14 @@ export default async function DashboardPage() {
<div className="grid grid-cols-[minmax(0,1fr)_360px] gap-5 max-[1100px]:grid-cols-1"> <div className="grid grid-cols-[minmax(0,1fr)_360px] gap-5 max-[1100px]:grid-cols-1">
<div className="min-w-0"> <div className="min-w-0">
{session.user.role === UserRole.ERZIEHER && (
<QuickCard
href="/dashboard/personal"
icon={Clock3}
title="Meine Arbeitszeit & Urlaub"
sub="Stunden erfassen, Urlaub beantragen und dein Zeitkonto ansehen."
/>
)}
{canReportAbsences ? ( {canReportAbsences ? (
<AbsenceCard <AbsenceCard
today={format(today, "yyyy-MM-dd")} today={format(today, "yyyy-MM-dd")}
@@ -237,7 +244,11 @@ export default async function DashboardPage() {
</div> </div>
<section className="mt-5 grid grid-cols-4 gap-3.5 max-[1100px]:grid-cols-2 max-[640px]:grid-cols-1"> <section className="mt-5 grid grid-cols-4 gap-3.5 max-[1100px]:grid-cols-2 max-[640px]:grid-cols-1">
<Stat label="Familien" value={familyCount} hint="registrierte Familien" /> <Stat
label="Familien"
value={familyCount}
hint="registrierte Familien"
/>
<Stat label="Kinder" value={childCount} hint="in der Einrichtung" /> <Stat label="Kinder" value={childCount} hint="in der Einrichtung" />
<Stat <Stat
label={`Notdienst ${targetData.monthName}`} label={`Notdienst ${targetData.monthName}`}
@@ -260,12 +271,22 @@ export default async function DashboardPage() {
Häufige Aktionen für Vorstand und Koordination. Häufige Aktionen für Vorstand und Koordination.
</p> </p>
<div className="mt-4 grid grid-cols-3 gap-3 max-[1100px]:grid-cols-1"> <div className="mt-4 grid grid-cols-3 gap-3 max-[1100px]:grid-cols-1">
{session.user.role === UserRole.ADMIN && (
<QuickCard
href="/dashboard/personal"
icon={Clock3}
title="Personal & Freigaben"
sub="Urlaub, Arbeitswochen und Beschäftigungsprofile verwalten."
/>
)}
{session.user.role === UserRole.ADMIN && (
<QuickCard <QuickCard
href="/dashboard/families" href="/dashboard/families"
icon={Users} icon={Users}
title="Familien verwalten" title="Familien verwalten"
sub="Familien anlegen, Kinder zuordnen, Kontakte pflegen." sub="Familien anlegen, Kinder zuordnen, Kontakte pflegen."
/> />
)}
{kita.terminModuleEnabled ? ( {kita.terminModuleEnabled ? (
<QuickCard <QuickCard
href="/dashboard/kalender" href="/dashboard/kalender"
@@ -274,7 +295,10 @@ export default async function DashboardPage() {
sub="Schließtage, Elternabende und Feste planen." sub="Schließtage, Elternabende und Feste planen."
/> />
) : null} ) : null}
{kita.notdienstModuleEnabled ? ( {kita.notdienstModuleEnabled &&
[UserRole.ADMIN, UserRole.KOORDINATOR].includes(
session.user.role as "ADMIN" | "KOORDINATOR",
) ? (
<QuickCard <QuickCard
href="/dashboard/notdienst/plan" href="/dashboard/notdienst/plan"
icon={ListTodo} icon={ListTodo}
+45
View File
@@ -0,0 +1,45 @@
"use server";
import { revalidatePath } from "next/cache";
import { z } from "zod";
import { requireStaffActor } from "@/lib/staff/auth";
import { executeStaffCommand } from "@/lib/staff/service";
export type StaffActionResult = {
error?: string;
success?: boolean;
invitePath?: string;
};
export async function staffAction(
command: string,
data: Record<string, unknown>,
): Promise<StaffActionResult> {
const actor = await requireStaffActor();
try {
const result = await executeStaffCommand(actor, { command, data });
revalidatePath("/dashboard/personal");
revalidatePath("/dashboard/profil");
revalidatePath("/dashboard/erzieher");
revalidatePath("/dashboard");
// Returned only to the authenticated admin who generated this single-use link.
return {
success: true,
...(result.invite
? { invitePath: `/invite/${result.invite.token}` }
: {}),
};
} catch (error) {
if (error instanceof z.ZodError)
return {
error: error.issues[0]?.message ?? "Bitte die Eingaben prüfen.",
};
if (
error instanceof Error &&
!error.message.includes("prisma") &&
!error.message.includes("Invalid `")
)
return { error: error.message };
return { error: "Speichern fehlgeschlagen. Bitte erneut versuchen." };
}
}
+757
View File
@@ -0,0 +1,757 @@
"use client";
import { useId, useState, useTransition, type ReactNode } from "react";
import { useRouter } from "next/navigation";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import {
Dialog,
DialogContent,
DialogDescription,
DialogHeader,
DialogTitle,
DialogTrigger,
} from "@/components/ui/dialog";
import {
DAY_NAMES,
clockMinute,
minuteClock,
todayKey,
} from "@/lib/staff/calculations";
import { staffAction, type StaffActionResult } from "./actions";
const control =
"w-full rounded-lg border border-[var(--hairline)] bg-[var(--surface)] px-3 py-2 text-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--accent-mid)]";
export function Field({
label,
name,
type = "text",
value,
required = true,
min,
max,
step,
}: {
label: string;
name: string;
type?: string;
value?: string | number;
required?: boolean;
min?: string | number;
max?: string | number;
step?: string | number;
}) {
const id = useId();
return (
<div className="grid gap-1.5">
<label htmlFor={id} className="text-sm font-medium">
{label}
</label>
<Input
id={id}
name={name}
type={type}
defaultValue={value}
required={required}
min={min}
max={max}
step={step}
/>
</div>
);
}
function transform(command: string, form: FormData) {
const text = (key: string) => String(form.get(key) ?? "");
const num = (key: string) => Number(text(key));
const hours = (key: string) => Math.round(num(key) * 60);
switch (command) {
case "setup":
return {
educatorId: text("educatorId"),
employmentStart: text("employmentStart"),
employmentEnd: text("employmentEnd") || null,
trackingStart: text("trackingStart"),
openingMinutes: hours("openingHours"),
reason: text("reason"),
};
case "invite":
return { email: text("email") };
case "employmentEnd":
return {
employmentEnd: text("employmentEnd") || null,
reason: text("reason"),
};
case "pattern":
return {
effectiveFrom: text("effectiveFrom"),
dailyMinutes: DAY_NAMES.map((_, i) => hours(`day${i}`)),
reason: text("reason"),
};
case "account":
return {
year: num("year"),
entitlementUnits: Math.round(num("entitlement") * 2),
carryUnits: Math.round(num("carry") * 2),
reason: text("reason"),
};
case "override":
return {
date: text("date"),
minutes: hours("hours"),
reason: text("reason"),
};
case "adjust":
return {
date: text("date"),
minutes: hours("hours"),
reason: text("reason"),
};
case "holiday":
return { date: text("date"), name: text("name") };
case "time":
return {
date: text("date"),
startMinute: clockMinute(text("start")),
endMinute: clockMinute(text("end")),
breakMinutes: num("breakMinutes"),
note: text("note"),
};
case "leave":
return {
kind: text("kind"),
startDate: text("startDate"),
endDate: text("endDate"),
halfDay: form.get("halfDay") === "on",
...(text("kind") === "TIME_OFF" ? { minutes: hours("hours") } : {}),
note: text("note"),
};
case "leaveReview":
case "weekReview":
return { reason: text("reason") };
default:
return {};
}
}
function StaffForm({
command,
profileId,
extra = {},
children,
label = "Speichern",
onSuccess,
}: {
command: string;
profileId?: string;
extra?: Record<string, unknown>;
children: ReactNode;
label?: string;
onSuccess?: (result: StaffActionResult) => void;
}) {
const [pending, start] = useTransition();
const [error, setError] = useState("");
const router = useRouter();
return (
<form
className="grid gap-4"
onSubmit={(event) => {
event.preventDefault();
const form = new FormData(event.currentTarget);
setError("");
start(async () => {
try {
const result = await staffAction(command, {
...transform(command, form),
...extra,
...(profileId ? { profileId } : {}),
});
if (result.error) {
setError(result.error);
return;
}
toast.success("Gespeichert.");
onSuccess?.(result);
router.refresh();
} catch (error) {
setError(
error instanceof Error
? error.message
: "Speichern fehlgeschlagen.",
);
}
});
}}
>
<fieldset disabled={pending} className="grid gap-4 disabled:opacity-60">
{children}
<div>
<Button type="submit">
{pending ? "Wird gespeichert …" : label}
</Button>
</div>
</fieldset>
{error && (
<p role="alert" className="text-sm text-[var(--danger)]">
{error}
</p>
)}
</form>
);
}
export function CommandButton({
command,
profileId,
data,
children,
variant = "outline",
}: {
command: string;
profileId: string;
data: Record<string, unknown>;
children: ReactNode;
variant?: "outline" | "ghost" | "default";
}) {
const [pending, start] = useTransition();
const router = useRouter();
return (
<Button
type="button"
variant={variant}
size="sm"
disabled={pending}
onClick={() =>
start(async () => {
const result = await staffAction(command, { ...data, profileId });
if (result.error) toast.error(result.error);
else {
toast.success("Gespeichert.");
router.refresh();
}
})
}
>
{pending ? "Bitte warten …" : children}
</Button>
);
}
export function ReviewButton({
command,
profileId,
data,
label,
approve,
}: {
command: "leaveReview" | "weekReview";
profileId: string;
data: Record<string, unknown>;
label: string;
approve: boolean;
}) {
const [open, setOpen] = useState(false);
return (
<Dialog open={open} onOpenChange={setOpen}>
<DialogTrigger asChild>
<Button size="sm" variant={approve ? "default" : "outline"}>
{label}
</Button>
</DialogTrigger>
<DialogContent>
<DialogHeader>
<DialogTitle>{label}</DialogTitle>
<DialogDescription>
Die Entscheidung wird im Personalverlauf dokumentiert.
</DialogDescription>
</DialogHeader>
<StaffForm
command={command}
profileId={profileId}
extra={{ ...data, approve }}
label={label}
onSuccess={() => setOpen(false)}
>
<Field label="Begründung / Rückmeldung" name="reason" />
</StaffForm>
</DialogContent>
</Dialog>
);
}
export function SetupForm({
educatorId,
values,
}: {
educatorId: string;
values?: {
employmentStart: string;
employmentEnd: string | null;
trackingStart: string;
openingMinutes: number;
};
}) {
return (
<StaffForm
command="setup"
extra={{ educatorId }}
label="Beschäftigungsprofil speichern"
>
<input type="hidden" name="educatorId" value={educatorId} />
<div className="grid gap-4 sm:grid-cols-2">
<Field
label="Beschäftigung ab"
name="employmentStart"
type="date"
value={values?.employmentStart ?? todayKey()}
/>
<Field
label="Beschäftigung bis (optional)"
name="employmentEnd"
type="date"
value={values?.employmentEnd ?? ""}
required={false}
/>
<Field
label="Zeiterfassung ab"
name="trackingStart"
type="date"
value={values?.trackingStart ?? todayKey()}
/>
<Field
label="Anfangssaldo in Stunden"
name="openingHours"
type="number"
step="any"
value={(values?.openingMinutes ?? 0) / 60}
/>
</div>
<Field label="Begründung" name="reason" value="Ersteinrichtung" />
</StaffForm>
);
}
export function TimeForm({
profileId,
initial,
}: {
profileId: string;
initial?: {
id: string;
date: string;
startMinute: number;
endMinute: number;
breakMinutes: number;
note: string | null;
};
}) {
const [open, setOpen] = useState(false);
return (
<Dialog open={open} onOpenChange={setOpen}>
<DialogTrigger asChild>
<Button
variant={initial ? "outline" : "default"}
size={initial ? "sm" : "default"}
>
{initial ? "Bearbeiten" : "+ Arbeitszeit erfassen"}
</Button>
</DialogTrigger>
<DialogContent>
<DialogHeader>
<DialogTitle>
{initial ? "Arbeitszeit bearbeiten" : "Arbeitszeit erfassen"}
</DialogTitle>
<DialogDescription>
Erfasse Beginn, Ende und die gesamte Pause dieses Arbeitsblocks.
Weitere Blöcke am selben Tag sind möglich.
</DialogDescription>
</DialogHeader>
<StaffForm
command="time"
profileId={profileId}
extra={initial ? { id: initial.id } : {}}
label="Arbeitszeit speichern"
onSuccess={() => setOpen(false)}
>
<Field
label="Datum"
name="date"
type="date"
value={initial?.date ?? todayKey()}
max={todayKey()}
/>
<div className="grid grid-cols-2 gap-4">
<Field
label="Beginn"
name="start"
type="time"
value={minuteClock(initial?.startMinute ?? 480)}
/>
<Field
label="Ende"
name="end"
type="time"
value={minuteClock(initial?.endMinute ?? 960)}
/>
</div>
<Field
label="Pause in Minuten"
name="breakMinutes"
type="number"
min={0}
step={1}
value={initial?.breakMinutes ?? 30}
/>
<Field
label="Notiz (optional)"
name="note"
value={initial?.note ?? ""}
required={false}
/>
</StaffForm>
</DialogContent>
</Dialog>
);
}
export function LeaveForm({
profileId,
admin,
initial,
}: {
profileId: string;
admin: boolean;
initial?: {
id: string;
kind: string;
startDate: string;
endDate: string;
halfDay: boolean;
minutes: number | null;
note: string | null;
};
}) {
const [open, setOpen] = useState(false);
const [kind, setKind] = useState(initial?.kind ?? "VACATION");
const id = useId();
return (
<Dialog open={open} onOpenChange={setOpen}>
<DialogTrigger asChild>
<Button size={initial ? "sm" : "default"} variant="outline">
{initial ? "Ändern" : "+ Abwesenheit beantragen"}
</Button>
</DialogTrigger>
<DialogContent>
<DialogHeader>
<DialogTitle>
{initial ? "Antrag ändern" : "Abwesenheit beantragen"}
</DialogTitle>
<DialogDescription>
Urlaub verbraucht nur deine vorgesehenen Arbeitstage.
Freizeitausgleich wird in Stunden für einen einzelnen Tag beantragt.
</DialogDescription>
</DialogHeader>
<StaffForm
command="leave"
profileId={profileId}
extra={initial ? { id: initial.id } : {}}
label={
kind === "SICKNESS" ? "Krankheit hinterlegen" : "Antrag speichern"
}
onSuccess={() => setOpen(false)}
>
<div className="grid gap-1.5">
<label htmlFor={`${id}-kind`} className="text-sm font-medium">
Art
</label>
<select
id={`${id}-kind`}
name="kind"
className={control}
value={kind}
onChange={(e) => setKind(e.target.value)}
>
<option value="VACATION">Urlaub</option>
<option value="TIME_OFF">Freizeitausgleich</option>
{admin && <option value="SICKNESS">Krankheit</option>}
</select>
</div>
<div className="grid grid-cols-2 gap-4">
<Field
label="Von"
name="startDate"
type="date"
value={initial?.startDate ?? todayKey()}
/>
<Field
label="Bis"
name="endDate"
type="date"
value={initial?.endDate ?? todayKey()}
/>
</div>
{kind === "VACATION" && (
<label className="flex items-center gap-2 text-sm">
<input
name="halfDay"
type="checkbox"
defaultChecked={initial?.halfDay}
/>
Halber Urlaubstag (Von = Bis)
</label>
)}
{kind === "TIME_OFF" && (
<Field
label="Freizeitausgleich in Stunden (Von = Bis)"
name="hours"
type="number"
min={1 / 60}
max={16}
step="any"
value={(initial?.minutes ?? 60) / 60}
/>
)}
<Field
label="Notiz (optional)"
name="note"
value={initial?.note ?? ""}
required={false}
/>
<p className="text-xs leading-5 text-[var(--ink-soft)]">
Der Antrag wird anhand deines Wochenmodells, der Tagesausnahmen und
der Feiertage geprüft. Ein halber Tag entspricht der Hälfte der
Sollzeit.
</p>
</StaffForm>
</DialogContent>
</Dialog>
);
}
function SettingsSection({
title,
children,
}: {
title: string;
children: ReactNode;
}) {
return (
<details className="rounded-xl border border-[var(--hairline)] bg-[var(--surface)] p-5">
<summary className="cursor-pointer font-semibold">{title}</summary>
<div className="mt-5">{children}</div>
</details>
);
}
export function SettingsPanel({
profileId,
educatorId,
employment,
email,
verified,
pattern,
year,
account,
}: {
profileId: string;
educatorId: string;
employment: {
employmentStart: string;
employmentEnd: string | null;
trackingStart: string;
openingMinutes: number;
};
email?: string;
verified: boolean;
pattern?: { effectiveFrom: string; dailyMinutes: number[] };
year: number;
account?: { entitlementUnits: number; carryUnits: number };
}) {
const [invitePath, setInvitePath] = useState("");
return (
<div className="grid gap-3">
<SettingsSection title="Zugang zur Zeiterfassung">
{verified ? (
<p className="text-sm">Aktives Konto: {email}</p>
) : (
<StaffForm
command="invite"
profileId={profileId}
label="Aktivierungslink erstellen"
onSuccess={(r) => setInvitePath(r.invitePath ?? "")}
>
<Field
label="E-Mail-Adresse"
name="email"
type="email"
value={email ?? ""}
/>
<p className="text-sm text-[var(--ink-soft)]">
Erstellt oder verknüpft einen ErzieherInnen-Account. Der
persönliche Link ist sieben Tage gültig. Ein neuer Link ersetzt
den vorherigen.
</p>
</StaffForm>
)}
{invitePath && (
<div className="mt-4 grid gap-2 rounded-lg bg-[var(--accent-soft)] p-4">
<label htmlFor="activation-link" className="text-sm font-medium">
Persönlicher Aktivierungslink
</label>
<Input
id="activation-link"
readOnly
value={`${window.location.origin}${invitePath}`}
/>
<Button
variant="outline"
onClick={async () => {
await navigator.clipboard.writeText(
`${window.location.origin}${invitePath}`,
);
toast.success("Link kopiert.");
}}
>
Link kopieren
</Button>
<p className="text-xs">
Bitte persönlich an die Fachkraft weitergeben. Es wird keine
E-Mail versendet.
</p>
</div>
)}
</SettingsSection>
<SettingsSection title="Feste Wochentage & Sollstunden">
<StaffForm
command="pattern"
profileId={profileId}
label="Wochenmodell speichern"
>
<Field
label="Gültig ab"
name="effectiveFrom"
type="date"
value={pattern?.effectiveFrom ?? employment.trackingStart}
/>
<div className="grid gap-3 sm:grid-cols-2">
{DAY_NAMES.map((day, i) => (
<Field
key={day}
label={`${day} · Stunden`}
name={`day${i}`}
type="number"
min={0}
max={16}
step="any"
value={(pattern?.dailyMinutes[i] ?? 0) / 60}
/>
))}
</div>
<Field label="Begründung" name="reason" />
<p className="text-xs text-[var(--ink-soft)]">
0 Stunden = frei. Stunden sind Nettozeiten ohne Pause. Änderungen
gelten ab dem gewählten Datum; ältere Modelle bleiben erhalten.
</p>
</StaffForm>
</SettingsSection>
<SettingsSection title={`Urlaubsanspruch & Übertrag · ${year}`}>
<StaffForm command="account" profileId={profileId}>
<Field
label="Jahr"
name="year"
type="number"
min={2000}
max={2100}
value={year}
/>
<div className="grid grid-cols-2 gap-4">
<Field
label="Jahresanspruch in Tagen"
name="entitlement"
type="number"
min={0}
max={400}
step={0.5}
value={(account?.entitlementUnits ?? 0) / 2}
/>
<Field
label="Übertrag in Tagen"
name="carry"
type="number"
min={0}
max={400}
step={0.5}
value={(account?.carryUnits ?? 0) / 2}
/>
</div>
<Field label="Begründung" name="reason" />
<p className="text-xs text-[var(--ink-soft)]">
Anspruch individuell für die Arbeitstage dieser Person hinterlegen.
Der Übertrag wird ausdrücklich festgelegt.
</p>
</StaffForm>
</SettingsSection>
<SettingsSection title="Ausnahme für einen einzelnen Tag">
<StaffForm command="override" profileId={profileId}>
<Field label="Datum" name="date" type="date" value={todayKey()} />
<Field
label="Abweichende Sollstunden (0 = frei)"
name="hours"
type="number"
min={0}
max={16}
step="any"
value={0}
/>
<Field label="Begründung" name="reason" />
<p className="text-xs text-[var(--ink-soft)]">
Bei einem Tausch beide Tage erfassen: den ursprünglichen Tag auf 0
setzen und den neuen Arbeitstag mit Sollstunden hinterlegen.
</p>
</StaffForm>
</SettingsSection>
<SettingsSection title="Zeitkonto korrigieren">
<StaffForm command="adjust" profileId={profileId}>
<Field
label="Buchungsdatum"
name="date"
type="date"
value={todayKey()}
/>
<Field
label="Korrektur in Stunden (mit Vorzeichen)"
name="hours"
type="number"
step="any"
/>
<Field label="Begründung" name="reason" />
<p className="text-xs text-[var(--ink-soft)]">
Korrekturen bleiben im Verlauf erhalten. Falsche Buchungen durch
eine Gegenbuchung berichtigen.
</p>
</StaffForm>
</SettingsSection>
<SettingsSection title="Beschäftigungsbeginn & Anfangssaldo">
<SetupForm educatorId={educatorId} values={employment} />
<p className="mt-3 text-xs text-[var(--ink-soft)]">
Die Grunddaten sind geschützt, sobald Zeiten, Wochen oder Anträge
erfasst wurden.
</p>
</SettingsSection>
<SettingsSection title="Beschäftigungsende ändern">
<StaffForm command="employmentEnd" profileId={profileId}>
<Field
label="Beschäftigung bis (leer = unbefristet)"
name="employmentEnd"
type="date"
value={employment.employmentEnd ?? ""}
required={false}
/>
<Field label="Begründung" name="reason" />
</StaffForm>
</SettingsSection>
</div>
);
}
export function HolidayForm() {
return (
<StaffForm command="holiday" label="Feiertag speichern">
<div className="grid gap-4 sm:grid-cols-2">
<Field label="Datum" name="date" type="date" />
<Field label="Bezeichnung" name="name" />
</div>
</StaffForm>
);
}
File diff suppressed because it is too large Load Diff
+36 -4
View File
@@ -1,5 +1,7 @@
import { format } from "date-fns"; import { format } from "date-fns";
import { de } from "date-fns/locale"; import { de } from "date-fns/locale";
import Link from "next/link";
import { UserRole } from "@prisma/client";
import { import {
AtSign, AtSign,
Baby, Baby,
@@ -96,7 +98,9 @@ export default async function ProfilPage() {
</em> </em>
</h1> </h1>
<p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]"> <p className="mt-3 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
Deine persönlichen Daten, verknüpfte Kinder und DSGVO-Einstellungen. {user.role === UserRole.ERZIEHER
? "Deine persönlichen Daten, dein Arbeitsbereich und Datenschutzeinstellungen."
: "Deine persönlichen Daten, verknüpfte Kinder und DSGVO-Einstellungen."}
</p> </p>
</header> </header>
@@ -124,7 +128,12 @@ export default async function ProfilPage() {
label="Telefon" label="Telefon"
value={user.phone ? user.phone : <EmptyDefValue />} value={user.phone ? user.phone : <EmptyDefValue />}
/> />
<DefItem icon={Shield} label="Rolle" value={<RoleBadge role={user.role} />} /> <DefItem
icon={Shield}
label="Rolle"
value={<RoleBadge role={user.role} />}
/>
{user.role !== UserRole.ERZIEHER && (
<DefItem <DefItem
icon={Home} icon={Home}
label="Haushalt" label="Haushalt"
@@ -143,6 +152,7 @@ export default async function ProfilPage() {
) )
} }
/> />
)}
<DefItem <DefItem
icon={CalendarHeart} icon={CalendarHeart}
label="Mitglied seit" label="Mitglied seit"
@@ -153,6 +163,24 @@ export default async function ProfilPage() {
</Card> </Card>
<div className="grid gap-4"> <div className="grid gap-4">
{user.role === UserRole.ERZIEHER && (
<Card>
<CardHeader>
<CardTitle>Meine Arbeitszeit & Urlaub</CardTitle>
<CardDescription>
Wochenmodell, Urlaubsanspruch, Zeiterfassung und Überstunden.
</CardDescription>
</CardHeader>
<CardContent>
<Link
href="/dashboard/personal"
className="font-medium text-[var(--accent-deep)] underline underline-offset-4"
>
Personalbereich öffnen →
</Link>
</CardContent>
</Card>
)}
<Card> <Card>
<CardHeader className="pb-5"> <CardHeader className="pb-5">
<div className="flex items-start gap-3"> <div className="flex items-start gap-3">
@@ -180,6 +208,8 @@ export default async function ProfilPage() {
</CardContent> </CardContent>
</Card> </Card>
{user.role !== UserRole.ERZIEHER && (
<>
<Card> <Card>
<CardHeader className="pb-5"> <CardHeader className="pb-5">
<div className="flex items-start gap-3"> <div className="flex items-start gap-3">
@@ -233,8 +263,8 @@ export default async function ProfilPage() {
Keine festen Ämter übernommen Keine festen Ämter übernommen
</p> </p>
<p className="mt-1 text-xs text-[var(--ink-soft)]"> <p className="mt-1 text-xs text-[var(--ink-soft)]">
Dienste und Rollen erscheinen hier, sobald sie zugewiesen Dienste und Rollen erscheinen hier, sobald sie
sind. zugewiesen sind.
</p> </p>
</div> </div>
) : ( ) : (
@@ -261,6 +291,8 @@ export default async function ProfilPage() {
)} )}
</CardContent> </CardContent>
</Card> </Card>
</>
)}
</div> </div>
</div> </div>
+10
View File
@@ -12,6 +12,7 @@ import {
ClipboardList, ClipboardList,
Stethoscope, Stethoscope,
Megaphone, Megaphone,
Clock3,
} from "lucide-react"; } from "lucide-react";
import { NavItem } from "@/components/ui/nav-item"; import { NavItem } from "@/components/ui/nav-item";
@@ -19,6 +20,14 @@ import { NavItem } from "@/components/ui/nav-item";
import { UserRole } from "@prisma/client"; import { UserRole } from "@prisma/client";
const navItems = [ const navItems = [
{
section: "Heute",
href: "/dashboard/personal",
label: "Personal & Arbeitszeit",
icon: Clock3,
exact: false,
allowedRoles: [UserRole.ADMIN, UserRole.ERZIEHER],
},
{ {
section: "Heute", section: "Heute",
href: "/dashboard", href: "/dashboard",
@@ -33,6 +42,7 @@ const navItems = [
icon: CalendarCheck2, icon: CalendarCheck2,
exact: true, exact: true,
badge: "4", badge: "4",
allowedRoles: [UserRole.ADMIN, UserRole.KOORDINATOR, UserRole.ELTERN],
}, },
{ {
section: "Heute", section: "Heute",
+28
View File
@@ -0,0 +1,28 @@
import { redirect } from "next/navigation";
import { UserRole } from "@prisma/client";
import { requireKitaSession } from "@/lib/auth-utils";
import { prisma } from "@/lib/prisma";
import type { StaffActor } from "./service";
export async function requireStaffActor(): Promise<StaffActor> {
const { user } = await requireKitaSession();
const current = await prisma.user.findFirst({
where: { id: user.id, kitaId: user.kitaId },
select: {
id: true,
kitaId: true,
role: true,
lockedUntil: true,
privacyPolicyAcceptedAt: true,
},
});
if (
!current?.kitaId ||
!current.privacyPolicyAcceptedAt ||
current.role !== user.role ||
(current.role !== UserRole.ADMIN && current.role !== UserRole.ERZIEHER) ||
(current.lockedUntil && current.lockedUntil > new Date())
)
redirect("/forbidden");
return { id: current.id, kitaId: current.kitaId, role: current.role };
}
+315
View File
@@ -0,0 +1,315 @@
import { z } from "zod";
export const DAY_NAMES = [
"Montag",
"Dienstag",
"Mittwoch",
"Donnerstag",
"Freitag",
"Samstag",
"Sonntag",
];
export const STATUS_LABELS: Record<string, string> = {
PENDING: "Beantragt",
APPROVED: "Genehmigt",
REJECTED: "Abgelehnt",
CANCEL_REQUESTED: "Stornierung beantragt",
CANCELLED: "Storniert",
DRAFT: "Offen",
SUBMITTED: "Zur Prüfung",
};
export const KIND_LABELS: Record<string, string> = {
VACATION: "Urlaub",
TIME_OFF: "Freizeitausgleich",
SICKNESS: "Krankheit",
};
export const dateSchema = z
.string()
.regex(/^\d{4}-\d{2}-\d{2}$/)
.refine((key) => {
const d = new Date(`${key}T00:00:00Z`);
return (
!Number.isNaN(d.getTime()) &&
d.toISOString().slice(0, 10) === key &&
key >= "2000-01-01" &&
key <= "2100-12-31"
);
}, "Bitte ein gültiges Datum zwischen 2000 und 2100 angeben.");
export function dateKey(date: Date) {
return date.toISOString().slice(0, 10);
}
export function dateOnly(key: string) {
return new Date(`${dateSchema.parse(key)}T00:00:00Z`);
}
export function todayKey(now = new Date()) {
return new Intl.DateTimeFormat("sv-SE", {
timeZone: "Europe/Berlin",
year: "numeric",
month: "2-digit",
day: "2-digit",
}).format(now);
}
export function addDays(key: string, amount: number) {
const d = dateOnly(key);
d.setUTCDate(d.getUTCDate() + amount);
return dateKey(d);
}
export function weekStart(key: string) {
const day = dateOnly(key).getUTCDay();
return addDays(key, -(day === 0 ? 6 : day - 1));
}
export function datesBetween(start: string, end: string) {
if (end < start)
throw new Error("Das Enddatum darf nicht vor dem Beginn liegen.");
if ((dateOnly(end).getTime() - dateOnly(start).getTime()) / 86400000 > 370)
throw new Error("Bitte höchstens ein Jahr auf einmal auswählen.");
const days: string[] = [];
for (let d = start; d <= end; d = addDays(d, 1)) days.push(d);
return days;
}
export function formatMinutes(minutes: number) {
const abs = Math.abs(Math.round(minutes));
return `${minutes < 0 ? "−" : ""}${Math.floor(abs / 60)}:${String(abs % 60).padStart(2, "0")} h`;
}
export function shortDate(key: string) {
return new Intl.DateTimeFormat("de-DE", {
timeZone: "UTC",
day: "2-digit",
month: "2-digit",
year: "numeric",
}).format(dateOnly(key));
}
export function clockMinute(value: string) {
if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(value))
throw new Error("Bitte eine gültige Uhrzeit angeben.");
const [h, m] = value.split(":").map(Number);
return h * 60 + m;
}
export function minuteClock(value: number) {
return `${String(Math.floor(value / 60)).padStart(2, "0")}:${String(value % 60).padStart(2, "0")}`;
}
export type Schedule = {
employmentStart: Date;
employmentEnd: Date | null;
trackingStart: Date;
workPatterns: { effectiveFrom: Date; dailyMinutes: number[] }[];
dayOverrides: { date: Date; minutes: number }[];
};
export function scheduledMinutes(
profile: Schedule,
key: string,
holidays: Set<string>,
) {
if (
key < dateKey(profile.employmentStart) ||
(profile.employmentEnd && key > dateKey(profile.employmentEnd)) ||
holidays.has(key)
)
return 0;
const override = profile.dayOverrides.find((o) => dateKey(o.date) === key);
if (override) return override.minutes;
const pattern = profile.workPatterns
.filter((p) => dateKey(p.effectiveFrom) <= key)
.sort((a, b) => b.effectiveFrom.getTime() - a.effectiveFrom.getTime())[0];
const weekday = dateOnly(key).getUTCDay();
return pattern?.dailyMinutes[weekday === 0 ? 6 : weekday - 1] ?? 0;
}
export type BookingDay = {
date: string;
vacationUnits: number;
creditMinutes: number;
};
export function calculateLeaveDays(
profile: Schedule,
holidays: Set<string>,
input: {
kind: string;
startDate: string;
endDate: string;
halfDay: boolean;
minutes?: number;
},
) {
if (
input.startDate < dateKey(profile.employmentStart) ||
(profile.employmentEnd && input.endDate > dateKey(profile.employmentEnd))
)
throw new Error("Der Zeitraum liegt außerhalb der Beschäftigung.");
if (input.halfDay && input.startDate !== input.endDate)
throw new Error("Halbe Tage bitte einzeln beantragen.");
if (input.kind === "TIME_OFF" && input.startDate !== input.endDate)
throw new Error(
"Freizeitausgleich bitte für einen einzelnen Tag beantragen.",
);
const days: BookingDay[] = [];
for (const date of datesBetween(input.startDate, input.endDate)) {
const expected = scheduledMinutes(profile, date, holidays);
if (!expected) continue;
const creditMinutes =
input.kind === "TIME_OFF"
? (input.minutes ?? 0)
: input.halfDay
? Math.round(expected / 2)
: expected;
if (creditMinutes <= 0 || creditMinutes > expected)
throw new Error(
"Freizeitausgleich muss zwischen einer Minute und der Sollzeit dieses Tages liegen.",
);
days.push({
date,
creditMinutes,
vacationUnits: input.kind === "VACATION" ? (input.halfDay ? 1 : 2) : 0,
});
}
if (!days.length)
throw new Error("Im ausgewählten Zeitraum liegen keine Arbeitstage.");
return days;
}
export type DailyTotal = {
date: string;
expected: number;
worked: number;
credit: number;
timeOff: number;
balance: number;
};
export function calculateWeek(
profile: Schedule,
holidays: Set<string>,
start: string,
entries: {
date: Date;
startMinute: number;
endMinute: number;
breakMinutes: number;
}[],
leaves: {
kind: string;
status: string;
days: { date: Date; creditMinutes: number }[];
}[],
): DailyTotal[] {
return datesBetween(start, addDays(start, 6)).map((date) => {
const expected =
date < dateKey(profile.trackingStart)
? 0
: scheduledMinutes(profile, date, holidays);
const worked = entries
.filter((e) => dateKey(e.date) === date)
.reduce(
(sum, e) => sum + e.endMinute - e.startMinute - e.breakMinutes,
0,
);
let credit = 0,
timeOff = 0;
for (const leave of leaves) {
if (!["APPROVED", "CANCEL_REQUESTED"].includes(leave.status)) continue;
const minutes = leave.days
.filter((d) => dateKey(d.date) === date)
.reduce((sum, d) => sum + d.creditMinutes, 0);
if (leave.kind === "TIME_OFF") timeOff += minutes;
else credit += minutes;
}
return {
date,
expected,
worked,
credit,
timeOff,
balance: worked + credit - expected,
};
});
}
export function readSnapshot(value: unknown): DailyTotal[] {
const parsed = z
.array(
z.object({
date: dateSchema,
expected: z.number().int(),
worked: z.number().int(),
credit: z.number().int(),
timeOff: z.number().int(),
balance: z.number().int(),
}),
)
.safeParse(value);
return parsed.success ? parsed.data : [];
}
export function getTimeBalance(
profile: { openingMinutes: number; trackingStart: Date },
weeks: { status: string; dailySnapshot: unknown }[],
adjustments: { date: Date; minutes: number }[],
leaves: {
kind: string;
status: string;
days: { date: Date; creditMinutes: number }[];
}[],
asOf = todayKey(),
) {
const approvedDays = weeks
.filter((w) => w.status === "APPROVED")
.flatMap((w) => readSnapshot(w.dailySnapshot));
const postedDates = new Set(
approvedDays.filter((d) => d.date <= asOf).map((d) => d.date),
);
const confirmed =
profile.openingMinutes +
approvedDays
.filter((d) => d.date <= asOf)
.reduce((sum, d) => sum + d.balance, 0) +
adjustments
.filter((a) => dateKey(a.date) <= asOf)
.reduce((sum, a) => sum + a.minutes, 0);
const reserved = leaves
.filter(
(l) =>
l.kind === "TIME_OFF" &&
["APPROVED", "CANCEL_REQUESTED"].includes(l.status),
)
.flatMap((l) => l.days)
.filter(
(d) =>
dateKey(d.date) >= dateKey(profile.trackingStart) &&
!postedDates.has(dateKey(d.date)),
)
.reduce((sum, d) => sum + d.creditMinutes, 0);
return { confirmed, reserved, available: confirmed - reserved };
}
export function vacationBalance(
account: { year: number; entitlementUnits: number; carryUnits: number },
leaves: {
kind: string;
status: string;
days: { date: Date; vacationUnits: number }[];
}[],
asOf = todayKey(),
) {
let taken = 0,
planned = 0,
pending = 0;
for (const leave of leaves.filter((l) => l.kind === "VACATION")) {
for (const day of leave.days.filter(
(d) => d.date.getUTCFullYear() === account.year,
)) {
if (leave.status === "PENDING") pending += day.vacationUnits;
if (["APPROVED", "CANCEL_REQUESTED"].includes(leave.status)) {
if (dateKey(day.date) < asOf) taken += day.vacationUnits;
else planned += day.vacationUnits;
}
}
}
return {
entitlement: account.entitlementUnits + account.carryUnits,
taken,
planned,
pending,
available: account.entitlementUnits + account.carryUnits - taken - planned,
};
}
File diff suppressed because it is too large Load Diff
+237
View File
@@ -0,0 +1,237 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import {
calculateLeaveDays,
calculateWeek,
dateOnly,
dateSchema,
getTimeBalance,
scheduledMinutes,
todayKey,
vacationBalance,
weekStart,
} from "../src/lib/staff/calculations";
const profile = {
employmentStart: dateOnly("2026-01-01"),
employmentEnd: null,
trackingStart: dateOnly("2026-01-01"),
openingMinutes: 120,
workPatterns: [
{
effectiveFrom: dateOnly("2026-01-01"),
dailyMinutes: [360, 360, 0, 360, 0, 0, 0],
},
],
dayOverrides: [],
};
const holidays = new Set(["2026-01-06"]);
const days = (date: string, vacationUnits: number, creditMinutes = 360) => [
{ date: dateOnly(date), vacationUnits, creditMinutes },
];
test("Teilzeiturlaub verbraucht nur feste Arbeitstage, Feiertage werden übersprungen", () => {
const result = calculateLeaveDays(profile, holidays, {
kind: "VACATION",
startDate: "2026-01-05",
endDate: "2026-01-11",
halfDay: false,
});
assert.deepEqual(
result.map((d) => d.date),
["2026-01-05", "2026-01-08"],
);
assert.equal(
result.reduce((s, d) => s + d.vacationUnits, 0),
4,
);
});
test("Halber Urlaubstag entspricht halbem Tages-Soll", () => {
assert.deepEqual(
calculateLeaveDays(profile, new Set(), {
kind: "VACATION",
startDate: "2026-01-05",
endDate: "2026-01-05",
halfDay: true,
}),
[{ date: "2026-01-05", vacationUnits: 1, creditMinutes: 180 }],
);
assert.throws(() =>
calculateLeaveDays(profile, holidays, {
kind: "VACATION",
startDate: "2026-01-05",
endDate: "2026-01-08",
halfDay: true,
}),
);
});
test("Tagesausnahmen und datierte Modelle verändern nur den vorgesehenen Zeitraum", () => {
const schedule = {
...profile,
dayOverrides: [{ date: dateOnly("2026-01-07"), minutes: 240 }],
workPatterns: [
...profile.workPatterns,
{
effectiveFrom: dateOnly("2026-02-01"),
dailyMinutes: [480, 0, 480, 0, 0, 0, 0],
},
],
};
assert.equal(scheduledMinutes(schedule, "2026-01-07", holidays), 240);
assert.equal(scheduledMinutes(schedule, "2026-01-05", holidays), 360);
assert.equal(scheduledMinutes(schedule, "2026-02-02", holidays), 480);
assert.equal(scheduledMinutes(schedule, "2026-01-06", holidays), 0);
assert.equal(
scheduledMinutes(
{ ...schedule, employmentEnd: dateOnly("2026-01-31") },
"2026-02-02",
holidays,
),
0,
);
});
test("Urlaub über Jahreswechsel wird auf die Jahreskonten verteilt", () => {
const leave = [
{
kind: "VACATION",
status: "APPROVED",
days: [...days("2026-12-31", 2), ...days("2027-01-04", 1)],
},
];
assert.equal(
vacationBalance(
{ year: 2026, entitlementUnits: 40, carryUnits: 2 },
leave,
"2026-10-01",
).planned,
2,
);
assert.equal(
vacationBalance(
{ year: 2027, entitlementUnits: 40, carryUnits: 0 },
leave,
"2026-10-01",
).planned,
1,
);
});
test("Offene Stornierung bleibt gebucht, Ablehnung und Stornierung verbrauchen nichts", () => {
const leave = [
{
kind: "VACATION",
status: "CANCEL_REQUESTED",
days: days("2026-01-05", 2),
},
{ kind: "VACATION", status: "PENDING", days: days("2026-01-08", 1) },
...["CANCELLED", "REJECTED"].map((status) => ({
kind: "VACATION",
status,
days: days("2026-01-12", 2),
})),
];
assert.deepEqual(
vacationBalance(
{ year: 2026, entitlementUnits: 40, carryUnits: 4 },
leave,
"2026-01-07",
),
{ entitlement: 44, taken: 2, planned: 0, pending: 1, available: 42 },
);
});
test("Mehrere Arbeitsblöcke abzüglich Pausen, Urlaub und Krankheit ergeben die Wochenbilanz", () => {
const entries = [
{
date: dateOnly("2026-01-05"),
startMinute: 480,
endMinute: 720,
breakMinutes: 30,
},
{
date: dateOnly("2026-01-05"),
startMinute: 780,
endMinute: 960,
breakMinutes: 0,
},
];
const leave = [
{ kind: "SICKNESS", status: "APPROVED", days: days("2026-01-08", 0) },
];
const result = calculateWeek(profile, holidays, "2026-01-05", entries, leave);
assert.equal(result[0].worked, 390);
assert.equal(result[0].balance, 30);
assert.equal(result[1].expected, 0);
assert.equal(result[3].credit, 360);
assert.equal(result[3].balance, 0);
});
test("Nur genehmigte Snapshots zählen; Zukunftskorrekturen zählen erst ab Datum", () => {
const snapshot = [
{
date: "2026-01-05",
expected: 360,
worked: 420,
credit: 0,
timeOff: 0,
balance: 60,
},
];
const result = getTimeBalance(
profile,
[
{ status: "APPROVED", dailySnapshot: snapshot },
{ status: "SUBMITTED", dailySnapshot: snapshot },
],
[{ date: dateOnly("2026-02-01"), minutes: 100 }],
[],
"2026-01-10",
);
assert.equal(result.confirmed, 180);
});
test("Freizeitausgleich wird reserviert und nach Wochenbuchung genau einmal abgezogen", () => {
const leave = [
{ kind: "TIME_OFF", status: "APPROVED", days: days("2026-01-05", 0, 60) },
];
const initial = getTimeBalance(profile, [], [], leave, "2026-01-04");
assert.deepEqual(initial, { confirmed: 120, reserved: 60, available: 60 });
const snapshot = [
{
date: "2026-01-05",
expected: 360,
worked: 300,
credit: 0,
timeOff: 60,
balance: -60,
},
];
assert.deepEqual(
getTimeBalance(
profile,
[{ status: "APPROVED", dailySnapshot: snapshot }],
[],
leave,
"2026-01-06",
),
{ confirmed: 60, reserved: 0, available: 60 },
);
const computed = calculateWeek(
profile,
new Set(),
"2026-01-05",
[
{
date: dateOnly("2026-01-05"),
startMinute: 480,
endMinute: 780,
breakMinutes: 0,
},
],
leave,
);
assert.equal(computed[0].credit, 0);
assert.equal(computed[0].balance, -60);
});
test("Ungültige Kalendertage werden abgewiesen; Tagesdatum wird in Berlin bestimmt", () => {
assert.equal(dateSchema.safeParse("2026-02-30").success, false);
assert.equal(dateSchema.safeParse("2028-02-29").success, true);
assert.equal(todayKey(new Date("2026-01-04T23:30:00Z")), "2026-01-05");
assert.equal(weekStart("2026-01-11"), "2026-01-05");
});
+518
View File
@@ -0,0 +1,518 @@
import { after, test } from "node:test";
import assert from "node:assert/strict";
import { randomUUID } from "node:crypto";
import { UserRole } from "@prisma/client";
import { prisma } from "../src/lib/prisma";
import {
executeStaffCommand,
getStaffProfile,
type StaffActor,
} from "../src/lib/staff/service";
import { dateOnly, getTimeBalance } from "../src/lib/staff/calculations";
// Never run integration tests against a user's application database.
const db = new URL(process.env.DATABASE_URL ?? "postgresql://invalid");
if (
db.hostname !== "127.0.0.1" ||
db.port !== "55439" ||
db.pathname !== "/kita_staff_test"
)
throw new Error(
"Integrationstests benötigen die isolierte Datenbank 127.0.0.1:55439/kita_staff_test.",
);
const tenants: string[] = [];
after(async () => {
await prisma.kita.deleteMany({ where: { id: { in: tenants } } });
await prisma.$disconnect();
});
async function fixture() {
const kita = await prisma.kita.create({
data: { name: "Testkita", slug: `staff-test-${randomUUID()}` },
});
tenants.push(kita.id);
const createUser = (role: UserRole) =>
prisma.user.create({
data: {
kitaId: kita.id,
email: `${randomUUID()}@staff-test.invalid`,
passwordHash: "test-only",
firstName: "Test",
lastName: role,
role,
privacyPolicyAcceptedAt: new Date(),
},
});
const adminUser = await createUser("ADMIN"),
staffUser = await createUser("ERZIEHER"),
otherUser = await createUser("ERZIEHER"),
parentUser = await createUser("ELTERN");
const actor = (u: typeof adminUser): StaffActor => ({
id: u.id,
kitaId: kita.id,
role: u.role,
});
const admin = actor(adminUser),
staff = actor(staffUser),
other = actor(otherUser),
parent = actor(parentUser);
const educator = await prisma.educator.create({
data: { kitaId: kita.id, firstName: "Test", lastName: "Fachkraft" },
});
await executeStaffCommand(admin, {
command: "setup",
data: {
educatorId: educator.id,
employmentStart: "2026-01-01",
employmentEnd: null,
trackingStart: "2026-01-01",
openingMinutes: 600,
reason: "Testeinrichtung",
},
});
const profile = await prisma.staffProfile.update({
where: { educatorId: educator.id },
data: { userId: staffUser.id },
});
const run = (
who: StaffActor,
command: string,
data: Record<string, unknown> = {},
) =>
executeStaffCommand(who, {
command,
data: { profileId: profile.id, ...data },
});
await run(admin, "pattern", {
effectiveFrom: "2026-01-01",
dailyMinutes: [360, 360, 0, 360, 0, 0, 0],
reason: "Feste Teilzeit",
});
await run(admin, "account", {
year: 2026,
entitlementUnits: 40,
carryUnits: 0,
reason: "Jahresanspruch",
});
return {
kita,
profile,
educator,
admin,
staff,
other,
parent,
run,
staffUser,
};
}
const vacation = (date = "2026-01-05") => ({
kind: "VACATION",
startDate: date,
endDate: date,
halfDay: false,
note: "Testurlaub",
});
const time = (date = "2026-01-05", startMinute = 480, endMinute = 840) => ({
date,
startMinute,
endMinute,
breakMinutes: 0,
});
test("Mandanten, Rollen und Eigentümer werden für Lesen und Schreiben geprüft", async () => {
const f = await fixture(),
foreign = await fixture();
await assert.rejects(
f.run(f.other, "time", time()),
/eigenes Personalprofil/,
);
await assert.rejects(f.run(f.parent, "time", time()), /Kein Zugriff/);
await assert.rejects(
f.run(f.staff, "account", {
year: 2026,
entitlementUnits: 100,
carryUnits: 0,
reason: "Versuch",
}),
/Nur Kita-Admins/,
);
await assert.rejects(f.run(foreign.admin, "time", time()), /nicht gefunden/);
await assert.rejects(
f.run({ ...f.admin, kitaId: foreign.kita.id }, "time", time()),
/keinen Zugriff/,
);
assert.equal(await getStaffProfile(f.other, f.profile.id), null);
assert.equal(await getStaffProfile(foreign.admin, f.profile.id), null);
await assert.rejects(getStaffProfile(f.parent, f.profile.id), /Kein Zugriff/);
});
test("Urlaubsantrag, Freigabe, Stornierung und interne Hinweise bleiben konsistent", async () => {
const f = await fixture();
await f.run(f.staff, "leave", vacation());
const leave = await prisma.staffLeave.findFirstOrThrow({
where: { profileId: f.profile.id },
include: { days: true },
});
assert.equal(leave.days[0].vacationUnits, 2);
assert.equal(
await prisma.staffNotification.count({ where: { userId: f.admin.id } }),
1,
);
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: true,
reason: "Freigegeben",
});
await f.run(f.staff, "leaveCancel", { id: leave.id });
assert.equal(
(await prisma.staffLeave.findUniqueOrThrow({ where: { id: leave.id } }))
.status,
"CANCEL_REQUESTED",
);
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: true,
reason: "Stornierung bestätigt",
});
assert.equal(
(await prisma.staffLeave.findUniqueOrThrow({ where: { id: leave.id } }))
.status,
"CANCELLED",
);
assert.equal(
await prisma.staffNotification.count({ where: { userId: f.staff.id } }),
2,
);
const notice = await prisma.staffNotification.findFirstOrThrow({
where: { userId: f.staff.id },
});
await f.run(f.admin, "noticeRead", { id: notice.id });
assert.equal(
(
await prisma.staffNotification.findUniqueOrThrow({
where: { id: notice.id },
})
).readAt,
null,
);
await f.run(f.staff, "noticeRead", { id: notice.id });
assert.ok(
(
await prisma.staffNotification.findUniqueOrThrow({
where: { id: notice.id },
})
).readAt,
);
});
test("Offene Urlaube reservieren den Anspruch und lassen sich nur im offenen Status ändern", async () => {
const f = await fixture();
await f.run(f.admin, "account", {
year: 2026,
entitlementUnits: 2,
carryUnits: 0,
reason: "Ein Tag",
});
await f.run(f.staff, "leave", vacation());
await assert.rejects(
f.run(f.staff, "leave", vacation("2026-01-08")),
/reichen.*nicht aus/,
);
const leave = await prisma.staffLeave.findFirstOrThrow({
where: { profileId: f.profile.id },
});
await f.run(f.staff, "leave", { ...vacation("2026-01-08"), id: leave.id });
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: true,
reason: "Genehmigung",
});
await assert.rejects(
f.run(f.staff, "leave", { ...vacation(), id: leave.id }),
/Nur offene/,
);
});
test("Überlappende Arbeitsblöcke und parallele Urlaubsanträge werden verhindert", async () => {
const f = await fixture();
await f.run(f.staff, "time", time());
await assert.rejects(
f.run(f.staff, "time", time("2026-01-05", 800, 900)),
/überschneidet/,
);
await f.run(f.admin, "account", {
year: 2026,
entitlementUnits: 2,
carryUnits: 0,
reason: "Ein Tag",
});
const results = await Promise.allSettled([
f.run(f.staff, "leave", vacation("2026-01-08")),
f.run(f.staff, "leave", vacation("2026-01-12")),
]);
assert.equal(results.filter((r) => r.status === "fulfilled").length, 1);
assert.equal(
await prisma.staffLeave.count({ where: { profileId: f.profile.id } }),
1,
);
});
test("Wochenfreigabe schützt Zeiten, Modelle und Feiertage; Rückgabe erlaubt Korrektur", async () => {
const f = await fixture();
for (const date of ["2026-01-05", "2026-01-06", "2026-01-08"])
await f.run(
f.staff,
"time",
time(date, 480, date === "2026-01-05" ? 900 : 840),
);
await f.run(f.staff, "weekSubmit", { weekStart: "2026-01-05" });
await assert.rejects(
f.run(f.staff, "time", time("2026-01-05", 1000, 1100)),
/zuerst.*zurückgeben/,
);
await f.run(f.admin, "weekReview", {
weekStart: "2026-01-05",
approve: true,
reason: "Zeiten geprüft",
});
let p = await getStaffProfile(f.staff);
assert.ok(p);
assert.equal(
getTimeBalance(p, p.weeks, p.adjustments, p.leaves).confirmed,
660,
);
await assert.rejects(
f.run(f.admin, "pattern", {
effectiveFrom: "2026-01-01",
dailyMinutes: [480, 480, 0, 480, 0, 0, 0],
reason: "Änderung",
}),
/bestehen bereits Freigaben/,
);
await assert.rejects(
f.run(f.admin, "holiday", { date: "2026-01-05", name: "Feiertag" }),
/bestehen bereits Freigaben/,
);
await f.run(f.admin, "weekReview", {
weekStart: "2026-01-05",
approve: false,
reason: "Bitte Pause prüfen",
});
p = await getStaffProfile(f.staff);
assert.ok(p);
assert.equal(
getTimeBalance(p, p.weeks, p.adjustments, p.leaves).confirmed,
600,
);
await f.run(f.staff, "time", time("2026-01-05", 1000, 1100));
});
test("Freizeitausgleich bleibt bei Storno reserviert und wird mit der Woche einmal verrechnet", async () => {
const f = await fixture();
await f.run(f.staff, "leave", {
kind: "TIME_OFF",
startDate: "2026-01-05",
endDate: "2026-01-05",
halfDay: false,
minutes: 60,
});
const leave = await prisma.staffLeave.findFirstOrThrow({
where: { profileId: f.profile.id },
});
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: true,
reason: "Guthaben geprüft",
});
let p = await getStaffProfile(f.staff);
assert.ok(p);
assert.equal(
getTimeBalance(p, p.weeks, p.adjustments, p.leaves).available,
540,
);
for (const date of ["2026-01-05", "2026-01-06", "2026-01-08"])
await f.run(
f.staff,
"time",
time(date, 480, date === "2026-01-05" ? 780 : 840),
);
await f.run(f.staff, "weekSubmit", { weekStart: "2026-01-05" });
await f.run(f.staff, "leaveCancel", { id: leave.id });
await assert.rejects(
f.run(f.admin, "weekReview", {
weekStart: "2026-01-05",
approve: true,
reason: "Geprüft",
}),
/offene Abwesenheiten/,
);
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: false,
reason: "Stornierung abgelehnt",
});
await f.run(f.admin, "weekReview", {
weekStart: "2026-01-05",
approve: true,
reason: "Geprüft",
});
p = await getStaffProfile(f.staff);
assert.ok(p);
assert.deepEqual(getTimeBalance(p, p.weeks, p.adjustments, p.leaves), {
confirmed: 540,
reserved: 0,
available: 540,
});
});
test("Halbtagsurlaub lässt nur die verbleibende Sollzeit als Arbeitszeit zu", async () => {
const f = await fixture();
await f.run(f.staff, "leave", { ...vacation(), halfDay: true });
const leave = await prisma.staffLeave.findFirstOrThrow({
where: { profileId: f.profile.id },
});
await f.run(f.admin, "leaveReview", {
id: leave.id,
approve: true,
reason: "Halber Tag",
});
await f.run(f.staff, "time", time("2026-01-05", 480, 660));
await assert.rejects(
f.run(f.staff, "time", time("2026-01-05", 700, 760)),
/überschreiten.*Sollzeit/,
);
});
test("Aktivierungslinks verknüpfen nur passende Accounts und werden bei Erneuerung ersetzt", async () => {
const f = await fixture();
const educator = await prisma.educator.create({
data: { kitaId: f.kita.id, firstName: "Neue", lastName: "Fachkraft" },
});
await f.run(f.admin, "setup", {
educatorId: educator.id,
employmentStart: "2026-01-01",
employmentEnd: null,
trackingStart: "2026-01-01",
openingMinutes: 0,
reason: "Einrichtung",
});
const profile = await prisma.staffProfile.findUniqueOrThrow({
where: { educatorId: educator.id },
});
const email = `${randomUUID()}@staff-test.invalid`;
const first = await f.run(f.admin, "invite", {
profileId: profile.id,
email,
});
assert.ok(first.invite);
const second = await f.run(f.admin, "invite", {
profileId: profile.id,
email,
});
assert.ok(second.invite);
assert.equal(
await prisma.verificationToken.count({
where: { token: first.invite.token },
}),
0,
);
const linked = await prisma.staffProfile.findUniqueOrThrow({
where: { id: profile.id },
include: { user: true },
});
assert.equal(linked.user?.role, "ERZIEHER");
assert.equal(linked.user?.passwordHash, "");
await assert.rejects(
f.run(f.admin, "invite", {
profileId: profile.id,
email: f.staffUser.email,
}),
/bereits einen Account/,
);
await prisma.verificationToken.deleteMany({
where: { identifier: linked.userId! },
});
});
test("Krankheit ist adminverwaltet, entlastet Sollzeit und verbraucht keinen Urlaub", async () => {
const f = await fixture();
const input = {
kind: "SICKNESS",
startDate: "2026-01-08",
endDate: "2026-01-08",
halfDay: false,
};
await assert.rejects(f.run(f.staff, "leave", input), /Nur Kita-Admins/);
await f.run(f.admin, "leave", input);
const leave = await prisma.staffLeave.findFirstOrThrow({
where: { profileId: f.profile.id },
include: { days: true },
});
assert.equal(leave.status, "APPROVED");
assert.equal(leave.days[0].creditMinutes, 360);
assert.equal(leave.days[0].vacationUnits, 0);
assert.equal(leave.days[0].date.getTime(), dateOnly("2026-01-08").getTime());
});
test("Beschäftigungsende bleibt nach Erfassungsstart verwaltbar und schützt vorhandene Zeiten", async () => {
const f = await fixture();
await f.run(f.staff, "time", time());
await f.run(f.admin, "employmentEnd", {
employmentEnd: "2026-01-31",
reason: "Vertragsende",
});
await assert.rejects(
f.run(f.staff, "time", time("2026-02-02")),
/innerhalb des Erfassungszeitraums/,
);
await assert.rejects(
f.run(f.admin, "employmentEnd", {
employmentEnd: "2026-01-04",
reason: "Zu früh",
}),
/aktive Anträge/,
);
await f.run(f.admin, "employmentEnd", {
employmentEnd: null,
reason: "Vertrag verlängert",
});
await f.run(f.staff, "time", time("2026-02-02"));
});
test("Personalaufzeichnungen sind vor Fachkraftlöschung geschützt und bleiben nach Accountlöschung erhalten", async () => {
const f = await fixture();
await f.run(f.staff, "time", time());
await assert.rejects(
prisma.educator.delete({ where: { id: f.educator.id } }),
(error: unknown) =>
typeof error === "object" &&
error !== null &&
"code" in error &&
error.code === "P2003",
);
await prisma.user.delete({ where: { id: f.staff.id } });
const profile = await prisma.staffProfile.findUniqueOrThrow({
where: { id: f.profile.id },
include: { timeEntries: true },
});
assert.equal(profile.userId, null);
assert.equal(profile.timeEntries.length, 1);
});
test("Entzogene Rollen, fehlender Consent und gesperrte Accounts können keine Personalaktionen ausführen", async () => {
const f = await fixture();
await assert.rejects(
f.run({ ...f.staff, role: "ADMIN" }, "account", {
year: 2026,
entitlementUnits: 100,
carryUnits: 0,
reason: "Manipulation",
}),
/keinen Zugriff/,
);
await prisma.user.update({
where: { id: f.staff.id },
data: { privacyPolicyAcceptedAt: null },
});
await assert.rejects(f.run(f.staff, "time", time()), /keinen Zugriff/);
await prisma.user.update({
where: { id: f.staff.id },
data: {
privacyPolicyAcceptedAt: new Date(),
lockedUntil: new Date(Date.now() + 60000),
},
});
await assert.rejects(f.run(f.staff, "time", time()), /keinen Zugriff/);
});