diff --git a/components/employees/tabs/HistorieTab.tsx b/components/employees/tabs/HistorieTab.tsx index e5ec93b..703b78c 100644 --- a/components/employees/tabs/HistorieTab.tsx +++ b/components/employees/tabs/HistorieTab.tsx @@ -38,7 +38,9 @@ export function HistorieTab({ history, employeeId }: { history: HistoryRow[]; em {history.map((h) => { const isFuture = h.event_date > today; const changes = h.changes ?? []; - const urteil = darfKorrigiertWerden(h, today); + // Die ganze Historie mitgeben: ob eine Abwesenheit gelöscht werden + // darf, hängt daran, ob es eine spätere Rückkehr gibt. + const urteil = darfKorrigiertWerden(h, today, history); return (
  • diff --git a/lib/history.ts b/lib/history.ts index 23a7a11..bcf6e3a 100644 --- a/lib/history.ts +++ b/lib/history.ts @@ -21,14 +21,22 @@ type Eintrag = { changes: AuditChange[] | null; /** Der geplante Vorgang, falls die Änderung noch nicht wirksam ist. */ pending_id?: string | null; + /** Für die Reihenfolge bei gleichem Datum. */ + created_at?: string; }; -export function darfKorrigiertWerden(eintrag: Eintrag, heute: string): KorrekturUrteil { +/** Die Vorgänge, die sich zurücknehmen und berichtigen lassen. */ +const KORRIGIERBAR: HistoryEventType[] = ["Stammdatenänderung", "Vertragsänderung", "Karenz", "Rückkehr"]; + +/** Abwesenheit und Rückkehr haben eigene Vorgänge, auch für die Zukunft. */ +const NUR_WIRKSAM: HistoryEventType[] = ["Karenz", "Rückkehr"]; + +export function darfKorrigiertWerden(eintrag: Eintrag, heute: string, alle: Eintrag[] = []): KorrekturUrteil { if (eintrag.event_type === "Eintritt") { return { erlaubt: false, grund: "Der Eintritt ist der Anfang der Zeitleiste und bleibt." }; } - if (eintrag.event_type !== "Stammdatenänderung" && eintrag.event_type !== "Vertragsänderung") { + if (!KORRIGIERBAR.includes(eintrag.event_type)) { return { erlaubt: false, grund: @@ -37,6 +45,24 @@ export function darfKorrigiertWerden(eintrag: Eintrag, heute: string): Korrektur }; } + // Die Reihenfolge zählt: eine Rückkehr setzt eine Abwesenheit voraus. + // Bliebe sie stehen, während die Abwesenheit verschwindet, stünde in der + // Akte eine Rückkehr aus dem Nichts — und der Status ergäbe sich aus einem + // Eintrag, dessen Ausgangslage gelöscht ist. + if (eintrag.event_type === "Karenz" && alle.some((h) => h.event_type === "Rückkehr" && spaeter(h, eintrag))) { + return { + erlaubt: false, + grund: "Zu dieser Abwesenheit gibt es eine Rückkehr. Sie muss zuerst gelöscht werden.", + }; + } + + if (NUR_WIRKSAM.includes(eintrag.event_type) && eintrag.event_date > heute) { + return { + erlaubt: false, + grund: "Diese Abwesenheit ist noch nicht wirksam. Sie muss über den Vorgang selbst abgebrochen werden.", + }; + } + // Noch nicht wirksam: das geht, aber nur mit Bezug auf den geplanten // Vorgang. Zeilen aus der Zeit vor dieser Verknüpfung haben keinen — sie // liessen sich nur über Person und Datum zuordnen, und das ist nicht @@ -60,6 +86,12 @@ export function darfKorrigiertWerden(eintrag: Eintrag, heute: string): Korrektur return { erlaubt: true }; } +/** Später im Sinne der Anzeige: erst das Datum, dann die Erfassungszeit. */ +function spaeter(a: Eintrag, b: Eintrag): boolean { + if (a.event_date !== b.event_date) return a.event_date > b.event_date; + return (a.created_at ?? "") > (b.created_at ?? ""); +} + /** * Was das Löschen bewirken würde: je Feld entweder Zurücksetzen oder nicht, * weil ein späterer Eintrag dasselbe Feld angefasst hat. diff --git a/supabase/migrations/20260814180000_karenz_ruecknahme.sql b/supabase/migrations/20260814180000_karenz_ruecknahme.sql new file mode 100644 index 0000000..71dcf61 --- /dev/null +++ b/supabase/migrations/20260814180000_karenz_ruecknahme.sql @@ -0,0 +1,607 @@ +-- Abwesenheit und Rückkehr lassen sich zurücknehmen und berichtigen. +-- +-- Bisher endete beides bei Stammdaten- und Vertragsänderungen. Eine +-- versehentlich erfasste Langzeitabwesenheit liess sich nur durch eine zweite +-- Buchung wieder loswerden — und dann standen zwei Einträge in der Akte, von +-- denen der erste nie stattgefunden hat. +-- +-- Damit das Zurücknehmen den Stand wirklich wiederherstellt, halten +-- start_karenz und record_karenz_return jetzt ihre Vorher-Werte fest, so wie +-- change_employee_data es tut: Status, Art der Abwesenheit, Beginn, geplante +-- Rückkehr — bei der Rückkehr zusätzlich Beschäftigungsausmaß, Stunden und +-- Teilzeitvariante. Erst damit hat die vorhandene Rücknahme etwas, worauf sie +-- zurücksetzen kann. +-- +-- ═══ Die Reihenfolge ═══ +-- +-- Eine Rückkehr setzt eine Abwesenheit voraus. Bliebe sie stehen, während die +-- Abwesenheit verschwindet, stünde in der Akte eine Rückkehr aus dem Nichts, +-- und der Status ergäbe sich aus einem Eintrag, dessen Ausgangslage gelöscht +-- ist. Deshalb: **eine Abwesenheit lässt sich erst löschen, wenn ihre +-- Rückkehr gelöscht ist.** Die Prüfung liegt in der Datenbank, nicht nur in +-- der Oberfläche. +-- +-- Zeilen von vor dieser Migration tragen keine Vorher-Werte und bleiben +-- deshalb unantastbar — mit derselben Meldung wie bisher. + +CREATE OR REPLACE FUNCTION public.app_feld_karte() + RETURNS jsonb + LANGUAGE sql + IMMUTABLE + SET search_path TO 'public', 'pg_temp' +AS $function$ + select jsonb_build_object( + 'Vorname', jsonb_build_array('first_name', 'text', 'person'), + 'Nachname', jsonb_build_array('last_name', 'text', 'person'), + 'Geschlecht', jsonb_build_array('gender', 'gender_type', 'person'), + 'Geburtsdatum', jsonb_build_array('birth_date', 'date', 'person'), + 'SV-Nummer', jsonb_build_array('sv_nummer', 'text', 'person'), + 'Staatsbürgerschaft', jsonb_build_array('nationality', 'text', 'person'), + 'Adresse', jsonb_build_array('address', 'text', 'person'), + 'Postleitzahl', jsonb_build_array('postal_code', 'text', 'person'), + 'Ort', jsonb_build_array('city', 'text', 'person'), + 'Land', jsonb_build_array('address_country', 'text', 'person'), + 'E-Mail', jsonb_build_array('email', 'text', 'person'), + 'Telefon', jsonb_build_array('phone', 'text', 'person'), + 'Notfallkontakt', jsonb_build_array('emergency_contact_name', 'text', 'person'), + 'Notfallkontakt Telefon', jsonb_build_array('emergency_contact_phone', 'text', 'person'), + 'Notfallkontakt Verhältnis', jsonb_build_array('emergency_contact_relation', 'text', 'person'), + 'Titel (vorangestellt)', jsonb_build_array('title_prefix', 'liste', 'person'), + 'Titel (nachgestellt)', jsonb_build_array('title_suffix', 'liste', 'person'), + 'Beschäftigungsausmaß', jsonb_build_array('employment_type', 'employment_type', 'contract'), + 'Wochenstunden', jsonb_build_array('weekly_hours', 'numeric', 'contract'), + 'Vertragsart', jsonb_build_array('contract_type', 'contract_type', 'contract'), + 'Befristet bis', jsonb_build_array('contract_end_date', 'date', 'contract'), + 'Angestellte:r/Arbeiter:in', jsonb_build_array('worker_type', 'worker_type', 'role'), + 'Kollektivvertrag', jsonb_build_array('collective_agreement', 'collective_agreement', 'role'), + 'Arbeitstage', jsonb_build_array('work_days', 'liste', 'role'), + 'Betriebsrat', jsonb_build_array('is_betriebsrat', 'boolean', 'role'), + 'Dienstwagen', jsonb_build_array('has_dienstwagen', 'boolean', 'role'), + 'Laterale Führung', jsonb_build_array('is_laterale_fuehrung', 'boolean', 'role'), + 'C-Level', jsonb_build_array('is_c_level', 'boolean', 'role'), + 'Dienstwagen Antrieb', jsonb_build_array('dienstwagen_art', 'text', 'role'), + 'Besonderer Kündigungsschutz', jsonb_build_array('has_kuendigungsschutz', 'boolean', 'role'), + 'Kündigungsschutz bis', jsonb_build_array('kuendigungsschutz_bis', 'date', 'role'), + 'Teilzeitvariante', jsonb_build_array('teilzeit_art', 'text', 'role'), + 'Teilzeit bis', jsonb_build_array('teilzeit_bis', 'date', 'role'), + -- Die Felder der Abwesenheit. Dritter Eintrag null: sie gehören zu + -- keiner Gruppe im payload einer geplanten Änderung, weil Abwesenheit + -- und Rückkehr ihre eigenen Vorgänge haben. Wer sie in einer + -- geplanten Änderung setzen wollte, hätte keinen Ort dafür — deshalb + -- weisen delete_/update_history_entry solche Einträge in der Zukunft + -- ab, statt an einer fehlenden Gruppe zu scheitern. + 'Status', jsonb_build_array('status', 'employment_status', null), + 'Art der Abwesenheit', jsonb_build_array('absence_type', 'text', null), + 'Abwesend ab', jsonb_build_array('karenz_start_date', 'date', null), + 'Geplante Rückkehr', jsonb_build_array('karenz_return_date', 'date', null) + ); +$function$; + +CREATE OR REPLACE FUNCTION public.start_karenz(payload jsonb) + RETURNS void + LANGUAGE plpgsql + SET search_path TO 'public', 'pg_temp' +AS $function$ +declare + v_employee_id uuid := (payload->>'employee_id')::uuid; + v_start_date date := (payload->>'karenz_start_date')::date; + v_absence_type text := nullif(payload->>'absence_type', ''); + v_name text; + v_old employees%rowtype; + -- Ohne Vorher-Werte liesse sich eine irrtümlich erfasste Abwesenheit + -- nicht zurücknehmen: es stünde nirgends, was vorher galt. + v_changes jsonb := '[]'::jsonb; +begin + perform require_hr_admin(); + select * into v_old from employees where id = v_employee_id; + v_name := v_old.first_name || ' ' || v_old.last_name; + + v_changes := app_aenderung(v_changes, 'Status', v_old.status::text, + case when v_start_date <= current_date then 'Karenz' else v_old.status::text end); + v_changes := app_aenderung(v_changes, 'Art der Abwesenheit', v_old.absence_type, v_absence_type); + v_changes := app_aenderung(v_changes, 'Abwesend ab', v_old.karenz_start_date::text, v_start_date::text); + v_changes := app_aenderung(v_changes, 'Geplante Rückkehr', v_old.karenz_return_date::text, payload->>'planned_return_date'); + + if v_start_date <= current_date then + update employees set status = 'Karenz', karenz_start_date = v_start_date, + karenz_return_date = (payload->>'planned_return_date')::date, + absence_type = v_absence_type + where id = v_employee_id; + else + update employees set karenz_start_date = v_start_date where id = v_employee_id; + insert into pending_org_changes (employee_id, change_type, effective_date, payload) + values (v_employee_id, 'karenz_start', v_start_date, + jsonb_build_object('planned_return_date', payload->>'planned_return_date', 'absence_type', v_absence_type)); + end if; + + insert into employee_history (employee_id, event_date, event_type, description, changes) + values (v_employee_id, v_start_date, 'Karenz', + coalesce(v_absence_type, 'Langzeitabwesenheit') || ', geplante Rückkehr am ' || (payload->>'planned_return_date') || + case when payload->>'note' is not null and payload->>'note' <> '' then ' — ' || (payload->>'note') else '' end, + v_changes); + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details) + values (app_current_user_id(), current_actor_name(), 'Karenz', v_name, v_employee_id, + coalesce(v_absence_type, 'Langzeitabwesenheit') || ', geplante Rückkehr ' || (payload->>'planned_return_date')); +end; +$function$; + +CREATE OR REPLACE FUNCTION public.record_karenz_return(payload jsonb) + RETURNS void + LANGUAGE plpgsql + SET search_path TO 'public', 'pg_temp' +AS $function$ +declare + v_employee_id uuid := (payload->>'employee_id')::uuid; + v_return_date date := (payload->>'return_date')::date; + v_name text; + v_employment_type employment_type; + v_weekly_hours numeric; + v_karenz_start date; + v_absence_type text; + v_old employees%rowtype; + -- Wie bei der Abwesenheit: ohne Vorher-Werte liesse sich eine + -- irrtümlich erfasste Rückkehr nicht zurücknehmen. + v_changes jsonb := '[]'::jsonb; + -- Warum jemand mit weniger Stunden zurückkommt: Wiedereingliederungs- + -- oder Elternteilzeit. Nur bedeutsam, wenn überhaupt reduziert wird. + v_grund text := nullif(payload->>'reduction_reason', ''); +begin + perform require_hr_admin(); + select * into v_old from employees where id = v_employee_id; + v_name := v_old.first_name || ' ' || v_old.last_name; + v_karenz_start := v_old.karenz_start_date; + v_absence_type := v_old.absence_type; + + if v_karenz_start is not null and v_return_date <= v_karenz_start then + raise exception 'Das Rückkehrdatum muss nach dem Beginn der Langzeitabwesenheit (%) liegen.', v_karenz_start; + end if; + + if payload->>'employment_mode' = 'Vollzeit' then + v_employment_type := 'Vollzeit'; v_weekly_hours := 38.5; + elsif payload->>'employment_mode' = 'Teilzeit' then + v_employment_type := 'Teilzeit'; v_weekly_hours := (payload->>'weekly_hours')::numeric; + end if; + + if v_return_date <= current_date then + -- Keine Manager-Nachführung mehr nötig: wer aus der Abwesenheit + -- zurückkehrt, ist wieder anwesend, und die abgeleitete Berichtslinie + -- fällt automatisch von der Vertretung auf ihn zurück. + update employees set + status = 'Aktiv', + karenz_return_date = null, + karenz_start_date = null, + absence_type = null, + employment_type = coalesce(v_employment_type, employment_type), + weekly_hours = coalesce(v_weekly_hours, weekly_hours), + -- Kehrt jemand reduziert zurück, ist der Grund dafür ein Zustand, + -- kein Einmalereignis: danach lässt sich auswerten, wer gerade in + -- Eltern- oder Wiedereingliederungsteilzeit ist. + teilzeit_art = case when payload->>'employment_mode' = 'Teilzeit' then v_grund else teilzeit_art end, + teilzeit_bis = case + when payload->>'employment_mode' = 'Teilzeit' and v_grund is not null + then nullif(payload->>'teilzeit_bis', '')::date + when payload->>'employment_mode' = 'Teilzeit' then null + else teilzeit_bis end + where id = v_employee_id; + else + update employees set karenz_return_date = v_return_date where id = v_employee_id; + insert into pending_org_changes (employee_id, change_type, effective_date, payload) + values (v_employee_id, 'karenz_return', v_return_date, + jsonb_build_object('employment_type', v_employment_type, 'weekly_hours', v_weekly_hours, + 'teilzeit_art', v_grund, 'teilzeit_bis', nullif(payload->>'teilzeit_bis', ''))); + end if; + + if v_return_date <= current_date then + v_changes := app_aenderung(v_changes, 'Status', v_old.status::text, 'Aktiv'); + v_changes := app_aenderung(v_changes, 'Art der Abwesenheit', v_old.absence_type, null); + v_changes := app_aenderung(v_changes, 'Abwesend ab', v_old.karenz_start_date::text, null); + v_changes := app_aenderung(v_changes, 'Geplante Rückkehr', v_old.karenz_return_date::text, null); + if v_employment_type is not null then + v_changes := app_aenderung(v_changes, 'Beschäftigungsausmaß', v_old.employment_type::text, v_employment_type::text); + v_changes := app_aenderung(v_changes, 'Wochenstunden', v_old.weekly_hours::text, v_weekly_hours::text); + end if; + if payload->>'employment_mode' = 'Teilzeit' then + v_changes := app_aenderung(v_changes, 'Teilzeitvariante', v_old.teilzeit_art, v_grund); + v_changes := app_aenderung(v_changes, 'Teilzeit bis', v_old.teilzeit_bis::text, + case when v_grund is not null then nullif(payload->>'teilzeit_bis', '') else null end); + end if; + end if; + + insert into employee_history (employee_id, event_date, event_type, description, changes) + values (v_employee_id, v_return_date, 'Rückkehr', + 'Rückkehr aus ' || coalesce(v_absence_type, 'Langzeitabwesenheit') || ' am ' || v_return_date + || case when payload->>'employment_mode' = 'Teilzeit' + then ', reduziert auf ' || (payload->>'weekly_hours') || ' h' + || coalesce(' (' || v_grund || ')', '') + else '' end, + v_changes); + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details) + values (app_current_user_id(), current_actor_name(), 'Rückkehr', v_name, v_employee_id, 'Rückkehr am ' || v_return_date || coalesce(' — ' || v_grund, '')); +end; +$function$; + +CREATE OR REPLACE FUNCTION public.delete_history_entry(payload jsonb) + RETURNS void + LANGUAGE plpgsql + SECURITY DEFINER + SET search_path TO 'public', 'pg_temp' +AS $function$ +declare + v_id uuid := (payload->>'history_id')::uuid; + v_eintrag employee_history%rowtype; + v_name text; + v_karte constant jsonb := app_feld_karte(); + v_aenderung jsonb; + v_feld text; + v_wert text; + v_spalte text; + v_typ text; + v_gruppe text; + v_spaeter boolean; + v_zurueckgesetzt jsonb := '[]'::jsonb; + v_setz text[] := '{}'; + v_plan pending_org_changes%rowtype; + v_neuer_payload jsonb; + v_leer boolean; +begin + perform require_hr_admin(); + + select * into v_eintrag from employee_history where id = v_id; + if not found then + raise exception 'Historieneintrag nicht gefunden.'; + end if; + + if v_eintrag.event_type = 'Eintritt' then + raise exception 'Der Eintritt lässt sich nicht löschen — er ist der Anfang der Zeitleiste.'; + end if; + + if v_eintrag.event_type not in ('Stammdatenänderung', 'Vertragsänderung', 'Karenz', 'Rückkehr') then + raise exception 'Dieser Vorgang lässt sich hier nicht zurücknehmen. Für % gibt es den passenden Weg.', v_eintrag.event_type; + end if; + + -- Die Reihenfolge zählt: eine Rückkehr setzt eine Abwesenheit voraus. + -- Bliebe sie stehen, während die Abwesenheit verschwindet, stünde in der + -- Akte eine Rückkehr aus dem Nichts — und der Status ergäbe sich aus + -- einem Eintrag, dessen Ausgangslage gelöscht ist. + if v_eintrag.event_type = 'Karenz' and exists ( + select 1 from employee_history h + where h.employee_id = v_eintrag.employee_id + and h.event_type = 'Rückkehr' + and (h.event_date, h.created_at) > (v_eintrag.event_date, v_eintrag.created_at) + ) then + raise exception 'Zu dieser Abwesenheit gibt es eine Rückkehr. Sie muss zuerst gelöscht werden.'; + end if; + + -- Abwesenheit und Rückkehr haben eigene Vorgänge; in einer geplanten + -- Änderung haben ihre Felder keinen Ort (siehe app_feld_karte). + if v_eintrag.event_type in ('Karenz', 'Rückkehr') and v_eintrag.event_date > current_date then + raise exception 'Diese Abwesenheit ist noch nicht wirksam. Sie muss über den Vorgang selbst abgebrochen werden.'; + end if; + + if v_eintrag.changes is null or jsonb_array_length(v_eintrag.changes) = 0 then + raise exception 'Zu diesem Eintrag sind keine Feldwerte erfasst — es gibt nichts, worauf zurückgesetzt werden könnte.'; + end if; + + select first_name || ' ' || last_name into v_name from employees where id = v_eintrag.employee_id; + + -- ── Noch nicht wirksam: die geplante Änderung entschärfen ────────── + if v_eintrag.event_date > current_date then + if v_eintrag.pending_id is null then + raise exception 'Zu dieser geplanten Änderung ist kein Vorgang hinterlegt. Sie stammt aus der Zeit vor dieser Verknüpfung und lässt sich hier nicht abbrechen.'; + end if; + + select * into v_plan from pending_org_changes where id = v_eintrag.pending_id for update; + if not found or v_plan.status <> 'pending' then + raise exception 'Der geplante Vorgang läuft nicht mehr — er wurde bereits angewendet oder abgebrochen.'; + end if; + + v_neuer_payload := v_plan.payload; + for v_aenderung in select * from jsonb_array_elements(v_eintrag.changes) loop + v_feld := v_aenderung->>'feld'; + if not v_karte ? v_feld then + continue; + end if; + v_spalte := v_karte->v_feld->>0; + v_gruppe := v_karte->v_feld->>2; + if v_neuer_payload ? v_gruppe then + v_neuer_payload := jsonb_set(v_neuer_payload, array[v_gruppe], (v_neuer_payload->v_gruppe) - v_spalte); + end if; + end loop; + + v_leer := coalesce(jsonb_array_length( + (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'person', '{}'::jsonb)) k)), 0) = 0 + and coalesce(jsonb_array_length( + (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'contract', '{}'::jsonb)) k)), 0) = 0 + and coalesce(jsonb_array_length( + (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'role', '{}'::jsonb)) k)), 0) = 0; + + if v_leer then + update pending_org_changes set status = 'cancelled' where id = v_plan.id; + else + update pending_org_changes set payload = v_neuer_payload where id = v_plan.id; + end if; + + delete from employee_history where id = v_id; + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes) + values (app_current_user_id(), current_actor_name(), 'Geplante Änderung abgebrochen', v_name, v_eintrag.employee_id, + v_eintrag.event_type || ' zum ' || v_eintrag.event_date || ' abgebrochen: ' || app_aenderungsfelder(v_eintrag.changes) || + case when v_leer then ' (der Vorgang entfällt ganz)' else ' (der Vorgang läuft mit den übrigen Feldern weiter)' end, + v_eintrag.changes); + return; + end if; + + -- ── Bereits wirksam: Feld für Feld zurücksetzen ──────────────────── + for v_aenderung in select * from jsonb_array_elements(v_eintrag.changes) loop + v_feld := v_aenderung->>'feld'; + + if not v_karte ? v_feld then + continue; + end if; + + select exists ( + select 1 + from employee_history h, + lateral jsonb_array_elements(coalesce(h.changes, '[]'::jsonb)) a + where h.employee_id = v_eintrag.employee_id + and h.id <> v_eintrag.id + and a->>'feld' = v_feld + and (h.event_date, h.created_at) > (v_eintrag.event_date, v_eintrag.created_at) + ) into v_spaeter; + + if v_spaeter then + continue; + end if; + + v_spalte := v_karte->v_feld->>0; + v_typ := v_karte->v_feld->>1; + v_wert := v_aenderung->>'vorher'; + + if v_typ = 'liste' then + v_setz := v_setz || format('%I = coalesce(string_to_array(%L, '', ''), ''{}'')', v_spalte, nullif(v_wert, '')); + else + v_setz := v_setz || format('%I = %L::%s', v_spalte, nullif(v_wert, ''), v_typ); + end if; + + v_zurueckgesetzt := v_zurueckgesetzt || jsonb_build_object( + 'feld', v_feld, + 'vorher', v_aenderung->>'nachher', + 'nachher', v_wert + ); + end loop; + + -- Alles in einem UPDATE: chk_weekly_hours verknüpft Beschäftigungsausmaß + -- und Wochenstunden, und zwischen zwei getrennten Anweisungen stünde + -- zwangsläufig ein Zwischenstand, den die Bedingung verbietet. + if array_length(v_setz, 1) > 0 then + begin + execute format('update employees set %s where id = %L', array_to_string(v_setz, ', '), v_eintrag.employee_id); + exception when check_violation then + raise exception 'Zurücksetzen nicht möglich: die Werte von damals passen nicht mehr zum heutigen Stand (%). Vermutlich wurde ein zusammengehörendes Feld später einzeln geändert.', sqlerrm; + end; + end if; + + delete from employee_history where id = v_id; + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes) + values (app_current_user_id(), current_actor_name(), 'Historieneintrag gelöscht', v_name, v_eintrag.employee_id, + v_eintrag.event_type || ' vom ' || v_eintrag.event_date || + case when jsonb_array_length(v_zurueckgesetzt) = 0 + then ' gelöscht; keine Werte zurückgesetzt (spätere Änderungen gelten)' + else ' gelöscht und zurückgesetzt: ' || app_aenderungsfelder(v_zurueckgesetzt) end, + v_zurueckgesetzt); +end; +$function$; + +CREATE OR REPLACE FUNCTION public.update_history_entry(payload jsonb) + RETURNS void + LANGUAGE plpgsql + SECURITY DEFINER + SET search_path TO 'public', 'pg_temp' +AS $function$ +declare + v_id uuid := (payload->>'history_id')::uuid; + v_eintrag employee_history%rowtype; + v_datum date; + v_name text; + v_karte constant jsonb := app_feld_karte(); + v_alt jsonb; + v_feld text; + v_neuer_wert text; + v_neu jsonb := '[]'::jsonb; + v_korrektur jsonb := '[]'::jsonb; + v_setz text[] := '{}'; + v_spalte text; + v_typ text; + v_gruppe text; + v_gueltig text; + v_plan pending_org_changes%rowtype; + v_neuer_payload jsonb; + v_war_zukunft boolean; +begin + perform require_hr_admin(); + + select * into v_eintrag from employee_history where id = v_id; + if not found then + raise exception 'Historieneintrag nicht gefunden.'; + end if; + + if v_eintrag.event_type = 'Eintritt' then + raise exception 'Der Eintritt lässt sich hier nicht berichtigen.'; + end if; + + if v_eintrag.event_type not in ('Stammdatenänderung', 'Vertragsänderung', 'Karenz', 'Rückkehr') then + raise exception 'Dieser Vorgang lässt sich hier nicht berichtigen. Für % gibt es den passenden Weg.', v_eintrag.event_type; + end if; + + if v_eintrag.event_type in ('Karenz', 'Rückkehr') and v_eintrag.event_date > current_date then + raise exception 'Diese Abwesenheit ist noch nicht wirksam. Sie muss über den Vorgang selbst berichtigt werden.'; + end if; + + if v_eintrag.changes is null or jsonb_array_length(v_eintrag.changes) = 0 then + raise exception 'Zu diesem Eintrag sind keine Feldwerte erfasst — es gibt nichts zu berichtigen.'; + end if; + + v_war_zukunft := v_eintrag.event_date > current_date; + v_datum := coalesce(nullif(payload->>'event_date', '')::date, v_eintrag.event_date); + + -- Ein Eintrag bleibt auf seiner Seite der Gegenwart. Beides zu erlauben + -- hiesse, eine gelaufene Änderung in eine geplante zu verwandeln (oder + -- umgekehrt) — dann müssten Stammdaten und payload gegenläufig angepasst + -- werden, und dafür gibt es die fachlichen Vorgänge. + if v_war_zukunft and v_datum <= current_date then + raise exception 'Eine geplante Änderung lässt sich hier nicht vorziehen. Dafür ist „Daten ändern" der richtige Weg.'; + end if; + if not v_war_zukunft and v_datum > current_date then + raise exception 'Eine bereits wirksame Änderung lässt sich nicht in die Zukunft verschieben.'; + end if; + + select first_name || ' ' || last_name into v_name from employees where id = v_eintrag.employee_id; + + -- Neue Werteliste bauen: Vorher bleibt, Nachher darf ersetzt werden. + for v_alt in select * from jsonb_array_elements(v_eintrag.changes) loop + v_feld := v_alt->>'feld'; + select w->>'nachher' into v_neuer_wert + from jsonb_array_elements(coalesce(payload->'werte', '[]'::jsonb)) w + where w->>'feld' = v_feld; + + if v_neuer_wert is null then + v_neu := v_neu || v_alt; + else + v_neu := v_neu || jsonb_build_object('feld', v_feld, 'vorher', v_alt->>'vorher', 'nachher', nullif(v_neuer_wert, '')); + if coalesce(v_alt->>'nachher', '') is distinct from coalesce(nullif(v_neuer_wert, ''), '') then + v_korrektur := v_korrektur || jsonb_build_object('feld', v_feld, 'vorher', v_alt->>'nachher', 'nachher', nullif(v_neuer_wert, '')); + end if; + end if; + end loop; + + if jsonb_array_length(v_korrektur) = 0 and v_datum = v_eintrag.event_date then + raise exception 'Nichts geändert.'; + end if; + + update employee_history + set changes = v_neu, + event_date = v_datum, + description = 'Geänderte Felder: ' || app_aenderungsfelder(v_neu) || ', wirksam ab ' || v_datum + where id = v_id; + + -- ── Noch nicht wirksam: den geplanten Vorgang nachziehen ─────────── + if v_war_zukunft then + if v_eintrag.pending_id is null then + raise exception 'Zu dieser geplanten Änderung ist kein Vorgang hinterlegt. Sie stammt aus der Zeit vor dieser Verknüpfung und lässt sich hier nicht berichtigen.'; + end if; + + select * into v_plan from pending_org_changes where id = v_eintrag.pending_id for update; + if not found or v_plan.status <> 'pending' then + raise exception 'Der geplante Vorgang läuft nicht mehr — er wurde bereits angewendet oder abgebrochen.'; + end if; + + v_neuer_payload := jsonb_set(v_plan.payload, '{effective_date}', to_jsonb(v_datum::text)); + for v_alt in select * from jsonb_array_elements(v_neu) loop + v_feld := v_alt->>'feld'; + if not v_karte ? v_feld then + continue; + end if; + v_spalte := v_karte->v_feld->>0; + v_typ := v_karte->v_feld->>1; + v_gruppe := v_karte->v_feld->>2; + if not v_neuer_payload ? v_gruppe then + v_neuer_payload := jsonb_set(v_neuer_payload, array[v_gruppe], '{}'::jsonb); + end if; + v_neuer_payload := jsonb_set( + v_neuer_payload, + array[v_gruppe, v_spalte], + case + when v_alt->>'nachher' is null then 'null'::jsonb + when v_typ = 'liste' then to_jsonb(string_to_array(v_alt->>'nachher', ', ')) + when v_typ = 'boolean' then to_jsonb((v_alt->>'nachher')::boolean) + when v_typ = 'numeric' then to_jsonb((v_alt->>'nachher')::numeric) + else to_jsonb(v_alt->>'nachher') + end, + true); + end loop; + + update pending_org_changes + set payload = v_neuer_payload, effective_date = v_datum + where id = v_plan.id; + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes) + values (app_current_user_id(), current_actor_name(), 'Geplante Änderung berichtigt', v_name, v_eintrag.employee_id, + v_eintrag.event_type || ' zum ' || v_eintrag.event_date || + case when v_datum <> v_eintrag.event_date then ' auf ' || v_datum || ' verschoben' else '' end || + case when jsonb_array_length(v_korrektur) > 0 then '; berichtigt: ' || app_aenderungsfelder(v_korrektur) else '' end, + v_korrektur); + return; + end if; + + -- ── Bereits wirksam: Stammdaten nachziehen ───────────────────────── + for v_feld in select distinct e->>'feld' from jsonb_array_elements(v_neu) e loop + if not v_karte ? v_feld then + continue; + end if; + + select a->>'nachher' into v_gueltig + from employee_history h, + lateral jsonb_array_elements(coalesce(h.changes, '[]'::jsonb)) a + where h.employee_id = v_eintrag.employee_id + and a->>'feld' = v_feld + and h.event_date <= current_date + order by h.event_date desc, h.created_at desc + limit 1; + + v_spalte := v_karte->v_feld->>0; + v_typ := v_karte->v_feld->>1; + + if v_typ = 'liste' then + v_setz := v_setz || format('%I = coalesce(string_to_array(%L, '', ''), ''{}'')', v_spalte, nullif(v_gueltig, '')); + else + v_setz := v_setz || format('%I = %L::%s', v_spalte, nullif(v_gueltig, ''), v_typ); + end if; + end loop; + + if array_length(v_setz, 1) > 0 then + begin + execute format('update employees set %s where id = %L', array_to_string(v_setz, ', '), v_eintrag.employee_id); + exception when check_violation then + raise exception 'Der berichtigte Wert passt nicht zum übrigen Stand (%). Zusammengehörende Felder — etwa Beschäftigungsausmaß und Wochenstunden — müssen gemeinsam stimmen.', sqlerrm; + end; + end if; + + insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes) + values (app_current_user_id(), current_actor_name(), 'Historieneintrag berichtigt', v_name, v_eintrag.employee_id, + v_eintrag.event_type || ' vom ' || v_eintrag.event_date || + case when v_datum <> v_eintrag.event_date then ' auf ' || v_datum || ' umdatiert' else '' end || + case when jsonb_array_length(v_korrektur) > 0 + then '; berichtigt: ' || app_aenderungsfelder(v_korrektur) else '' end, + v_korrektur); +end; +$function$; + + +-- Selbstprüfung. +do $$ +declare + v_start text := pg_get_functiondef('public.start_karenz(jsonb)'::regprocedure); + v_ret text := pg_get_functiondef('public.record_karenz_return(jsonb)'::regprocedure); + v_del text := pg_get_functiondef('public.delete_history_entry(jsonb)'::regprocedure); + v_upd text := pg_get_functiondef('public.update_history_entry(jsonb)'::regprocedure); +begin + if v_start not like '%description, changes%' then + raise exception 'start_karenz hält keine Vorher-Werte fest'; + end if; + if v_ret not like '%description, changes%' then + raise exception 'record_karenz_return hält keine Vorher-Werte fest'; + end if; + if v_del not like '%muss zuerst gelöscht werden%' then + raise exception 'Die Reihenfolgeregel fehlt'; + end if; + if v_upd not like '%''Karenz'', ''Rückkehr''%' then + raise exception 'update_history_entry lässt die zwei Typen nicht zu'; + end if; + if not (app_feld_karte() ? 'Art der Abwesenheit' and app_feld_karte() ? 'Status') then + raise exception 'Die Feldtabelle kennt die Felder der Abwesenheit nicht'; + end if; +end +$$; diff --git a/tests/unit/history.test.ts b/tests/unit/history.test.ts index 95467d5..88b5953 100644 --- a/tests/unit/history.test.ts +++ b/tests/unit/history.test.ts @@ -30,7 +30,7 @@ describe("darfKorrigiertWerden", () => { expect(u.erlaubt === false && u.grund).toMatch(/Anfang der Zeitleiste/); }); - it.each(["Versetzung", "Beförderung", "Karenz", "Rückkehr", "Austritt", "Wiedereintritt", "Reorganisation"])( + it.each(["Versetzung", "Beförderung", "Austritt", "Wiedereintritt", "Reorganisation"])( "verweist bei %s auf den fachlichen Vorgang", (typ) => { const u = darfKorrigiertWerden(eintrag({ event_type: typ }), HEUTE); @@ -39,6 +39,14 @@ describe("darfKorrigiertWerden", () => { } ); + it("lässt Abwesenheit und Rückkehr zu", () => { + // Eine versehentlich erfasste Abwesenheit war sonst nur durch eine zweite + // Buchung loszuwerden — und dann stünden zwei Einträge in der Akte, von + // denen der erste nie stattgefunden hat. + expect(darfKorrigiertWerden(eintrag({ event_type: "Karenz" }), HEUTE).erlaubt).toBe(true); + expect(darfKorrigiertWerden(eintrag({ event_type: "Rückkehr" }), HEUTE).erlaubt).toBe(true); + }); + it("lässt Zukünftiges zu, sobald der geplante Vorgang bekannt ist", () => { // Das ist der Sinn von pending_id: ohne Bezug liesse sich die geplante // Änderung nur über Person und Datum finden, und das ist nicht eindeutig. @@ -113,3 +121,38 @@ describe("loeschVorschau", () => { expect(v).toMatchObject({ feld: "Adresse", von: "Endstrasse 9", auf: "Zwischenweg 1" }); }); }); + +// Die Reihenfolge zählt: eine Rückkehr setzt eine Abwesenheit voraus. Bliebe +// sie stehen, während die Abwesenheit verschwindet, stünde in der Akte eine +// Rückkehr aus dem Nichts — und der Status ergäbe sich aus einem Eintrag, +// dessen Ausgangslage gelöscht ist. +describe("Reihenfolge von Abwesenheit und Rückkehr", () => { + const karenz = eintrag({ id: "k", event_type: "Karenz", event_date: "2026-07-15", created_at: "2026-07-15T09:00:00.000Z" }); + const rueckkehr = eintrag({ id: "r", event_type: "Rückkehr", event_date: "2026-08-10", created_at: "2026-08-10T09:00:00.000Z" }); + + it("verweigert die Abwesenheit, solange die Rückkehr steht", () => { + const u = darfKorrigiertWerden(karenz, HEUTE, [karenz, rueckkehr]); + expect(u.erlaubt).toBe(false); + expect(u.erlaubt === false && u.grund).toMatch(/Rückkehr.*zuerst gelöscht/); + }); + + it("lässt die Rückkehr jederzeit zurücknehmen — sie ist das obere Ende", () => { + expect(darfKorrigiertWerden(rueckkehr, HEUTE, [karenz, rueckkehr]).erlaubt).toBe(true); + }); + + it("gibt die Abwesenheit frei, sobald die Rückkehr weg ist", () => { + expect(darfKorrigiertWerden(karenz, HEUTE, [karenz]).erlaubt).toBe(true); + }); + + it("stört sich nicht an einer früheren Rückkehr aus einer anderen Abwesenheit", () => { + const frueher = eintrag({ id: "r0", event_type: "Rückkehr", event_date: "2026-01-05", created_at: "2026-01-05T09:00:00.000Z" }); + expect(darfKorrigiertWerden(karenz, HEUTE, [frueher, karenz]).erlaubt).toBe(true); + }); + + it("lässt eine noch nicht wirksame Abwesenheit in Ruhe", () => { + const geplant = eintrag({ event_type: "Karenz", event_date: "2099-01-01", pending_id: "p1" }); + const u = darfKorrigiertWerden(geplant, HEUTE, [geplant]); + expect(u.erlaubt).toBe(false); + expect(u.erlaubt === false && u.grund).toMatch(/noch nicht wirksam/); + }); +});