// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026, angebote/stundensaetze/stundensatz-konzept.md): // je Lohnart eine Rechentabelle wie Hennings Excel-Blatt. 1 Zeit: Arbeitstage × Std/Tag − Feiertage − Ausfall // − unproduktive Zeiten = produktive Stunden. 2 Kosten in fünf Blöcken (Lohn, AG-Anteile, indirekte Personalkosten, // Sachkosten, Verwaltung) plus kalkulatorischer Gewinn. 3 Stundensatz = Kosten je Jahr ÷ produktive Stunden (Vollkosten). // Unproduktive Zeiten können statt als Zeitabzug als Kosten zählen (S2): Stunden × Lohnkostensatz der Bewertungs- // Tabelle (Blöcke 1–3 ÷ produktive Stunden, ohne Gemeinkosten, damit keine Zirkelrechnung entsteht). // Gerechnet wird ohne Zwischenrundung wie in Excel; gerundet wird nur der Satz auf den Cent. import type { Cent } from "./geld.js"; export const BLOECKE = [1, 2, 3, 4, 5] as const; export type Block = (typeof BLOECKE)[number]; export const BLOCK_NAME: Record = { 1: "Lohn (direkter Personalaufwand)", 2: "AG-Anteile, BG, SoKa", 3: "indirekter Personalaufwand", 4: "Sachkosten (Organisationsaufwand)", 5: "zentrale Verwaltung", }; /** monat/jahr: fester Betrag; netto: Monatslohn netto ÷ Faktor = brutto; prozent: Anteil der Lohnsumme (Block 1); * stunden: Std je Monat × € je Std; laufend: Summe gewählter laufender Kosten im Jahr */ export const KOSTENARTEN_S = ["netto", "monat", "jahr", "prozent", "stunden", "laufend"] as const; export type KostenArtS = (typeof KOSTENARTEN_S)[number]; export const KOSTENART_S_NAME: Record = { netto: "netto je Monat", monat: "je Monat", jahr: "je Jahr", prozent: "% vom Lohn", stunden: "Std/Monat × €", laufend: "aus laufenden Kosten", }; export interface Kostenzeile { id: string; block: Block; name: string; art: KostenArtS; /** Cent: je Monat (netto, monat), je Jahr (jahr), je Stunde (stunden) */ betrag?: Cent; /** netto: Anteil, der netto bleibt (0,7) */ faktor?: number; /** prozent: Prozent der Lohnsumme */ prozent?: number; /** stunden: Std je Monat */ stunden?: number; /** laufend: ids der laufenden Kosten */ laufend?: string[]; /** Betrag auf die Köpfe des Betriebs verteilen */ koepfe?: boolean; /** Anteil in %, Vorgabe 100 */ anteil?: number; notiz?: string; } export interface Ausfall { id: string; name: string; tage: number } export interface Unproduktiv { id: string; name: string; stunden: number; je: "monat" | "tag"; als: "zeit" | "kosten" } export interface Rechentabelle { /** fester Schlüssel, zugleich die Lohnart im Angebot (chef, planer, geselle, helfer, …) */ id: string; name: string; hinweis?: string; zeit: { stundenTag: number; tageJahr: number; feiertage: number; ausfall: Ausfall[]; unproduktiv: Unproduktiv[] }; kosten: Kostenzeile[]; /** kalkulatorischer Gewinn in % der Kosten */ gewinn: number; /** Umsatzbedarf: Lohnanteil am Umsatz in % und Wagnis darin */ lohnanteil: number; wagnis: number; } export interface StundensatzDaten { tabellen: Rechentabelle[]; /** Köpfe, auf die Sachkosten verteilt werden; leer = aus dem Personal gezählt */ koepfe: number | null; /** Tabelle, mit deren Lohnkostensatz unproduktive Zeiten als Kosten bewertet werden (S2) */ bewertung: string; /** je Tabelle: im Mittellohn an/aus und Personen (leer = aus dem Personal gezählt) */ mittellohn: Record; } /** Was das Programm selbst weiß: Köpfe und Personen je Lohnart aus dem Personal, laufende Kosten im Jahr */ export interface Umfeld { koepfe: number; personen: Record; laufend: Record; } export interface ZeileErgebnis { id: string; block: Block; name: string; jahr: number; monat: number; jeStd: number; /** Anteil an den Gesamtkosten in % */ anteil: number; rechnung: string; /** aus einer unproduktiven Zeit „als Kosten“ */ ausZeit?: boolean; } export interface TabellenErgebnis { id: string; name: string; zeit: { bruttoStd: number; feiertageStd: number; jahresStd: number; jahresTage: number; ausfall: { id: string; std: number; tage: number }[]; ausfallStd: number; ausfallTage: number; anwesenheitTage: number; unproduktiv: { id: string; std: number; tage: number; als: "zeit" | "kosten" }[]; produktiv: number; produktivTage: number; }; zeilen: ZeileErgebnis[]; /** je Block die Summe und die Zwischensumme bis einschließlich dieses Blocks (wie im Excel-Blatt) */ bloecke: { block: Block; jahr: number; bis: number; bisJeStd: number }[]; /** Blöcke 1–3: Lohnkosten ohne Gemeinkosten */ lohnkosten: number; lohnkostensatz: Cent; gewinn: number; summe: number; /** Vollkosten-Stundensatz, auf den Cent gerundet */ satz: Cent; satzGenau: number; gemeinkostenanteil: Cent; umsatzbedarf: number; } export interface MittellohnErgebnis { zeilen: { id: string; name: string; an: boolean; personen: number; gezaehlt: number; std: number; satz: Cent; lohnkostensatz: Cent }[]; personen: number; std: number; satz: Cent | null; lohnkostensatz: Cent | null; } export interface StundensatzErgebnis { tabellen: TabellenErgebnis[]; koepfe: number; bewertungssatz: Cent; mittellohn: MittellohnErgebnis; umsatzbedarf: { jahr: number; monat: number; lohn: number; material: number }; } const zahl = (n: number) => n.toLocaleString("de-DE", { maximumFractionDigits: 2 }); const eur = (c: number) => `${(c / 100).toLocaleString("de-DE", { minimumFractionDigits: 2, maximumFractionDigits: 2 })} €`; export function zeitRechnen(t: Rechentabelle): TabellenErgebnis["zeit"] { const z = t.zeit, h = z.stundenTag; const bruttoStd = z.tageJahr * h, feiertageStd = z.feiertage * h; const ausfall = z.ausfall.map((a) => ({ id: a.id, std: a.tage * h, tage: a.tage })); const ausfallStd = ausfall.reduce((s, a) => s + a.std, 0), ausfallTage = ausfall.reduce((s, a) => s + a.tage, 0); const anwesenheitTage = z.tageJahr - z.feiertage - ausfallTage; const unproduktiv = z.unproduktiv.map((u) => { const std = u.stunden * (u.je === "monat" ? 12 : anwesenheitTage); return { id: u.id, std, tage: h ? Math.ceil(std / h) : 0, als: u.als }; }); const produktiv = bruttoStd - feiertageStd - ausfallStd - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.std, 0); return { bruttoStd, feiertageStd, jahresStd: bruttoStd - feiertageStd, jahresTage: z.tageJahr - z.feiertage, ausfall, ausfallStd, ausfallTage, anwesenheitTage, unproduktiv, produktiv, produktivTage: z.tageJahr - z.feiertage - ausfallTage - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.tage, 0), }; } /** Kosten einer Zeile im Jahr (Cent, ungerundet) und wie sie entstehen */ function zeileRechnen(k: Kostenzeile, lohnsumme: number, u: Umfeld): { jahr: number; rechnung: string } { const anteil = (k.anteil ?? 100) / 100; const teiler = k.koepfe ? Math.max(1, u.koepfe) : 1; const nach = (x: number) => (x * anteil) / teiler; const zusatz = `${anteil !== 1 ? ` × ${zahl(anteil * 100)} %` : ""}${teiler !== 1 ? ` ÷ ${zahl(teiler)} Köpfe` : ""}`; const b = k.betrag ?? 0; switch (k.art) { case "netto": { const f = k.faktor && k.faktor > 0 ? k.faktor : 1; return { jahr: nach((b / f) * 12), rechnung: `${eur(b)} netto ÷ ${zahl(f)} = ${eur(b / f)} brutto × 12${zusatz}` }; } case "monat": return { jahr: nach(b * 12), rechnung: `${eur(b)} × 12${zusatz}` }; case "jahr": return { jahr: nach(b), rechnung: `${eur(b)} im Jahr${zusatz}` }; case "prozent": return { jahr: nach((lohnsumme * (k.prozent ?? 0)) / 100), rechnung: `${zahl(k.prozent ?? 0)} % von ${eur(lohnsumme)}${zusatz}` }; case "stunden": return { jahr: nach((k.stunden ?? 0) * b * 12), rechnung: `${zahl(k.stunden ?? 0)} Std × ${eur(b)} × 12${zusatz}` }; case "laufend": { const s = (k.laufend ?? []).reduce((x, id) => x + (u.laufend[id] ?? 0), 0); return { jahr: nach(s), rechnung: `${(k.laufend ?? []).length} laufende Kosten, ${eur(s)} im Jahr${zusatz}` }; } } } function tabelleRechnen(t: Rechentabelle, u: Umfeld, bewertung: (eigen: Cent) => Cent): TabellenErgebnis { const zeit = zeitRechnen(t); const prod = zeit.produktiv > 0 ? zeit.produktiv : NaN; const roh: Omit[] = []; let lohnsumme = 0; for (const block of BLOECKE) { if (block === 4) { // Lohnkostensatz steht nach Block 3 fest; unproduktive Zeiten „als Kosten“ kommen in die Sachkosten const lohnkosten = roh.reduce((s, z) => s + z.jahr, 0); const satz = bewertung(Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0); for (const p of t.zeit.unproduktiv) { if (p.als !== "kosten") continue; const std = zeit.unproduktiv.find((x) => x.id === p.id)!.std; roh.push({ id: `zeit-${p.id}`, block: 4, name: p.name, jahr: std * satz, rechnung: `${zahl(std)} Std × ${eur(satz)} Lohnkosten je Std`, ausZeit: true }); } } for (const k of t.kosten.filter((x) => x.block === block)) { const r = zeileRechnen(k, lohnsumme, u); roh.push({ id: k.id, block, name: k.name, jahr: r.jahr, rechnung: r.rechnung }); } if (block === 1) lohnsumme = roh.reduce((s, z) => s + z.jahr, 0); } const kosten = roh.reduce((s, z) => s + z.jahr, 0); const gewinn = (kosten * (t.gewinn ?? 0)) / 100; const summe = kosten + gewinn; const lohnkosten = roh.filter((z) => z.block <= 3).reduce((s, z) => s + z.jahr, 0); let bis = 0; const bloecke = BLOECKE.map((block) => { const jahr = roh.filter((z) => z.block === block).reduce((s, z) => s + z.jahr, 0); bis += jahr; return { block, jahr, bis, bisJeStd: bis / prod }; }); const satzGenau = summe / prod; const satz = Number.isFinite(satzGenau) ? Math.round(satzGenau) : 0; const lohnkostensatz = Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0; const netto = (t.lohnanteil - t.wagnis) / 100; return { id: t.id, name: t.name, zeit, zeilen: roh.map((z) => ({ ...z, monat: z.jahr / 12, jeStd: z.jahr / prod, anteil: summe ? (z.jahr / summe) * 100 : 0 })), bloecke, lohnkosten, lohnkostensatz, gewinn, summe, satz, satzGenau, gemeinkostenanteil: satz - lohnkostensatz, umsatzbedarf: netto > 0 ? summe / netto : 0, }; } /** Personen je Tabelle: eingetragen oder aus dem Personal gezählt */ export const personenVon = (d: StundensatzDaten, u: Umfeld, id: string) => d.mittellohn[id]?.personen ?? u.personen[id] ?? 0; export function rechneStundensaetze(d: StundensatzDaten, u: Umfeld): StundensatzErgebnis { const koepfe = d.koepfe ?? u.koepfe; const umfeld = { ...u, koepfe }; // Bewertungssatz: Lohnkostensatz der Bewertungs-Tabelle, die ihre eigenen Zeiten dabei nur als Zeit kennt const bt = d.tabellen.find((t) => t.id === d.bewertung); const bewertungssatz = bt ? tabelleRechnen(bt, umfeld, (eigen) => eigen).lohnkostensatz : 0; const tabellen = d.tabellen.map((t) => tabelleRechnen(t, umfeld, (eigen) => (bt ? bewertungssatz : eigen))); const zeilen = tabellen.map((t) => { const m = d.mittellohn[t.id]; return { id: t.id, name: t.name, an: m?.an ?? false, personen: personenVon(d, u, t.id), gezaehlt: u.personen[t.id] ?? 0, std: t.zeit.produktiv, satz: t.satz, lohnkostensatz: t.lohnkostensatz }; }); const mit = zeilen.filter((z) => z.an && z.personen > 0 && z.std > 0); const std = mit.reduce((s, z) => s + z.std * z.personen, 0); const gewichtet = (f: (z: (typeof mit)[number]) => number) => (std > 0 ? Math.round(mit.reduce((s, z) => s + f(z) * z.std * z.personen, 0) / std) : null); const jahr = tabellen.reduce((s, t) => s + t.umsatzbedarf * personenVon(d, u, t.id), 0); const lohn = tabellen.reduce((s, t) => s + t.summe * personenVon(d, u, t.id), 0); return { tabellen, koepfe, bewertungssatz, mittellohn: { zeilen, personen: mit.reduce((s, z) => s + z.personen, 0), std, satz: gewichtet((z) => z.satz), lohnkostensatz: gewichtet((z) => z.lohnkostensatz) }, umsatzbedarf: { jahr, monat: jahr / 12, lohn, material: jahr - lohn }, }; } export const MITTELLOHN = "mittellohn"; /** Sätze und Lohnarten, wie sie ein Angebot festschreibt (A36): Mittellohn zuerst, dann jede Tabelle */ export function saetzeFuerAngebot(e: StundensatzErgebnis): { stundensaetze: Record; lohnarten: { id: string; name: string }[] } { const stundensaetze: Record = {}; const lohnarten: { id: string; name: string }[] = []; if (e.mittellohn.satz != null) { stundensaetze[MITTELLOHN] = e.mittellohn.satz; lohnarten.push({ id: MITTELLOHN, name: "Mittellohn" }); } for (const t of e.tabellen) { stundensaetze[t.id] = t.satz; lohnarten.push({ id: t.id, name: t.name }); } return { stundensaetze, lohnarten }; } /** Schlüssel für eine neue Tabelle aus dem Namen: „2. Vorarbeiter“ → „2-vorarbeiter“, eindeutig */ export function schluesselFuer(name: string, vorhanden: string[]): string { const roh = name.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30) || "lohnart"; let s = roh === MITTELLOHN ? "lohnart" : roh, i = 2; while (vorhanden.includes(s)) s = `${roh}-${i++}`; return s; } /** Jahressumme einer laufenden Kosten-Position im Jahr (einmalige zählen nicht) */ export function laufendImJahr(k: { betrag: number; rhythmus: string; start: string; ende?: string | null }, jahr: number): Cent { if (k.rhythmus === "einmalig" || k.start > `${jahr}-12-31` || (k.ende && k.ende < `${jahr}-01-01`)) return 0; return k.betrag * ({ monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 } as Record)[k.rhythmus]!; }