diff --git a/CHANGELOG.md b/CHANGELOG.md index 0e903ba..6cc0731 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.8.0 + +- Neuer Reiter „Personal“: alle Mitarbeiter mit Arbeitszeit, was heute ist (z. B. Urlaub oder „4 von 8 Std.“), Resturlaub und offenen Urlaubsanträgen. +- Je Mitarbeiter: Stammdaten (Personalnummer fürs Steuerbüro, Eintritt, Urlaubsanspruch, Lohnkosten je Stunde nur für dich), Arbeitszeitmodell mit Stunden je Wochentag und „gültig ab“, damit ein Wechsel auf Teilzeit die frühere Planung nicht ändert. +- Abwesenheiten: Urlaub, Krank, Berufsschule, Frei und „Nicht verfügbar“, ganztags, halber Tag oder stundengenau (z. B. „Do nur bis 12 Uhr“). Urlaubskonto mit Anspruch, Übertrag, genommen, geplant, beantragt und Rest; Feiertage und freie Tage zählen nicht als Urlaub. +- Verfügbarkeit der nächsten vier Wochen je Mitarbeiter: frei schraffiert, teilweise verfügbar halb gefüllt mit Stundenzahl. + ## 0.7.0 - Stufe 2 beginnt: Anmeldung und Rollen. Jede Person meldet sich mit eigenem Anmeldenamen und Passwort an; am Handy bleibt sie 90 Tage angemeldet. Unten links stehen Name, „Passwort ändern“ und „Abmelden“. diff --git a/demo/kern.ts b/demo/kern.ts index bd1844c..db6295d 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -9,11 +9,12 @@ import m004 from "../src/server/migrations/004_besetzung.sql"; import m005 from "../src/server/migrations/005_projektseite_kategorien.sql"; import m006 from "../src/server/migrations/006_zahlungsplan_automatisch.sql"; import m007 from "../src/server/migrations/007_anmeldung.sql"; +import m008 from "../src/server/migrations/008_personal.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], ["005_projektseite_kategorien.sql", m005], ["006_zahlungsplan_automatisch.sql", m006], - ["007_anmeldung.sql", m007], + ["007_anmeldung.sql", m007], ["008_personal.sql", m008], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index b34bf6a..1bedb14 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.7.0", + "version": "0.8.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/personal.ts b/src/domain/personal.ts new file mode 100644 index 0000000..f9ec141 --- /dev/null +++ b/src/domain/personal.ts @@ -0,0 +1,127 @@ +// M8: Arbeitszeitmodell je Person mit Gültig-ab-Datum, M4: Abwesenheiten, M10: Urlaubskonto. +// Grundlage für Zeiterfassung (Soll), Dauer aus Verfügbarkeit (T15) und Auslastung (T16). + +import { type Datum, jahrVon, plusTage, wochentag } from "./datum.js"; +import { feiertag } from "./kalender.js"; + +export interface Modell { + kontakt_id: string; + gueltig_ab: Datum; + /** Stunden Mo … So */ + stunden: number[]; +} + +export type AbwesenheitArt = "urlaub" | "krank" | "schule" | "frei" | "sperre"; + +export interface Abwesenheit { + id?: string; + kontakt_id: string; + art: AbwesenheitArt; + von: Datum; + bis: Datum; + /** halber Urlaubstag (nur bei einem einzelnen Tag) */ + halbtag?: boolean; + /** stundengenau, z. B. „Do nur bis 12 Uhr“ oder Arzttermin: so viele Stunden fehlen je Tag; leer = ganzer Tag */ + stunden?: number | null; + status: "beantragt" | "genehmigt" | "abgelehnt"; +} + +export const ABWESENHEIT_TEXT: Record = { + urlaub: "Urlaub", krank: "Krank", schule: "Berufsschule", frei: "Frei", sperre: "Nicht verfügbar", +}; + +/** Ohne eigenes Modell: Mo–Fr je stundenProTag (Vorgabe 8) */ +export const standardStunden = (stundenProTag = 8): number[] => [1, 2, 3, 4, 5, 6, 7].map((t) => (t <= 5 ? stundenProTag : 0)); + +/** Das Modell, das an einem Tag gilt: das mit dem spätesten Gültig-ab bis zu diesem Tag */ +export function modellAm(modelle: Modell[], kontaktId: string, d: Datum): Modell | undefined { + let treffer: Modell | undefined; + for (const m of modelle) { + if (m.kontakt_id !== kontaktId || m.gueltig_ab > d) continue; + if (!treffer || m.gueltig_ab > treffer.gueltig_ab) treffer = m; + } + return treffer; +} + +/** Vertragliche Stunden an einem Tag (Feiertage 0) */ +export function sollStunden(modelle: Modell[], kontaktId: string, d: Datum, stundenProTag = 8): number { + if (feiertag(d)) return 0; + const m = modellAm(modelle, kontaktId, d); + return (m?.stunden ?? standardStunden(stundenProTag))[wochentag(d) - 1] ?? 0; +} + +/** Stunden, die eine Abwesenheit an einem Tag wegnimmt, höchstens das Soll */ +export function abwesendStunden(a: Abwesenheit, soll: number): number { + if (a.stunden != null) return Math.min(soll, Math.max(0, a.stunden)); + if (a.halbtag) return soll / 2; + return soll; +} + +/** Wirksame Abwesenheiten: genehmigt. Beantragter Urlaub sperrt noch nicht (M10). */ +export const wirksam = (a: Abwesenheit) => a.status === "genehmigt"; + +export interface Tag { + datum: Datum; + soll: number; + frei: number; + /** Abwesenheiten an diesem Tag, wirksame zuerst */ + abwesend: Abwesenheit[]; + feiertag?: string; +} + +/** Verfügbarkeit einer Person je Tag im Zeitraum */ +export function verfuegbarkeit(modelle: Modell[], abwesenheiten: Abwesenheit[], kontaktId: string, von: Datum, bis: Datum, stundenProTag = 8): Tag[] { + const eigene = abwesenheiten.filter((a) => a.kontakt_id === kontaktId && a.status !== "abgelehnt" && a.bis >= von && a.von <= bis); + const aus: Tag[] = []; + for (let d = von; d <= bis; d = plusTage(d, 1)) { + const soll = sollStunden(modelle, kontaktId, d, stundenProTag); + const heute = eigene.filter((a) => a.von <= d && a.bis >= d).sort((a, b) => Number(wirksam(b)) - Number(wirksam(a))); + const weg = heute.filter(wirksam).reduce((s, a) => s + abwesendStunden(a, soll), 0); + aus.push({ datum: d, soll, frei: Math.max(0, soll - weg), abwesend: heute, feiertag: feiertag(d)?.name }); + } + return aus; +} + +/** Urlaubstage einer Abwesenheit in einem Jahr: Tage mit Soll > 0 (keine Feiertage, keine freien Tage), halber Tag = 0,5 */ +export function urlaubstage(a: Abwesenheit, modelle: Modell[], jahr: number, stundenProTag = 8, nurBis?: Datum, nurAb?: Datum): number { + let n = 0; + for (let d = a.von; d <= a.bis; d = plusTage(d, 1)) { + if (jahrVon(d) !== jahr || (nurBis && d > nurBis) || (nurAb && d < nurAb)) continue; + if (sollStunden(modelle, a.kontakt_id, d, stundenProTag) > 0) n += a.halbtag ? 0.5 : 1; + } + return n; +} + +export interface Urlaubskonto { + jahr: number; + anspruch: number; + uebertrag: number; + /** genehmigt und schon vorbei (bis einschließlich heute) */ + genommen: number; + /** genehmigt und noch in der Zukunft */ + geplant: number; + beantragt: number; + rest: number; +} + +export function urlaubskonto(kontaktId: string, jahr: number, heute: Datum, anspruch: number, uebertrag: number, + abwesenheiten: Abwesenheit[], modelle: Modell[], stundenProTag = 8): Urlaubskonto { + const urlaub = abwesenheiten.filter((a) => a.kontakt_id === kontaktId && a.art === "urlaub"); + let genommen = 0, geplant = 0, beantragt = 0; + const morgen = plusTage(heute, 1); + for (const a of urlaub) { + if (a.status === "genehmigt") { + genommen += urlaubstage(a, modelle, jahr, stundenProTag, heute); + geplant += urlaubstage(a, modelle, jahr, stundenProTag, undefined, morgen); + } else if (a.status === "beantragt") beantragt += urlaubstage(a, modelle, jahr, stundenProTag); + } + return { jahr, anspruch, uebertrag, genommen, geplant, beantragt, rest: anspruch + uebertrag - genommen - geplant }; +} + +/** „Mo 8 · Di 8 · Mi 8 · Do 8 · Fr 6 = 38 Std.“ ohne freie Tage */ +export function modellText(stunden: number[]): string { + const namen = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; + const zahl = (h: number) => String(h).replace(".", ","); + const teile = stunden.map((h, i) => (h > 0 ? `${namen[i]} ${zahl(h)}` : "")).filter(Boolean); + return `${teile.join(" · ")} = ${zahl(stunden.reduce((s, h) => s + h, 0))} Std.`; +} diff --git a/src/server/app.ts b/src/server/app.ts index 25c6134..877de62 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -21,6 +21,7 @@ import { benutzerFuerSicherung, pruefeStand, speichereStand } from "./stand.js"; import { VERSION } from "./version.js"; import { type Anmeldeart, registriereAnmeldung, werName } from "./anmeldung.js"; import { istEingeteilt, registriereIch } from "./ich.js"; +import { registrierePersonal } from "./personal.js"; export interface Optionen { pool: Pool; @@ -62,6 +63,7 @@ export async function baueApp(o: Optionen): Promise { registriereAnmeldung(app, pool, o.anmeldung ?? "passwort", o.einrichtungsCode); registriereIch(app, pool, ladeEinstellungen); + registrierePersonal(app, pool, ladeEinstellungen); app.get("/api/status", async () => { await pool.query("select 1"); @@ -158,20 +160,32 @@ export async function baueApp(o: Optionen): Promise { const projektDerZahlung = async (c: Client, tabelle: string, id: string) => tabelle === "zahlung" ? (await c.query("select projekt_id from zahlung where id = $1", [id])).rows[0]?.projekt_id as string | undefined : undefined; + // U2: Felder wie der Stundenlohn gehen nur an den Inhaber; Zahlen-Arrays (Arbeitszeitmodell) als Zahlen + const fuer = (req: FastifyRequest, t: (typeof TABELLEN)[number]) => (z: Record | undefined) => { + if (!z) return z; + const aus: Record = { ...z }; + if (req.wer?.rolle !== "inhaber") for (const f of t.nurInhaber ?? []) delete aus[f]; + for (const [k, v] of Object.entries(aus)) if (Array.isArray(v)) aus[k] = v.map((x) => (typeof x === "string" && /^-?\d+(\.\d+)?$/.test(x) ? Number(x) : x)); + return aus; + }; + const verboten = (req: FastifyRequest, t: (typeof TABELLEN)[number], daten: Record) => + req.wer?.rolle !== "inhaber" && (t.nurInhaber ?? []).some((f) => daten[f] !== undefined); + for (const t of TABELLEN) { const felder = Object.keys(t.schema.shape); const teil = t.schema.partial(); - app.get(`/api/${t.pfad}`, async () => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows); + app.get(`/api/${t.pfad}`, async (req) => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows.map(fuer(req, t))); app.get(`/api/${t.pfad}/:id`, async (req, reply) => { const { id } = IdParam.parse(req.params); const r = await pool.query(`select * from ${t.name} where id = $1`, [id]); - return r.rows[0] ?? reply.status(404).send({ fehler: "Nicht gefunden" }); + return fuer(req, t)(r.rows[0]) ?? reply.status(404).send({ fehler: "Nicht gefunden" }); }); app.post(`/api/${t.pfad}`, async (req, reply) => { const daten = t.schema.parse(req.body) as Record; + if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); const spalten = felder.filter((f) => daten[f] !== undefined); const row = await transaktion(pool, benutzer(req), async (c) => { if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string }); @@ -184,12 +198,13 @@ export async function baueApp(o: Optionen): Promise { )).rows[0], [], t.name === "zahlung" ? daten.projekt_id as string : undefined); }); if (t.name === "projekt") return reply.status(201).send(await mitOrdner(row, benutzer(req))); - return reply.status(201).send(row); + return reply.status(201).send(fuer(req, t)(row)); }); app.patch(`/api/${t.pfad}/:id`, async (req, reply) => { const { id } = IdParam.parse(req.params); const daten = teil.parse(req.body) as Record; + if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); const spalten = felder.filter((f) => daten[f] !== undefined); if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); const row = await transaktion(pool, benutzer(req), async (c) => { @@ -205,7 +220,7 @@ export async function baueApp(o: Optionen): Promise { )).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : [], zahlungVon); }); if (row && t.name === "projekt" && (daten.nummer || daten.bezeichnung || daten.status)) return mitOrdner(row, benutzer(req)); - return row ?? reply.status(404).send({ fehler: "Nicht gefunden" }); + return fuer(req, t)(row) ?? reply.status(404).send({ fehler: "Nicht gefunden" }); }); app.delete(`/api/${t.pfad}/:id`, async (req, reply) => { diff --git a/src/server/migrations/008_personal.sql b/src/server/migrations/008_personal.sql new file mode 100644 index 0000000..2fcfe2c --- /dev/null +++ b/src/server/migrations/008_personal.sql @@ -0,0 +1,71 @@ +-- Stufe 2, Personal: Stammdaten je Mitarbeiter (M1), Arbeitszeitmodell mit Gültig-ab (M8), +-- Abwesenheiten mit Urlaubsantrag (M4, M10) und Urlaubskonto je Jahr. + +create table mitarbeiter ( + id uuid primary key default gen_random_uuid(), + kontakt_id uuid not null unique references kontakt (id) on delete cascade, + personalnummer text, + eintritt date, + austritt date, + -- angestellt: Pausenregel M3 und Übergabe ans Steuerbüro; der Inhaber nicht + angestellt boolean not null default true, + -- Lohnkosten je Stunde in Cent, sieht nur der Inhaber (U2) + lohn_cent bigint check (lohn_cent >= 0), + urlaubstage numeric(4, 1) not null default 30 check (urlaubstage >= 0), + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create trigger mitarbeiter_protokoll before insert or update or delete on mitarbeiter + for each row execute function stempel_und_protokoll(); + +create table arbeitszeitmodell ( + id uuid primary key default gen_random_uuid(), + kontakt_id uuid not null references kontakt (id) on delete cascade, + gueltig_ab date not null, + -- Stunden Mo … So + stunden numeric(4, 2)[] not null check (array_length(stunden, 1) = 7 and 0 <= all (stunden) and 24 >= all (stunden)), + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system', + unique (kontakt_id, gueltig_ab) +); +create trigger arbeitszeitmodell_protokoll before insert or update or delete on arbeitszeitmodell + for each row execute function stempel_und_protokoll(); + +create table abwesenheit ( + id uuid primary key default gen_random_uuid(), + kontakt_id uuid not null references kontakt (id) on delete cascade, + art text not null check (art in ('urlaub', 'krank', 'schule', 'frei', 'sperre')), + von date not null, + bis date not null, + halbtag boolean not null default false, + stunden numeric(4, 2) check (stunden > 0), + status text not null default 'genehmigt' check (status in ('beantragt', 'genehmigt', 'abgelehnt')), + notiz text, + -- Antwort auf einen Urlaubsantrag, sieht der Mitarbeiter + antwort text, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system', + check (bis >= von), + check (not halbtag or von = bis) +); +create index abwesenheit_kontakt on abwesenheit (kontakt_id, von); +create trigger abwesenheit_protokoll before insert or update or delete on abwesenheit + for each row execute function stempel_und_protokoll(); + +-- Übertrag aus dem Vorjahr und abweichender Anspruch je Jahr; ohne Zeile gilt mitarbeiter.urlaubstage +create table urlaubskonto ( + id uuid primary key default gen_random_uuid(), + kontakt_id uuid not null references kontakt (id) on delete cascade, + jahr integer not null, + anspruch numeric(4, 1), + uebertrag numeric(4, 1) not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system', + unique (kontakt_id, jahr) +); +create trigger urlaubskonto_protokoll before insert or update or delete on urlaubskonto + for each row execute function stempel_und_protokoll(); diff --git a/src/server/personal.ts b/src/server/personal.ts new file mode 100644 index 0000000..0fc2a69 --- /dev/null +++ b/src/server/personal.ts @@ -0,0 +1,79 @@ +// Personal auf dem Server: Übersicht je Mitarbeiter mit Arbeitszeitmodell, Urlaubskonto und Verfügbarkeit. +import type { FastifyInstance } from "fastify"; +import { z } from "zod"; +import type { Pool } from "./db.js"; +import type { Einstellungen } from "./einstellungen.js"; +import { type Abwesenheit, type Modell, standardStunden, urlaubskonto, verfuegbarkeit, modellAm } from "../domain/personal.js"; +import { plusTage } from "../domain/datum.js"; + +const Tag = z.string().regex(/^\d{4}-\d{2}-\d{2}$/); + +export interface Personalstand { + modelle: Modell[]; + abwesenheiten: (Abwesenheit & { id: string; notiz: string | null; antwort: string | null })[]; + stammdaten: Map>; + konten: Map>; +} + +/** Modelle, Abwesenheiten, Stammdaten und Urlaubskonten; optional nur für einen Kontakt */ +export async function ladePersonal(pool: Pick, kontaktId?: string): Promise { + const wo = kontaktId ? "where kontakt_id = $1" : ""; + const p = kontaktId ? [kontaktId] : []; + const [m, a, s, k] = await Promise.all([ + pool.query(`select kontakt_id, gueltig_ab, stunden from arbeitszeitmodell ${wo} order by gueltig_ab`, p), + pool.query(`select * from abwesenheit ${wo} order by von`, p), + pool.query(`select * from mitarbeiter ${wo}`, p), + pool.query(`select * from urlaubskonto ${wo}`, p), + ]); + return { + modelle: m.rows.map((r) => ({ ...r, stunden: (r.stunden as unknown[]).map(Number) })), + abwesenheiten: a.rows.map((r) => ({ ...r, stunden: r.stunden == null ? null : Number(r.stunden) })), + stammdaten: new Map(s.rows.map((r) => [r.kontakt_id, r])), + konten: new Map(k.rows.map((r) => [`${r.kontakt_id}/${r.jahr}`, r])), + }; +} + +export function kontoFuer(st: Personalstand, kontaktId: string, jahr: number, heute: string, stundenProTag: number) { + const s = st.stammdaten.get(kontaktId); + const k = st.konten.get(`${kontaktId}/${jahr}`); + const anspruch = k?.anspruch != null ? Number(k.anspruch) : s ? Number(s.urlaubstage) : 30; + return urlaubskonto(kontaktId, jahr, heute, anspruch, Number(k?.uebertrag ?? 0), st.abwesenheiten, st.modelle, stundenProTag); +} + +export function registrierePersonal(app: FastifyInstance, pool: Pool, einstellungen: () => Promise): void { + // Liste für die Seite Personal: je Mitarbeiter Modell, Urlaub und was heute ist + app.get("/api/personal", async (req) => { + const q = z.object({ heute: Tag.optional() }).parse(req.query); + const heute = q.heute ?? new Date().toISOString().slice(0, 10); + const e = await einstellungen(); + const [kontakte, st] = await Promise.all([ + pool.query("select k.id, k.name, k.telefon, k.email, b.id as benutzer_id, b.anmeldename, b.rolle as benutzer_rolle from kontakt k left join benutzer b on b.kontakt_id = k.id where k.rolle = 'mitarbeiter' order by k.name"), + ladePersonal(pool), + ]); + const inhaber = req.wer?.rolle === "inhaber"; + return kontakte.rows.map((k) => { + const s = st.stammdaten.get(k.id) ?? null; + const [tag] = verfuegbarkeit(st.modelle, st.abwesenheiten, k.id, heute, heute, e.stundenProTag); + return { + ...k, + stammdaten: s && !inhaber ? { ...s, lohn_cent: undefined } : s, + stunden: modellAm(st.modelle, k.id, heute)?.stunden ?? standardStunden(e.stundenProTag), + eigenesModell: !!modellAm(st.modelle, k.id, heute), + urlaub: kontoFuer(st, k.id, Number(heute.slice(0, 4)), heute, e.stundenProTag), + heute: tag, + antraege: st.abwesenheiten.filter((a) => a.kontakt_id === k.id && a.status === "beantragt").length, + }; + }); + }); + + // Verfügbare Stunden je Person und Tag (M8, Grundlage für T15/T16) + app.get("/api/verfuegbarkeit", async (req) => { + const q = z.object({ von: Tag, bis: Tag.optional(), kontakt_id: z.uuid().optional() }).parse(req.query); + const bis = q.bis ?? plusTage(q.von, 27); + if (bis < q.von || bis > plusTage(q.von, 400)) throw Object.assign(new Error("Zeitraum ungültig"), { statusCode: 400 }); + const e = await einstellungen(); + const kontakte = (await pool.query("select id, name from kontakt where rolle = 'mitarbeiter' and ($1::uuid is null or id = $1) order by name", [q.kontakt_id ?? null])).rows; + const st = await ladePersonal(pool, q.kontakt_id); + return kontakte.map((k) => ({ kontakt_id: k.id, name: k.name, tage: verfuegbarkeit(st.modelle, st.abwesenheiten, k.id, q.von, bis, e.stundenProTag) })); + }); +} diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 245852e..a6236ef 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -12,6 +12,8 @@ export interface Tabelle { pfad: string; schema: z.ZodObject; sortierung: string; + /** Felder, die nur der Inhaber sieht und ändert (U2: Löhne) */ + nurInhaber?: string[]; } export const TABELLEN: Tabelle[] = [ @@ -180,4 +182,57 @@ export const TABELLEN: Tabelle[] = [ erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(), }), }, + // Stufe 2: Personal (M1, M8, M4, M10) + { + name: "mitarbeiter", + pfad: "mitarbeiter", + sortierung: "angelegt_am", + nurInhaber: ["lohn_cent"], + schema: z.object({ + kontakt_id: id, + personalnummer: optText, + eintritt: datum.nullable().optional(), + austritt: datum.nullable().optional(), + angestellt: z.boolean().optional(), + lohn_cent: cent.min(0).nullable().optional(), + urlaubstage: z.number().min(0).max(60).optional(), + }), + }, + { + name: "arbeitszeitmodell", + pfad: "arbeitszeitmodelle", + sortierung: "kontakt_id, gueltig_ab", + schema: z.object({ + kontakt_id: id, + gueltig_ab: datum, + stunden: z.array(z.number().min(0).max(24)).length(7, "Stunden für Montag bis Sonntag"), + }), + }, + { + name: "abwesenheit", + pfad: "abwesenheiten", + sortierung: "von, kontakt_id", + schema: z.object({ + kontakt_id: id, + art: z.enum(["urlaub", "krank", "schule", "frei", "sperre"]), + von: datum, + bis: datum, + halbtag: z.boolean().optional(), + stunden: z.number().positive().max(24).nullable().optional(), + status: z.enum(["beantragt", "genehmigt", "abgelehnt"]).optional(), + notiz: optText, + antwort: optText, + }), + }, + { + name: "urlaubskonto", + pfad: "urlaubskonten", + sortierung: "kontakt_id, jahr", + schema: z.object({ + kontakt_id: id, + jahr: z.number().int().min(2000).max(2100), + anspruch: z.number().min(0).max(60).nullable().optional(), + uebertrag: z.number().min(-60).max(60).optional(), + }), + }, ]; diff --git a/src/web/app.ts b/src/web/app.ts index afb96e5..2b06176 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -5,6 +5,7 @@ import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeite huelle, inhalt, optionenHtml, seite, tabelle, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js"; import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js"; import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js"; +import { mitarbeiterSeite, personalSeite } from "./personal.js"; // ---------- Reiter ---------- @@ -777,7 +778,7 @@ function reiterFuer(s: Sitzung): Reiter[] { if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]]; const alle: Reiter[] = [ ["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte], - ["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte], + ["terminplan", "Terminplan", terminplan], ["personal", "Personal", personalSeite], ["kontakte", "Kontakte", kontakte], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten], ]; if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); @@ -794,6 +795,7 @@ const SYMBOLE: Record = { liquiditaet: '', "laufende-kosten": '', benutzer: '', + personal: '', "meine-einsaetze": '', daten: '', }; @@ -801,6 +803,7 @@ const symbol = (id: string) => ` { const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r; if (r) location.hash = r; @@ -811,12 +814,15 @@ async function zeige(): Promise { // Projektseite: #projekt-, gehört zum Reiter Projekte; Mitarbeiter: #ablage- const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id); const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1]; + const mitarbeiter = /^mitarbeiter-([0-9a-f-]{36})$/.exec(id)?.[1]; const projekt = treffer?.[1]; if (treffer?.[2]) projektTeil = treffer[2]; - const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : id)) ?? REITER[0]!; + const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : mitarbeiter ? "personal" : id)) ?? REITER[0]!; nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0])); try { - await (ablage ? ablageSeite(ablage) : projekt && REITER.some(([r]) => r === "projekte") ? projektSeite(projekt) : reiter[2]()); + await (ablage ? ablageSeite(ablage) + : mitarbeiter && reiter[0] === "personal" ? mitarbeiterSeite(mitarbeiter, sitzung?.benutzer?.rolle === "inhaber") + : projekt && reiter[0] === "projekte" ? projektSeite(projekt) : reiter[2]()); } catch (e) { inhalt.insertAdjacentHTML("beforeend", `

