// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026). Nur der Inhaber sieht Löhne und Sätze (U2); // die Namen der Lohnarten (/api/lohnarten) braucht auch das Büro für Personal und Kalkulation. import type { FastifyInstance, FastifyRequest } from "fastify"; import { z } from "zod"; import { type Client, type Pool, transaktion } from "./db.js"; import { werName } from "./anmeldung.js"; import { type Block, KOSTENARTEN_S, MITTELLOHN, type StundensatzDaten, type Umfeld, laufendImJahr, rechneStundensaetze, saetzeFuerAngebot } from "../domain/stundensatz.js"; import { stundensaetzeAusExcel, stundensaetzeNachS2 } from "../domain/stundensatz-excel.js"; import type { Cent } from "../domain/geld.js"; const schluessel = z.string().regex(/^[a-z0-9-]{1,40}$/).refine((s) => s !== MITTELLOHN, "„mittellohn“ ist vergeben"); const kurz = z.string().trim().max(120); const zahl = z.number().min(0).max(1e7); const cent = z.number().int().min(0).max(10_000_000_000); const kleineId = z.string().min(1).max(40); export const DatenSchema = z.object({ tabellen: z.array(z.object({ id: schluessel, name: kurz.min(1), hinweis: z.string().max(500).optional(), zeit: z.object({ stundenTag: z.number().min(0).max(24), tageJahr: z.number().min(0).max(366), feiertage: z.number().min(0).max(366), ausfall: z.array(z.object({ id: kleineId, name: kurz, tage: z.number().min(0).max(366) })).max(30), unproduktiv: z.array(z.object({ id: kleineId, name: kurz, stunden: z.number().min(0).max(744), je: z.enum(["monat", "tag"]), als: z.enum(["zeit", "kosten"]) })).max(30), }), kosten: z.array(z.object({ id: kleineId, block: z.number().int().min(1).max(5).transform((b) => b as Block), name: kurz, art: z.enum(KOSTENARTEN_S), betrag: cent.optional(), faktor: z.number().min(0.01).max(10).optional(), prozent: z.number().min(0).max(1000).optional(), stunden: z.number().min(0).max(744).optional(), laufend: z.array(z.uuid()).max(200).optional(), koepfe: z.boolean().optional(), anteil: z.number().min(0).max(1000).optional(), notiz: z.string().max(300).optional(), })).max(100), gewinn: z.number().min(0).max(100), lohnanteil: z.number().min(1).max(100), wagnis: z.number().min(0).max(50), })).min(1).max(30).refine((t) => new Set(t.map((x) => x.id)).size === t.length, "Jede Tabelle braucht einen eigenen Schlüssel"), koepfe: zahl.min(1).max(500).nullable(), bewertung: z.string().max(40), mittellohn: z.record(z.string().max(40), z.object({ an: z.boolean(), personen: z.number().min(0).max(500).nullable() })), }); const Datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/); const IdParam = z.object({ id: z.uuid() }); type Abfrage = Pick; /** Köpfe und Personen je Lohnart aus dem Personal (heute beschäftigt): der Inhaber ohne Rolle zählt als Chef, * Angestellte ohne Rolle als Geselle. Laufende Kosten als Jahressumme im angegebenen Jahr. */ export async function umfeldLaden(c: Abfrage, jahr: number, heute: string): Promise { const leute = (await c.query(`select coalesce(funktion, case when angestellt then 'geselle' else 'chef' end) as lohnart, count(*)::int as n from mitarbeiter where (eintritt is null or eintritt <= $1) and (austritt is null or austritt >= $1) group by 1`, [heute])).rows; const personen = Object.fromEntries(leute.map((r) => [r.lohnart as string, r.n as number])); const lk = (await c.query("select id, bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten order by kategorie nulls last, bezeichnung")).rows; const liste = lk.map((l) => ({ id: l.id as string, bezeichnung: l.bezeichnung as string, kategorie: (l.kategorie ?? null) as string | null, jahr: laufendImJahr({ ...l, betrag: Number(l.betrag) }, jahr) })); return { koepfe: Math.max(1, leute.reduce((s, r) => s + (r.n as number), 0)), personen, laufend: Object.fromEntries(liste.map((l) => [l.id, l.jahr])), liste }; } /** Version, die an diesem Tag gilt */ async function geltende(c: Abfrage, datum: string) { return (await c.query("select id, name, gilt_ab, daten from stundensatz_version where gilt_ab <= $1 order by gilt_ab desc limit 1", [datum])).rows[0] as { id: string; name: string; gilt_ab: string; daten: StundensatzDaten } | undefined; } export interface AngebotsSaetze { stundensaetze: Record; lohnarten: { id: string; name: string }[]; stundensatz_version: { id: string; name: string; gilt_ab: string } } /** Sätze für ein neues Angebot (A36) aus der Version, die am Datum gilt; ohne Version null (dann die Einstellungen) */ export async function aktuelleSaetze(c: Abfrage, datum: string): Promise { const v = await geltende(c, datum); if (!v) return null; const u = await umfeldLaden(c, Number(v.gilt_ab.slice(0, 4)), datum); return { ...saetzeFuerAngebot(rechneStundensaetze(v.daten, u)), stundensatz_version: { id: v.id, name: v.name, gilt_ab: v.gilt_ab } }; } export function registriereStundensaetze(app: FastifyInstance, pool: Pool): void { const wer = (req: FastifyRequest) => werName(req); const heute = () => new Date().toISOString().slice(0, 10); const zeile = (r: Record) => ({ id: r.id, name: r.name, gilt_ab: r.gilt_ab, daten: r.daten as StundensatzDaten, geaendert_am: r.geaendert_am }); app.get("/api/stundensaetze", async () => { const versionen = (await pool.query("select * from stundensatz_version order by gilt_ab")).rows.map(zeile); const gilt = await geltende(pool, heute()); const jahre = [...new Set(versionen.map((v) => Number(v.gilt_ab.slice(0, 4))).concat(Number(heute().slice(0, 4))))]; const umfeld: Record>> = {}; for (const j of jahre) umfeld[j] = await umfeldLaden(pool, j, heute()); const personal = (await pool.query(`select k.name, m.funktion, m.angestellt from mitarbeiter m join kontakt k on k.id = m.kontakt_id where (m.eintritt is null or m.eintritt <= $1) and (m.austritt is null or m.austritt >= $1) order by k.name`, [heute()])).rows; return { versionen, gilt: gilt?.id ?? null, umfeld, personal, heute: heute() }; }); // Lohnarten für Rolle im Personal und Auswahl in der Kalkulation: Tabellen der heute geltenden Version app.get("/api/lohnarten", async () => { const v = await geltende(pool, heute()); const tabellen = v?.daten.tabellen.map((t) => ({ id: t.id, name: t.name })) ?? []; return tabellen.length ? tabellen : [{ id: "planer", name: "Planer" }, { id: "geselle", name: "Geselle" }, { id: "helfer", name: "Helfer" }]; }); const Neu = z.object({ name: kurz.min(1), gilt_ab: Datum, daten: DatenSchema }); app.post("/api/stundensaetze", async (req, reply) => { const q = Neu.parse(req.body); const r = await transaktion(pool, wer(req), async (c) => { if ((await c.query("select 1 from stundensatz_version where gilt_ab = $1", [q.gilt_ab])).rowCount) return null; return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *", [q.name, q.gilt_ab, q.daten])).rows[0]; }); if (!r) return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." }); return reply.status(201).send(zeile(r)); }); // M19: erste Fassung aus Hennings Excel (gilt ab 26.05.2026) und die Fassung nach S2 (gilt ab heute) app.post("/api/stundensaetze/excel", async (req, reply) => { const r = await transaktion(pool, wer(req), async (c) => { if ((await c.query("select 1 from stundensatz_version limit 1")).rowCount) return null; const excel = stundensaetzeAusExcel(); await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3)", ["Excel 26.05.2026", "2026-05-26", excel]); const ab = heute() > "2026-05-26" ? heute() : "2026-05-27"; return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *", ["Akquise und Verwaltung als Kosten", ab, stundensaetzeNachS2(excel)])).rows[0]; }); if (!r) return reply.status(409).send({ fehler: "Es gibt schon Stundensätze." }); return reply.status(201).send(zeile(r)); }); const Aenderung = z.object({ name: kurz.min(1).optional(), gilt_ab: Datum.optional(), daten: DatenSchema.optional() }); app.patch("/api/stundensaetze/:id", async (req, reply) => { const { id } = IdParam.parse(req.params); const q = Aenderung.parse(req.body); const r = await transaktion(pool, wer(req), async (c) => { if (q.gilt_ab && (await c.query("select 1 from stundensatz_version where gilt_ab = $1 and id <> $2", [q.gilt_ab, id])).rowCount) return "doppelt" as const; return (await c.query(`update stundensatz_version set name = coalesce($2, name), gilt_ab = coalesce($3, gilt_ab), daten = coalesce($4, daten) where id = $1 returning *`, [id, q.name ?? null, q.gilt_ab ?? null, q.daten ?? null])).rows[0]; }); if (r === "doppelt") return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." }); if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); return zeile(r); }); app.delete("/api/stundensaetze/:id", async (req, reply) => { const { id } = IdParam.parse(req.params); const r = await transaktion(pool, wer(req), (c) => c.query("delete from stundensatz_version where id = $1", [id])); if (!r.rowCount) return reply.status(404).send({ fehler: "Nicht gefunden" }); return reply.status(204).send(); }); }