Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz),
Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau
(80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten.
Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage
bei neuer Version.

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-22 06:55:22 +00:00
parent 0d5f11c842
commit 45c21943bf
24 changed files with 1305 additions and 42 deletions

270
src/domain/stundensatz.ts Normal file
View File

@@ -0,0 +1,270 @@
// 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<Block, string> = {
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<KostenArtS, string> = {
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<string, { an: boolean; personen: number | null }>;
}
/** 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<string, number>;
laufend: Record<string, Cent>;
}
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<ZeileErgebnis, "monat" | "jeStd" | "anteil">[] = [];
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<string, Cent>; lohnarten: { id: string; name: string }[] } {
const stundensaetze: Record<string, Cent> = {};
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<string, number>)[k.rhythmus]!;
}