${esc((e as Error).message)}

`); } @@ -834,6 +840,7 @@ async function start(): Promise { s = await api("sitzung"); } if (!s.benutzer) return anmeldeSeite(s); + sitzung = s; abgemeldet.melden = () => { location.hash = ""; location.reload(); }; document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter"); REITER = reiterFuer(s); diff --git a/src/web/personal.ts b/src/web/personal.ts new file mode 100644 index 0000000..e6b75f8 --- /dev/null +++ b/src/web/personal.ts @@ -0,0 +1,210 @@ +// Personal (Lastenheft 5.1): Mitarbeiter mit Stammdaten, Arbeitszeitmodell (M8), Abwesenheiten (M4) und Urlaubskonto (M10). +// Inhaber und Büro; den Stundenlohn sieht nur der Inhaber (U2). + +import { formatEuro } from "../domain/geld.js"; +import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/personal.js"; +import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite, tabelle } from "./ui.js"; + +const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; +const zahl = (h: number | null | undefined) => (h == null ? "" : String(Math.round(h * 100) / 100).replace(".", ",")); +const tageText = (n: number) => `${zahl(n)} ${n === 1 ? "Tag" : "Tage"}`; +const wtag = (d: string) => (new Date(`${d}T00:00:00Z`).getUTCDay() + 6) % 7; +const ARTEN = Object.entries(ABWESENHEIT_TEXT) as [AbwesenheitArt, string][]; +const STATUS: [string, string][] = [["genehmigt", "genehmigt"], ["beantragt", "beantragt"], ["abgelehnt", "abgelehnt"]]; + +/** Kurz, was heute ist: „Urlaub“, „4 von 8 Std.“, „8 Std.“, „frei“ */ +function heuteText(t: Zeile | undefined): string { + if (!t) return ""; + const a = t.abwesend.find((x: Zeile) => x.status === "genehmigt"); + if (t.feiertag) return `${esc(t.feiertag)}`; + if (t.soll === 0) return 'frei'; + if (a && t.frei === 0) return `${esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt])}`; + if (t.frei < t.soll) return `${zahl(t.frei)} von ${zahl(t.soll)} Std.`; + return `${zahl(t.soll)} Std.`; +} + +export async function personalSeite(): Promise { + const liste = await api(`personal?heute=${heute()}`); + seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter }); + if (!liste.length) { + inhalt.insertAdjacentHTML("beforeend", '

Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.

'); + return; + } + inhalt.appendChild(tabelle([ + { titel: "Name", wert: (z) => `${esc(z.name)}${z.antraege ? ` ${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}` : ""}` }, + { titel: "Arbeitszeit", wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' (Vorgabe)'), klasse: "optional" }, + { titel: "Heute", wert: (z) => heuteText(z.heute) }, + { titel: "Resturlaub", wert: (z) => `${tageText(z.urlaub.rest)} von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}` }, + { titel: "Zugang", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : 'keiner'), klasse: "optional" }, + ], liste, (z) => { location.hash = `mitarbeiter-${z.id}`; })); +} + +async function neuerMitarbeiter(): Promise { + const r = await dialog("Neuer Mitarbeiter", [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }], {}, false); + if (r?.aktion !== "speichern") return; + const k = await api("kontakte", "POST", { ...r.daten, rolle: "mitarbeiter" }); + location.hash = `mitarbeiter-${k.id}`; +} + +export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise { + const jahr = Number(heute().slice(0, 4)); + const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10); + const [kontakt, liste, alleStamm, modelle, abw, konten, verf] = await Promise.all([ + api(`kontakte/${kontaktId}`), + api(`personal?heute=${heute()}`), + api("mitarbeiter"), + api("arbeitszeitmodelle"), + api("abwesenheiten"), + api("urlaubskonten"), + api(`verfuegbarkeit?von=${heute()}&bis=${bis}&kontakt_id=${kontaktId}`), + ]); + const ich = liste.find((x) => x.id === kontaktId); + const stamm = alleStamm.find((m) => m.kontakt_id === kontaktId) ?? null; + const eigeneModelle = modelle.filter((m) => m.kontakt_id === kontaktId).sort((a, b) => (a.gueltig_ab < b.gueltig_ab ? 1 : -1)); + const eigeneAbw = abw.filter((a) => a.kontakt_id === kontaktId && a.bis >= `${jahr - 1}-01-01`).sort((a, b) => (a.von < b.von ? 1 : -1)); + const konto = konten.find((k) => k.kontakt_id === kontaktId && k.jahr === jahr) ?? null; + const neuLaden = () => mitarbeiterSeite(kontaktId, inhaber); + + seite(kontakt.name); + inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '← Personal'); + const raster = document.createElement("div"); + raster.className = "personal-raster"; + const u = ich?.urlaub; + raster.innerHTML = ` +

