Files
Betriebsf-hrungssoftware/src/domain/stundensatz.ts
Claude 45c21943bf
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
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
2026-10-22 06:55:22 +00:00

271 lines
14 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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]!;
}