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
This commit is contained in:
270
src/domain/stundensatz.ts
Normal file
270
src/domain/stundensatz.ts
Normal 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]!;
|
||||
}
|
||||
Reference in New Issue
Block a user