Stammdaten

+
+
Personalnummer
${esc(stamm?.personalnummer ?? "–")}
+
Eintritt
${stamm?.eintritt ? dat(stamm.eintritt) : "–"}${stamm?.austritt ? ` bis ${dat(stamm.austritt)}` : ""}
+
Art
${stamm && !stamm.angestellt ? "Inhaber (keine Pausenregel, keine Lohnübergabe)" : "angestellt"}
+ ${inhaber ? `
Lohnkosten je Stunde
${stamm?.lohn_cent != null ? formatEuro(stamm.lohn_cent) : "–"}
` : ""} +
Zugang
${ich?.anmeldename ? esc(ich.anmeldename) : inhaber ? 'anlegen unter Benutzer' : "keiner"}
+
+

Urlaub ${jahr}

+ ${u ? `
+
Anspruch${zahl(u.anspruch)}
Übertrag${zahl(u.uebertrag)}
+
genommen${zahl(u.genommen)}
geplant${zahl(u.geplant)}
+ ${u.beantragt ? `
beantragt${zahl(u.beantragt)}
` : ""}
Rest${zahl(u.rest)}
` : ""} +
+

Arbeitszeitmodell

+

Stunden je Wochentag. Ein neues Modell gilt ab seinem Datum; was davor liegt, bleibt unverändert. Geplant wird nur Montag bis Donnerstag, der Freitag ist Reserve.

