Personal: Stammdaten, Arbeitszeitmodell, Abwesenheiten, Urlaubskonto (0.8.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Stufe 2, Schritt 2 (M1, M8, M4, M10-Konto). Modelle mit Gültig-ab, Abwesenheiten
ganztags, halbtags oder stundengenau, Verfügbarkeit je Tag als Grundlage für
T15/T16. Lohnkosten je Stunde nur für den Inhaber (nurInhaber in TABELLEN).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-20 06:33:33 +00:00
parent bc5e15339a
commit 859a076e83
13 changed files with 709 additions and 9 deletions

View File

@@ -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“.

View File

@@ -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) {

View File

@@ -1,6 +1,6 @@
{
"name": "betrieb",
"version": "0.7.0",
"version": "0.8.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",

127
src/domain/personal.ts Normal file
View File

@@ -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<AbwesenheitArt, string> = {
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.`;
}

View File

@@ -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<FastifyInstance> {
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<FastifyInstance> {
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<string, unknown> | undefined) => {
if (!z) return z;
const aus: Record<string, unknown> = { ...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<string, unknown>) =>
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<string, unknown>;
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<FastifyInstance> {
)).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<string, unknown>;
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<FastifyInstance> {
)).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) => {

View File

@@ -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();

79
src/server/personal.ts Normal file
View File

@@ -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<string, Record<string, any>>;
konten: Map<string, Record<string, any>>;
}
/** Modelle, Abwesenheiten, Stammdaten und Urlaubskonten; optional nur für einen Kontakt */
export async function ladePersonal(pool: Pick<Pool, "query">, kontaktId?: string): Promise<Personalstand> {
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<Einstellungen>): 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) }));
});
}

View File

@@ -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(),
}),
},
];

View File

@@ -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<string, string> = {
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
personal: '<circle cx="12" cy="7" r="3.5"/><path d="M5 21v-2a5 5 0 0 1 5-5h4a5 5 0 0 1 5 5v2"/><path d="M9 14l3 4 3-4"/>',
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
};
@@ -801,6 +803,7 @@ const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="cur
const nav = document.getElementById("reiter")!;
let REITER: Reiter[] = [];
let sitzung: Sitzung | undefined;
nav.addEventListener("click", (ev) => {
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<void> {
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte; Mitarbeiter: #ablage-<id>
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", `<p class="fehler">${esc((e as Error).message)}</p>`);
}
@@ -834,6 +840,7 @@ async function start(): Promise<void> {
s = await api<Sitzung>("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);

210
src/web/personal.ts Normal file
View File

@@ -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 `<span class="marke grau">${esc(t.feiertag)}</span>`;
if (t.soll === 0) return '<span class="marke grau">frei</span>';
if (a && t.frei === 0) return `<span class="marke offen">${esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt])}</span>`;
if (t.frei < t.soll) return `${zahl(t.frei)} von ${zahl(t.soll)} Std.`;
return `${zahl(t.soll)} Std.`;
}
export async function personalSeite(): Promise<void> {
const liste = await api<Zeile[]>(`personal?heute=${heute()}`);
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
if (!liste.length) {
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.</p>');
return;
}
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => `${esc(z.name)}${z.antraege ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
{ titel: "Arbeitszeit", wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), klasse: "optional" },
{ titel: "Heute", wert: (z) => heuteText(z.heute) },
{ titel: "Resturlaub", wert: (z) => `${tageText(z.urlaub.rest)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
{ titel: "Zugang", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), klasse: "optional" },
], liste, (z) => { location.hash = `mitarbeiter-${z.id}`; }));
}
async function neuerMitarbeiter(): Promise<void> {
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<Zeile>("kontakte", "POST", { ...r.daten, rolle: "mitarbeiter" });
location.hash = `mitarbeiter-${k.id}`;
}
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
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<Zeile>(`kontakte/${kontaktId}`),
api<Zeile[]>(`personal?heute=${heute()}`),
api<Zeile[]>("mitarbeiter"),
api<Zeile[]>("arbeitszeitmodelle"),
api<Zeile[]>("abwesenheiten"),
api<Zeile[]>("urlaubskonten"),
api<Zeile[]>(`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", '<a class="neben zurueck" href="#personal">← Personal</a>');
const raster = document.createElement("div");
raster.className = "personal-raster";
const u = ich?.urlaub;
raster.innerHTML = `
<section class="karte"><div class="karte-kopf"><h2>Stammdaten</h2><button class="neben" data-a="stamm">Bearbeiten</button></div>
<dl class="werte">
<dt>Personalnummer</dt><dd>${esc(stamm?.personalnummer ?? "–")}</dd>
<dt>Eintritt</dt><dd>${stamm?.eintritt ? dat(stamm.eintritt) : "–"}${stamm?.austritt ? ` bis ${dat(stamm.austritt)}` : ""}</dd>
<dt>Art</dt><dd>${stamm && !stamm.angestellt ? "Inhaber (keine Pausenregel, keine Lohnübergabe)" : "angestellt"}</dd>
${inhaber ? `<dt>Lohnkosten je Stunde</dt><dd>${stamm?.lohn_cent != null ? formatEuro(stamm.lohn_cent) : "–"}</dd>` : ""}
<dt>Zugang</dt><dd>${ich?.anmeldename ? esc(ich.anmeldename) : inhaber ? '<a href="#benutzer">anlegen unter Benutzer</a>' : "keiner"}</dd>
</dl></section>
<section class="karte"><div class="karte-kopf"><h2>Urlaub ${jahr}</h2><button class="neben" data-a="konto">Anspruch und Übertrag</button></div>
${u ? `<div class="urlaub-zahlen">
<div><small>Anspruch</small><b>${zahl(u.anspruch)}</b></div><div><small>Übertrag</small><b>${zahl(u.uebertrag)}</b></div>
<div><small>genommen</small><b>${zahl(u.genommen)}</b></div><div><small>geplant</small><b>${zahl(u.geplant)}</b></div>
${u.beantragt ? `<div><small>beantragt</small><b>${zahl(u.beantragt)}</b></div>` : ""}<div class="rest"><small>Rest</small><b>${zahl(u.rest)}</b></div></div>` : ""}
</section>
<section class="karte breit"><div class="karte-kopf"><h2>Arbeitszeitmodell</h2><button class="neben" data-a="modell">+ Neues Modell</button></div>
<p class="hinweis">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.</p>
<div id="modelle"></div></section>
<section class="karte breit"><div class="karte-kopf"><h2>Verfügbar in den nächsten 4 Wochen</h2></div><div id="streifen"></div></section>
<section class="karte breit"><div class="karte-kopf"><h2>Abwesenheiten</h2><button class="neben" data-a="abw">+ Abwesenheit</button></div><div id="abw"></div></section>`;
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 = `<p class="hinweis">Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}</p>`;
// Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8)
const tage: Zeile[] = verf[0]?.tage ?? [];
raster.querySelector("#streifen")!.innerHTML = `<div class="streifen">${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 `<div class="s-tag ${klasse}${wtag(t.datum) === 0 ? " montag" : ""}" title="${esc(titel)}"><small>${WT[wtag(t.datum)]}</small><span>${dat(t.datum).slice(0, 5)}</span>
<b>${klasse === "voll" || klasse === "teil" ? `${zahl(t.frei)} h` : klasse === "weg" ? esc((a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "").slice(0, 6)) : ""}</b>${a && a.status === "beantragt" ? "<i>?</i>" : ""}</div>`;
}).join("")}</div>`;
// 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) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${esc(a.status)}</span>` },
{ titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" },
], eigeneAbw, (a) => void abwDialog(a)));
else aZiel.innerHTML = '<p class="hinweis">Keine Abwesenheiten eingetragen.</p>';
// ---------- Dialoge ----------
async function stammDialog(): Promise<void> {
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<void> {
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<void> {
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<void> {
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);
});
}

View File

@@ -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; } }

View File

@@ -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;

70
test/personal.test.ts Normal file
View File

@@ -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>): 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 });
});
});