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:
@@ -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 {
|
||||
|
||||
93
src/domain/stundensatz-excel.ts
Normal file
93
src/domain/stundensatz-excel.ts
Normal 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
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