+
+

Verfügbar in den nächsten 4 Wochen

+

Abwesenheiten

`; + inhalt.appendChild(raster); + + // Modelle + const mZiel = raster.querySelector("#modelle")!; + if (eigeneModelle.length) { + mZiel.appendChild(tabelle([ + { titel: "Gültig ab", wert: (m) => dat(m.gueltig_ab) }, + ...WT.map((t, i) => ({ titel: t, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", klasse: "zahl" })), + { titel: "Woche", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, klasse: "zahl" }, + ], eigeneModelle, (m) => void modellDialog(m))); + } else mZiel.innerHTML = `

Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}

`; + + // Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8) + const tage: Zeile[] = verf[0]?.tage ?? []; + raster.querySelector("#streifen")!.innerHTML = `
${tage.map((t) => { + const a = t.abwesend[0]; + const klasse = t.soll === 0 ? "aus" : t.frei === 0 ? "weg" : t.frei < t.soll ? "teil" : "voll"; + const titel = `${WT[wtag(t.datum)]} ${dat(t.datum)}: ${t.feiertag ?? (a ? `${ABWESENHEIT_TEXT[a.art as AbwesenheitArt]}${a.status !== "genehmigt" ? ` (${a.status})` : ""}` : "")} ${zahl(t.frei)} von ${zahl(t.soll)} Std. frei`; + return `
${WT[wtag(t.datum)]}${dat(t.datum).slice(0, 5)} + ${klasse === "voll" || klasse === "teil" ? `${zahl(t.frei)} h` : klasse === "weg" ? esc((a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "").slice(0, 6)) : ""}${a && a.status === "beantragt" ? "?" : ""}
`; + }).join("")}
`; + + // Abwesenheiten + const aZiel = raster.querySelector("#abw")!; + if (eigeneAbw.length) aZiel.appendChild(tabelle([ + { titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) }, + { titel: "Zeitraum", wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) }, + { titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") }, + { titel: "Status", wert: (a) => `${esc(a.status)}` }, + { titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" }, + ], eigeneAbw, (a) => void abwDialog(a))); + else aZiel.innerHTML = '

Keine Abwesenheiten eingetragen.

'; + + // ---------- Dialoge ---------- + async function stammDialog(): Promise { + const felder: Feld[] = [ + { name: "personalnummer", titel: "Personalnummer (für das Steuerbüro)" }, + { name: "eintritt", titel: "Eintritt", art: "datum" }, + { name: "austritt", titel: "Austritt", art: "datum" }, + { name: "angestellt", titel: "Art", art: "auswahl", optionen: [["ja", "angestellt"], ["nein", "Inhaber (keine Pausenregel, keine Lohnübergabe)"]] }, + ...(inhaber ? [{ name: "lohn", titel: "Lohnkosten je Stunde (€)", art: "euro" as const, hilfe: "Nur für dich sichtbar; für die Nachkalkulation." }] : []), + { name: "urlaubstage", titel: "Urlaubsanspruch je Jahr (Tage)", art: "zahl" }, + ]; + const werte = { ...(stamm ?? { urlaubstage: 30 }), angestellt: stamm && !stamm.angestellt ? "nein" : "ja", lohn: stamm?.lohn_cent ?? null }; + const r = await dialog("Stammdaten", felder, werte, false); + if (r?.aktion !== "speichern") return; + const d = r.daten; + const daten: Zeile = { personalnummer: d.personalnummer, eintritt: d.eintritt, austritt: d.austritt, angestellt: d.angestellt !== "nein", urlaubstage: d.urlaubstage ?? 30 }; + if (inhaber) daten.lohn_cent = d.lohn; + if (stamm) await api(`mitarbeiter/${stamm.id}`, "PATCH", daten); + else await api("mitarbeiter", "POST", { ...daten, kontakt_id: kontaktId }); + neuLaden(); + } + + async function kontoDialog(): Promise { + const felder: Feld[] = [ + { name: "anspruch", titel: `Anspruch ${jahr} (leer = ${zahl(stamm ? Number(stamm.urlaubstage) : 30)} aus den Stammdaten)`, art: "zahl" }, + { name: "uebertrag", titel: `Resturlaub aus ${jahr - 1}`, art: "zahl" }, + ]; + const r = await dialog(`Urlaub ${jahr}`, felder, konto ?? {}, false); + if (r?.aktion !== "speichern") return; + const daten = { anspruch: r.daten.anspruch, uebertrag: r.daten.uebertrag ?? 0 }; + if (konto) await api(`urlaubskonten/${konto.id}`, "PATCH", daten); + else await api("urlaubskonten", "POST", { ...daten, kontakt_id: kontaktId, jahr }); + neuLaden(); + } + + async function modellDialog(m: Zeile | null): Promise { + const vorlage = m?.stunden ?? eigeneModelle[0]?.stunden ?? ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]; + const felder: Feld[] = [ + { name: "gueltig_ab", titel: "Gültig ab", art: "datum", pflicht: true }, + ...WT.map((t, i): Feld => ({ name: `t${i}`, titel: `${t} (Std.)`, art: "zahl" })), + ]; + const werte: Zeile = { gueltig_ab: m?.gueltig_ab ?? heute(), ...Object.fromEntries(vorlage.map((h: number, i: number) => [`t${i}`, zahl(h)])) }; + const r = await dialog(m ? "Arbeitszeitmodell" : "Neues Arbeitszeitmodell", felder, werte, !!m); + if (!r) return; + if (r.aktion === "loeschen") await api(`arbeitszeitmodelle/${m!.id}`, "DELETE"); + else { + const daten = { gueltig_ab: r.daten.gueltig_ab, stunden: WT.map((_, i) => r.daten[`t${i}`] ?? 0) }; + if (m) await api(`arbeitszeitmodelle/${m.id}`, "PATCH", daten); + else await api("arbeitszeitmodelle", "POST", { ...daten, kontakt_id: kontaktId }); + } + neuLaden(); + } + + async function abwDialog(a: Zeile | null): Promise { + const felder: Feld[] = [ + { name: "art", titel: "Art", art: "auswahl", optionen: ARTEN }, + { name: "von", titel: "Von", art: "datum", pflicht: true }, + { name: "bis", titel: "Bis (leer = nur ein Tag)", art: "datum" }, + { name: "umfang", titel: "Umfang", art: "auswahl", optionen: [["ganz", "ganztags"], ["halb", "halber Tag (nur ein Tag)"], ["stunden", "einige Stunden"]] }, + { name: "stunden", titel: "Stunden nicht verfügbar (bei „einige Stunden“)", art: "zahl", hilfe: "Beispiel „Do nur bis 12 Uhr“ bei 8 Std.: 4 eintragen." }, + { name: "status", titel: "Status", art: "auswahl", optionen: STATUS }, + { name: "notiz", titel: "Notiz" }, + ...(a?.status === "beantragt" || a?.antwort ? [{ name: "antwort", titel: "Antwort an den Mitarbeiter" }] : []), + ]; + const werte: Zeile = a ? { ...a, umfang: a.halbtag ? "halb" : a.stunden ? "stunden" : "ganz", stunden: zahl(a.stunden) } : { art: "urlaub", von: heute(), umfang: "ganz", status: "genehmigt" }; + const r = await dialog(a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "Neue Abwesenheit", felder, werte, !!a); + if (!r) return; + if (r.aktion === "loeschen") await api(`abwesenheiten/${a!.id}`, "DELETE"); + else { + const d = r.daten; + const daten: Zeile = { art: d.art, von: d.von, bis: d.bis || d.von, halbtag: d.umfang === "halb", stunden: d.umfang === "stunden" ? d.stunden : null, status: d.status, notiz: d.notiz }; + if ("antwort" in d) daten.antwort = d.antwort; + if (a) await api(`abwesenheiten/${a.id}`, "PATCH", daten); + else await api("abwesenheiten", "POST", { ...daten, kontakt_id: kontaktId }); + } + neuLaden(); + } + + raster.addEventListener("click", (ev) => { + const a = (ev.target as HTMLElement).dataset.a; + if (a === "stamm") void stammDialog(); + if (a === "konto") void kontoDialog(); + if (a === "modell") void modellDialog(null); + if (a === "abw") void abwDialog(null); + }); +} diff --git a/src/web/styles.css b/src/web/styles.css index fa95557..519d84d 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -455,3 +455,29 @@ body.abgemeldet #inhalt { display: grid; place-items: center; min-height: 100vh; #wer .konto { display: grid; place-items: center; width: 36px; height: 36px; border-radius: 50%; border: 0; background: var(--leiste-aktiv); color: #fff; font: inherit; font-weight: 600; cursor: pointer; } #wer select { width: auto; } } + +/* Personal: Stammdaten, Urlaub, Arbeitszeitmodell, Verfügbarkeit (M8: ganz frei grau schraffiert, teilweise halb gefüllt) */ +.personal-raster { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; } +.personal-raster .breit { grid-column: 1 / -1; } +.personal-raster > .karte { min-width: 0; } +#modelle, #abw { overflow-x: auto; } +.kopf .zurueck { margin-right: 12px; } +dl.werte { display: grid; grid-template-columns: auto 1fr; gap: 6px 16px; margin: 0; } +dl.werte dt { color: var(--leise); font-size: 13px; } +dl.werte dd { margin: 0; } +.urlaub-zahlen { display: flex; flex-wrap: wrap; gap: 10px; } +.urlaub-zahlen div { display: flex; flex-direction: column; padding: 8px 12px; border: 1px solid var(--linie); border-radius: 8px; min-width: 76px; } +.urlaub-zahlen small { color: var(--leise); font-size: 12px; } +.urlaub-zahlen b { font-size: 20px; } +.urlaub-zahlen .rest { background: var(--akzent-hell); border-color: transparent; } +.streifen { display: grid; grid-template-columns: repeat(auto-fill, minmax(44px, 1fr)); gap: 4px; } +.s-tag { position: relative; border: 1px solid var(--linie); border-radius: 6px; padding: 4px 2px; text-align: center; display: flex; flex-direction: column; font-size: 11px; color: var(--leise); min-height: 58px; } +.s-tag b { color: var(--text); font-size: 12px; margin-top: auto; } +.s-tag.montag { border-left: 2px solid var(--leise); } +.s-tag.voll { background: var(--fl); } +.s-tag.teil { background: linear-gradient(to top, var(--akzent-hell) 50%, var(--fl) 50%); } +.s-tag.weg, .s-tag.aus { background: repeating-linear-gradient(135deg, var(--bg) 0 4px, var(--linie) 4px 6px); } +.s-tag.aus b { visibility: hidden; } +.s-tag i { position: absolute; top: 2px; right: 4px; font-style: normal; color: var(--warn); font-weight: 700; } +td.zahl, th.zahl { text-align: right; } +@media (max-width: 800px) { .personal-raster { grid-template-columns: 1fr; } } diff --git a/test/api.test.ts b/test/api.test.ts index 4079664..cb5e1be 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -540,6 +540,38 @@ describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(401); }); + it("Personal: Modell, Abwesenheit, Urlaubskonto; den Stundenlohn sieht nur der Inhaber (M1, M8, M4, U2)", async () => { + const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; + const m = await als(inhaber, "POST", "/api/mitarbeiter", { kontakt_id: jan, personalnummer: "17", lohn_cent: 2850, urlaubstage: 28 }); + expect(m.statusCode, m.body).toBe(201); + expect(m.json().lohn_cent).toBe(2850); + const mod = await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-01-01", stunden: [8, 8, 8, 8, 6.5, 0, 0] }); + expect(mod.statusCode, mod.body).toBe(201); + expect(mod.json().stunden).toEqual([8, 8, 8, 8, 6.5, 0, 0]); + expect((await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-02-01", stunden: [8, 8] })).statusCode).toBe(400); + expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-02", bis: "2026-11-06" })).statusCode).toBe(201); + expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-09", bis: "2026-11-08" })).statusCode).toBe(400); + expect((await als(inhaber, "POST", "/api/urlaubskonten", { kontakt_id: jan, jahr: 2026, uebertrag: 3 })).statusCode).toBe(201); + + const b = await anmelden("buero", "buero12345"); + const liste = (await als(b, "GET", "/api/personal?heute=2026-11-03")).json(); + const j = liste.find((x: { id: string }) => x.id === jan); + expect(j).toMatchObject({ stunden: [8, 8, 8, 8, 6.5, 0, 0], eigenesModell: true, heute: { soll: 8, frei: 0 } }); + expect(j.urlaub).toMatchObject({ anspruch: 28, uebertrag: 3, genommen: 2, geplant: 3, rest: 26 }); + expect(j.stammdaten.lohn_cent).toBeUndefined(); + expect((await als(b, "GET", "/api/mitarbeiter")).json()[0]).not.toHaveProperty("lohn_cent"); + expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { lohn_cent: 9999 })).statusCode).toBe(403); + expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { personalnummer: "18" })).json()).not.toHaveProperty("lohn_cent"); + const v = (await als(b, "GET", `/api/verfuegbarkeit?von=2026-11-06&bis=2026-11-09&kontakt_id=${jan}`)).json(); + expect(v[0].tage.map((t: { frei: number }) => t.frei)).toEqual([0, 0, 0, 8]); + // Mitarbeiter selbst kommen an die Personalliste nicht heran (Jan wurde oben gesperrt) + const janB = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; + expect((await als(inhaber, "PATCH", `/api/benutzer/${janB}`, { aktiv: true })).statusCode).toBe(200); + const jj = await anmelden("jan", "neuespasswort"); + expect((await als(jj, "GET", "/api/personal")).statusCode).toBe(403); + expect((await als(jj, "GET", "/api/mitarbeiter")).statusCode).toBe(403); + }); + it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => { const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; diff --git a/test/personal.test.ts b/test/personal.test.ts new file mode 100644 index 0000000..9527224 --- /dev/null +++ b/test/personal.test.ts @@ -0,0 +1,70 @@ +import { describe, it, expect } from "vitest"; +import { type Abwesenheit, type Modell, modellAm, modellText, sollStunden, urlaubskonto, urlaubstage, verfuegbarkeit } from "../src/domain/personal.js"; + +const K = "k1"; +const modelle: Modell[] = [ + { kontakt_id: K, gueltig_ab: "2026-01-01", stunden: [8, 8, 8, 8, 6, 0, 0] }, + // ab November Teilzeit: Mittwoch frei, Donnerstag 4 Stunden (Beispiel aus M8) + { kontakt_id: K, gueltig_ab: "2026-11-01", stunden: [8, 8, 0, 4, 0, 0, 0] }, +]; +const ab = (x: Partial): Abwesenheit => ({ kontakt_id: K, art: "urlaub", von: "2026-10-26", bis: "2026-10-26", status: "genehmigt", ...x }); + +describe("Arbeitszeitmodell (M8)", () => { + it("gilt ab seinem Datum, frühere Tage behalten das alte Modell", () => { + expect(modellAm(modelle, K, "2026-10-31")!.gueltig_ab).toBe("2026-01-01"); + expect(modellAm(modelle, K, "2026-11-01")!.gueltig_ab).toBe("2026-11-01"); + expect(sollStunden(modelle, K, "2026-10-28")).toBe(8); // Mi vorher + expect(sollStunden(modelle, K, "2026-11-04")).toBe(0); // Mi nachher frei + expect(sollStunden(modelle, K, "2026-11-05")).toBe(4); // Do 4 h + }); + it("ohne Modell Mo–Fr nach Einstellung, Feiertage 0", () => { + expect(sollStunden([], "x", "2026-10-30")).toBe(8); // Freitag + expect(sollStunden([], "x", "2026-10-31")).toBe(0); // Reformationstag (SH) und Samstag + expect(sollStunden(modelle, K, "2026-12-25")).toBe(0); + expect(sollStunden([], "x", "2026-10-27", 7.5)).toBe(7.5); + }); + it("Text", () => { + expect(modellText([8, 8, 0, 4, 0, 0, 0])).toBe("Mo 8 · Di 8 · Do 4 = 20 Std."); + expect(modellText([8.5, 8.5, 8.5, 8.5, 6, 0, 0])).toBe("Mo 8,5 · Di 8,5 · Mi 8,5 · Do 8,5 · Fr 6 = 40 Std."); + }); +}); + +describe("Verfügbarkeit (M4, M8)", () => { + it("Urlaub, halber Tag, stundengenaue Sperre; beantragter Urlaub sperrt noch nicht", () => { + const abw: Abwesenheit[] = [ + ab({ von: "2026-10-19", bis: "2026-10-20" }), + ab({ von: "2026-10-21", bis: "2026-10-21", halbtag: true }), + ab({ art: "sperre", von: "2026-10-22", bis: "2026-10-22", stunden: 4 }), + ab({ von: "2026-10-23", bis: "2026-10-23", status: "beantragt" }), + ab({ art: "krank", von: "2026-10-26", bis: "2026-10-26", status: "abgelehnt" }), + ]; + const t = verfuegbarkeit(modelle, abw, K, "2026-10-19", "2026-10-26"); + expect(t.map((x) => x.frei)).toEqual([0, 0, 4, 4, 6, 0, 0, 8]); + expect(t[4]!.abwesend.map((a) => a.status)).toEqual(["beantragt"]); + expect(t[7]!.abwesend).toEqual([]); + }); + it("Sperre mit mehr Stunden als Soll nimmt höchstens das Soll", () => { + const t = verfuegbarkeit(modelle, [ab({ art: "sperre", von: "2026-11-05", bis: "2026-11-05", stunden: 6 })], K, "2026-11-05", "2026-11-05"); + expect(t[0]!.frei).toBe(0); + }); +}); + +describe("Urlaubskonto (M10)", () => { + it("zählt nur Tage mit Soll, Feiertage nicht, halbe Tage halb", () => { + // 23.12.–2.1. im Teilzeitmodell (Mi frei): Do 24., Mo 28., Di 29., Do 31.; 25.12. und 1.1. Feiertag + const a = ab({ von: "2026-12-23", bis: "2027-01-02" }); + expect(urlaubstage(a, modelle, 2026)).toBe(4); + expect(urlaubstage(a, modelle, 2027)).toBe(0); + expect(urlaubstage(ab({ von: "2026-10-27", bis: "2026-10-27", halbtag: true }), modelle, 2026)).toBe(0.5); + }); + it("genommen, geplant, beantragt, Rest", () => { + const abw = [ + ab({ von: "2026-03-02", bis: "2026-03-06" }), // 5 Tage (Mo–Fr, altes Modell) + ab({ von: "2026-10-30", bis: "2026-10-30", halbtag: true }), // Fr, halber Tag + ab({ von: "2026-11-09", bis: "2026-11-13" }), // neues Modell: Mo, Di, Do → 3 Tage, geplant + ab({ von: "2026-11-16", bis: "2026-11-17", status: "beantragt" }), // 2 + ]; + const k = urlaubskonto(K, 2026, "2026-10-30", 30, 2.5, abw, modelle); + expect(k).toEqual({ jahr: 2026, anspruch: 30, uebertrag: 2.5, genommen: 5.5, geplant: 3, beantragt: 2, rest: 24 }); + }); +});