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

View File

@@ -13,9 +13,25 @@ export type Kostenart = (typeof KOSTENARTEN)[number];
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
lohn: "Lohn", material: "Material", geraet: "Gerät", fahrt: "Fahrt", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
};
// Lohnarten ohne Stundensatz-Tabellen; mit Tabellen (M17) sind es deren Schlüssel und der Mittellohn
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
export type Lohnart = (typeof LOHNARTEN)[number];
export const LOHNART_NAME: Record<Lohnart, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
export type Lohnart = string;
export const LOHNART_NAME: Record<string, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer", chef: "Chef", mittellohn: "Mittellohn" };
/** Lohnarten, die ein Angebot kennt: aus den festgeschriebenen Stundensatz-Tabellen oder die drei festen */
export function lohnartenVon(s: Pick<Saetze, "lohnarten" | "stundensaetze">): { id: string; name: string }[] {
if (s.lohnarten?.length) return s.lohnarten;
return Object.keys(s.stundensaetze).map((id) => ({ id, name: LOHNART_NAME[id] ?? id }));
}
/** Auswahl für eine Lohnzeile; eine Lohnart, die das Angebot nicht kennt, bleibt sichtbar */
export function lohnartOptionen(liste: { id: string; name: string }[], aktuell: string | null | undefined): [string, string][] {
const o = liste.map((x): [string, string] => [x.id, x.name]);
if (aktuell && !o.some(([id]) => id === aktuell)) o.push([aktuell, LOHNART_NAME[aktuell] ?? aktuell]);
return o;
}
/** Lohnarten für Vorlagen ohne Angebot: Mittellohn und die üblichen Tabellen */
export const VORLAGE_LOHNARTEN = ["mittellohn", "chef", "planer", "geselle", "helfer"].map((id) => ({ id, name: LOHNART_NAME[id]! }));
/** Lohnart neuer Lohnzeilen: Mittellohn, wenn das Angebot einen hat, sonst Geselle */
export const standardLohnart = (s: Pick<Saetze, "stundensaetze">) => (s.stundensaetze.mittellohn != null ? "mittellohn" : "geselle");
// A28: Alternativ- und Eventualpositionen stehen mit Preis da, zählen aber nicht; „eventual_summe“ ist einkalkuliert
export const POSITIONSARTEN = ["normal", "alternativ", "eventual", "eventual_summe"] as const;
@@ -40,7 +56,11 @@ export function einheitRichtig(e: string): string | undefined {
export interface Saetze {
/** EK-Stundensätze in Cent je Lohnart, beim Anlegen des Angebots festgeschrieben (A36) */
stundensaetze: Record<Lohnart, Cent>;
stundensaetze: Record<string, Cent>;
/** Lohnarten mit Namen aus den Stundensatz-Tabellen (M17), Mittellohn zuerst */
lohnarten?: { id: string; name: string }[];
/** Version der Stundensätze, aus der die Sätze stammen */
stundensatz_version?: { id: string; name: string; gilt_ab: string } | null;
/** Standardzuschläge in % je Kostenart */
zuschlaege: Record<Kostenart, number>;
wagnis: number;
@@ -180,7 +200,7 @@ export function verteile(betrag: Cent, gewichte: number[]): Cent[] {
export function ekVon(k: KKosten, s: Saetze): number {
if (k.ek !== null && k.ek !== undefined && k.ek !== "") return Number(k.ek);
if (k.kostenart === "fahrt") return s.kilometersatz ?? 50;
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? 0 : 0;
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? s.stundensaetze.geselle ?? 0 : 0;
}
export function zuschlagVon(k: KKosten, s: Saetze): number {

View File

@@ -0,0 +1,93 @@
// Erste Fassung der Stundensätze aus Hennings Excel 26-05-26_Pers_Stundenlohn_HS.xlsx (M19): Blätter Personalzeit,
// Personalkosten (Chef) und Planerkosten mit denselben Zahlen. Beträge aus „Zim. Grundk.“ (andere Datei) stehen hier
// fest auf den Cent gerundet. Abnahme: 80,38 €/Std Chef und 107,81 €/Std Planer.
// Die zweite Fassung setzt Hennings Antwort S2 um: Akquise und Verwaltung als Kosten statt als Zeitabzug.
import type { Kostenzeile, Rechentabelle, StundensatzDaten, Unproduktiv } from "./stundensatz.js";
const zeit = (): Rechentabelle["zeit"] => ({
stundenTag: 8, tageJahr: 260, feiertage: 10,
ausfall: [
{ id: "a1", name: "Urlaub", tage: 30 }, { id: "a2", name: "Fort- und Weiterbildung", tage: 3 }, { id: "a3", name: "Krankheit, Kuren, Reha", tage: 8 },
{ id: "a4", name: "Sonderurlaub, Sonderbefreiung", tage: 0 }, { id: "a5", name: "Kinderbetreuung", tage: 1 },
],
unproduktiv: [
{ id: "u1", name: "Akquise, Kundenberatung", stunden: 7, je: "monat", als: "zeit" }, { id: "u2", name: "Verwaltung", stunden: 7, je: "monat", als: "zeit" },
{ id: "u3", name: "Rüstzeiten", stunden: 1, je: "tag", als: "zeit" }, { id: "u4", name: "Koordinationszeit", stunden: 0.5, je: "tag", als: "zeit" },
],
});
const sozial = (): Kostenzeile[] => [
{ id: "k3", block: 2, name: "AG-Anteil Krankenversicherung", art: "prozent", prozent: 15 },
{ id: "k4", block: 2, name: "AG-Anteil Rentenversicherung", art: "prozent", prozent: 19 },
{ id: "k5", block: 2, name: "AG-Anteil Pflegeversicherung", art: "prozent", prozent: 4 },
{ id: "k6", block: 2, name: "AG-Anteil Arbeitslosenversicherung", art: "prozent", prozent: 0 },
{ id: "k7", block: 2, name: "Berufsgenossenschaft (BG)", art: "jahr", betrag: 0 },
{ id: "k8", block: 2, name: "SoKa-Bau", art: "prozent", prozent: 0 },
];
function chef(): Rechentabelle {
return {
id: "chef", name: "Chef", zeit: zeit(), gewinn: 0, lohnanteil: 55, wagnis: 3,
kosten: [
{ id: "k1", block: 1, name: "Grundvergütung", art: "netto", betrag: 300000, faktor: 0.7 },
{ id: "k2", block: 1, name: "Telefonzuschuss", art: "monat", betrag: 1000 },
...sozial(),
{ id: "k9", block: 3, name: "Betriebsärztlicher Dienst", art: "jahr", betrag: 15000 },
{ id: "k10", block: 3, name: "Fortbildung", art: "jahr", betrag: 50000 },
{ id: "k11", block: 4, name: "Sachaufwand Fahrzeuge", art: "jahr", betrag: 1134490, koepfe: true, notiz: "aus Zim. Grundk." },
{ id: "k12", block: 4, name: "Sachaufwand Werkzeug", art: "jahr", betrag: 241392, koepfe: true, notiz: "aus Zim. Grundk." },
{ id: "k13", block: 4, name: "Sachaufwand Software", art: "jahr", betrag: 177000, koepfe: true, notiz: "aus Zim. Grundk." },
{ id: "k14", block: 4, name: "Investitionsrücklagen", art: "monat", betrag: 10000, koepfe: true },
{ id: "k15", block: 4, name: "Verwaltung", art: "stunden", stunden: 8, betrag: 6500, koepfe: true },
{ id: "k16", block: 4, name: "Kundenberatung, Akquisekosten", art: "stunden", stunden: 8, betrag: 6500, koepfe: true },
{ id: "k17", block: 4, name: "Verbände", art: "jahr", betrag: 118000, koepfe: true, notiz: "aus Zim. Grundk." },
{ id: "k18", block: 5, name: "FiBu (USt, Mitarbeiterverwaltung)", art: "monat", betrag: 120000, koepfe: true, notiz: "aus Zim. Grundk." },
{ id: "k19", block: 5, name: "Steuerberatung", art: "jahr", betrag: 198615, koepfe: true, notiz: "aus Zim. Grundk." },
],
};
}
function planer(): Rechentabelle {
return {
id: "planer", name: "Planer", zeit: zeit(), gewinn: 0, lohnanteil: 100, wagnis: 3,
kosten: [
{ id: "k1", block: 1, name: "Grundvergütung", art: "netto", betrag: 500000, faktor: 0.7 },
{ id: "k2", block: 1, name: "Telefonzuschuss", art: "monat", betrag: 1000 },
...sozial(),
{ id: "k10", block: 3, name: "Fortbildung", art: "jahr", betrag: 50000 },
{ id: "k11", block: 4, name: "Sachaufwand Fahrzeuge", art: "jahr", betrag: 200000 },
{ id: "k12", block: 4, name: "Sachaufwand Werkzeug", art: "jahr", betrag: 0 },
{ id: "k13", block: 4, name: "Sachaufwand Software", art: "jahr", betrag: 200000, notiz: "10.000 € auf 5 Jahre" },
{ id: "k14", block: 4, name: "Investitionsrücklagen", art: "monat", betrag: 10000 },
{ id: "k17", block: 4, name: "Verbände", art: "jahr", betrag: 22000, notiz: "aus Zim. Grundk." },
{ id: "k18", block: 5, name: "FiBu (USt, Mitarbeiterverwaltung)", art: "monat", betrag: 120000, anteil: 20, notiz: "aus Zim. Grundk." },
{ id: "k19", block: 5, name: "Steuerberatung", art: "jahr", betrag: 198615, anteil: 20, notiz: "aus Zim. Grundk." },
],
};
}
/** Fassung 1: genau die Excel-Tabelle; Geselle und Helfer zunächst als Kopie von Chef (in der Excel gibt es sie nicht) */
export function stundensaetzeAusExcel(): StundensatzDaten {
const geselle = { ...chef(), id: "geselle", name: "Geselle", hinweis: "Kopie von Chef (in deiner Excel gleich). Bitte Lohn und Zeiten anpassen." };
const helfer = { ...chef(), id: "helfer", name: "Helfer", hinweis: "In deiner Excel gibt es kein Helfer-Blatt: Kopie von Chef, bitte Lohn und Zeiten eintragen." };
return {
tabellen: [chef(), planer(), geselle, helfer],
koepfe: 2,
bewertung: "geselle",
mittellohn: { chef: { an: true, personen: 1 }, geselle: { an: true, personen: 1 }, helfer: { an: false, personen: null }, planer: { an: false, personen: null } },
};
}
/** Fassung 2 (S2): Akquise und Verwaltung zählen nicht mehr als Zeit, sondern als Kosten zum Lohnkostensatz des Gesellen */
export function stundensaetzeNachS2(d: StundensatzDaten): StundensatzDaten {
const x = structuredClone(d);
for (const t of x.tabellen) {
const akquise = (u: Unproduktiv) => /akquise|verwaltung/i.test(u.name);
if (!t.zeit.unproduktiv.some(akquise)) continue;
for (const u of t.zeit.unproduktiv) if (akquise(u)) u.als = "kosten";
t.kosten = t.kosten.filter((k) => !(k.art === "stunden" && /akquise|verwaltung/i.test(k.name)));
}
x.koepfe = null;
for (const m of Object.values(x.mittellohn)) m.personen = null;
return x;
}

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]!;
}