Personal: Stammdaten, Arbeitszeitmodell, Abwesenheiten, Urlaubskonto (0.8.0)
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:
127
src/domain/personal.ts
Normal file
127
src/domain/personal.ts
Normal 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.`;
|
||||
}
|
||||
@@ -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) => {
|
||||
|
||||
71
src/server/migrations/008_personal.sql
Normal file
71
src/server/migrations/008_personal.sql
Normal 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
79
src/server/personal.ts
Normal 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) }));
|
||||
});
|
||||
}
|
||||
@@ -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(),
|
||||
}),
|
||||
},
|
||||
];
|
||||
|
||||
@@ -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
210
src/web/personal.ts
Normal 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);
|
||||
});
|
||||
}
|
||||
@@ -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; } }
|
||||
|
||||
Reference in New Issue
Block a user