Files
Betriebsf-hrungssoftware/src/web/stundensaetze.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

405 lines
30 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.
// Personal → Stundensätze (M15–M19, Henning 22.10.2026, Entwurf angebote/stundensaetze/entwurf): links die
// Rechentabellen je Lohnart mit ihrem Satz und „+ Tabelle hinzufügen“, rechts die geöffnete Tabelle wie Hennings
// Excel-Blatt (1 Zeit, 2 Kosten, 3 Stundensatz), darunter der Mittellohn mit Schaltern je Lohnart.
// Versionen mit „gilt ab“: ein Angebot nimmt die Version, die an seinem Datum gilt, und schreibt die Sätze fest.
// Nur für den Inhaber (Löhne, U2).
import { type Zeile, api, bestaetigen, dat, dialog, esc, heute, huelle, inhalt, lies, merke } from "./ui.js";
import { formatEuro, parseEuro } from "../domain/geld.js";
import { feiertageSH } from "../domain/kalender.js";
import { plusTage, wochentag } from "../domain/datum.js";
import { BLOCK_NAME, BLOECKE, type Block, KOSTENARTEN_S, KOSTENART_S_NAME, type Kostenzeile, type Rechentabelle, type StundensatzDaten, type StundensatzErgebnis,
type TabellenErgebnis, type Umfeld, rechneStundensaetze, schluesselFuer } from "../domain/stundensatz.js";
interface Version { id: string; name: string; gilt_ab: string; daten: StundensatzDaten }
type UmfeldMitListe = Umfeld & { liste: { id: string; bezeichnung: string; kategorie: string | null; jahr: number }[] };
let d: Zeile;
let versionen: Version[] = [];
let v: Version | null = null;
let offen: string | null = null;
let speichernNach: ReturnType<typeof setTimeout> | undefined;
let teile: (aktiv: string) => void = () => {};
const zahl = (n: number, stellen = 2) => (Number.isFinite(n) ? n.toLocaleString("de-DE", { maximumFractionDigits: stellen }) : "–");
const eur = (c: number) => (Number.isFinite(c) ? formatEuro(Math.round(c)) : "–");
const eurWert = (c: number | undefined) => (c ? formatEuro(c, false) : "");
const zahlWert = (n: number | undefined | null) => (n == null ? "" : n.toLocaleString("de-DE", { maximumFractionDigits: 4, useGrouping: false }));
const neueId = () => `n${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`;
const leseZahl = (t: string) => {
const s = t.trim().replace(/\./g, "").replace(",", ".");
if (!s) return 0;
const n = Number(s);
if (!Number.isFinite(n) || n < 0) throw new Error("Bitte eine Zahl eingeben.");
return n;
};
const umfeld = (): UmfeldMitListe => d.umfeld[Number(v!.gilt_ab.slice(0, 4))] ?? d.umfeld[Number(heute().slice(0, 4))];
const rechne = (): StundensatzErgebnis => rechneStundensaetze(v!.daten, umfeld());
const tabelle = (): Rechentabelle => v!.daten.tabellen.find((t) => t.id === offen) ?? v!.daten.tabellen[0]!;
export async function stundensaetzeTeil(kopf: (aktiv: string) => void): Promise<void> {
teile = kopf;
d = await api<Zeile>("stundensaetze");
versionen = d.versionen;
v = versionen.find((x) => x.id === lies("ss-version")) ?? versionen.find((x) => x.id === d.gilt) ?? versionen[versionen.length - 1] ?? null;
inhalt.innerHTML = '<div class="kopf"><h1>Personal</h1></div>';
teile("stundensaetze");
if (!v) return leerZeigen();
if (!v.daten.tabellen.some((t) => t.id === offen)) offen = lies("ss-tabelle") && v.daten.tabellen.some((t) => t.id === lies("ss-tabelle")) ? lies("ss-tabelle") : v.daten.tabellen[0]!.id;
const leiste = document.createElement("div");
leiste.className = "leiste ss-leiste";
inhalt.append(leiste);
leiste.innerHTML = `<div class="jp-versionen" role="group" aria-label="Version"><span class="hinweis">Version:</span>${versionen.map((x) =>
`<button class="chip-knopf${x.id === v?.id ? " an" : ""}" data-version="${x.id}" aria-pressed="${x.id === v?.id}">${esc(x.name)} <small>ab ${dat(x.gilt_ab)}</small>${x.id === d.gilt ? ' <span class="jp-gilt">gilt heute</span>' : ""}</button>`).join("")}
<button class="chip-knopf" data-a="neue-version" title="Kopie dieser Version mit eigenem „gilt ab“">+ neue Version</button>
<button class="verweis" data-a="version-bearbeiten" aria-label="Version umbenennen, Datum ändern oder löschen">⋯</button></div>
<span class="hinweis ss-gespeichert" aria-live="polite"></span>`;
leiste.onclick = (ev) => void leisteKlick(ev);
const raster = document.createElement("div");
raster.className = "ss-raster";
inhalt.append(raster);
zeichne();
}
function leerZeigen(): void {
const k = document.createElement("section");
k.className = "karte ss-leer";
k.innerHTML = `<h2>Noch keine Stundensätze</h2>
<p>Das Programm rechnet je Lohnart wie deine Excel-Tabelle: Zeit, Kosten, Stundensatz. Am einfachsten beginnst du mit deiner Excel vom 26.05.2026.</p>
<p class="hinweis">Es entstehen zwei Versionen: <b>genau deine Excel</b> (Chef 80,38 €, Planer 107,81 €) und <b>ab heute</b> die Fassung nach unserer Absprache: Akquise und Verwaltung zählen als Kosten zum Lohnkostensatz des Gesellen statt als Zeitabzug. Geselle und Helfer starten als Kopie von Chef.</p>
<div class="knoepfe-links"><button class="haupt" data-a="excel">Mit meiner Excel beginnen</button></div>`;
inhalt.append(k);
k.querySelector<HTMLElement>('[data-a="excel"]')!.onclick = async () => {
const neu = await api<Version>("stundensaetze/excel", "POST");
merke("ss-version", neu.id);
void stundensaetzeTeil(teile);
};
}
async function leisteKlick(ev: Event): Promise<void> {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-version], [data-a]");
if (!b || !v) return;
await speichernJetzt();
if (b.dataset.version) { merke("ss-version", b.dataset.version); return stundensaetzeTeil(teile); }
if (b.dataset.a === "neue-version") {
const vorschlag = (() => { let t = heute(); while (versionen.some((x) => x.gilt_ab === t)) t = plusTage(t, 1); return t; })();
const e = await dialog("Neue Version", [
{ name: "name", titel: "Name", pflicht: true, hilfe: "z. B. „Lohnerhöhung 2027“" },
{ name: "gilt_ab", titel: "Gilt ab", art: "datum", pflicht: true, hilfe: "Angebote ab diesem Tag bekommen diese Sätze. Ältere Angebote behalten ihre." },
], { name: `Version ${versionen.length + 1}`, gilt_ab: vorschlag }, false);
if (e?.aktion !== "speichern") return;
const neu = await api<Version>("stundensaetze", "POST", { name: e.daten.name, gilt_ab: e.daten.gilt_ab, daten: v.daten });
merke("ss-version", neu.id);
return stundensaetzeTeil(teile);
}
if (b.dataset.a === "version-bearbeiten") {
const e = await dialog("Version bearbeiten", [
{ name: "name", titel: "Name", pflicht: true }, { name: "gilt_ab", titel: "Gilt ab", art: "datum", pflicht: true },
], { name: v.name, gilt_ab: v.gilt_ab }, versionen.length > 1);
if (!e) return;
if (e.aktion === "loeschen") { await api(`stundensaetze/${v.id}`, "DELETE"); merke("ss-version", null); }
else await api(`stundensaetze/${v.id}`, "PATCH", { name: e.daten.name, gilt_ab: e.daten.gilt_ab });
return stundensaetzeTeil(teile);
}
}
// ---------- Zeichnen ----------
/** Werte, die sich beim Tippen ändern: data-w="…" */
function werte(e: StundensatzErgebnis): Record<string, string> {
const w: Record<string, string> = {};
for (const t of e.tabellen) w[`l.${t.id}`] = eur(t.satz);
w["ml.satz"] = e.mittellohn.satz == null ? "–" : eur(e.mittellohn.satz);
w["ml.lohn"] = e.mittellohn.lohnkostensatz == null ? "–" : eur(e.mittellohn.lohnkostensatz);
w["ml.personen"] = zahl(e.mittellohn.personen);
w["ml.std"] = zahl(e.mittellohn.std, 0);
for (const z of e.mittellohn.zeilen) { w[`ml.${z.id}.std`] = zahl(z.std, 0); w[`ml.${z.id}.satz`] = eur(z.satz); }
w["ub.jahr"] = eur(e.umsatzbedarf.jahr); w["ub.monat"] = eur(e.umsatzbedarf.monat);
w["bewertung"] = eur(e.bewertungssatz);
w["koepfe"] = zahl(e.koepfe);
const t = e.tabellen.find((x) => x.id === tabelle().id)!;
const z = t.zeit;
Object.assign(w, {
"z.brutto": zahl(z.bruttoStd), "z.feiertage": `−${zahl(z.feiertageStd)}`, "z.jahresStd": zahl(z.jahresStd), "z.jahresTage": zahl(z.jahresTage),
"z.ausfallStd": `−${zahl(z.ausfallStd)}`, "z.ausfallTage": `−${zahl(z.ausfallTage)}`, "z.anwesend": zahl(z.anwesenheitTage),
"z.produktiv": zahl(z.produktiv), "z.produktivTage": zahl(z.produktivTage), "z.tageJahr": zahl(tabelle().zeit.tageJahr), "z.feiertageTage": `−${zahl(tabelle().zeit.feiertage)}`,
});
for (const a of z.ausfall) { w[`a.${a.id}.std`] = `−${zahl(a.std)}`; w[`a.${a.id}.tage`] = `−${zahl(a.tage)}`; }
for (const u of z.unproduktiv) { w[`u.${u.id}.std`] = u.als === "zeit" ? `−${zahl(u.std)}` : zahl(u.std); w[`u.${u.id}.tage`] = u.als === "zeit" ? `−${zahl(u.tage)}` : "→ Kosten"; }
for (const k of t.zeilen) {
w[`k.${k.id}.jahr`] = eur(k.jahr); w[`k.${k.id}.monat`] = eur(k.monat); w[`k.${k.id}.std`] = eur(k.jeStd); w[`k.${k.id}.anteil`] = `${zahl(k.anteil, 1)} %`;
w[`k.${k.id}.rechnung`] = k.rechnung;
}
for (const b of t.bloecke) { w[`b.${b.block}.jahr`] = eur(b.bis); w[`b.${b.block}.monat`] = eur(b.bis / 12); w[`b.${b.block}.std`] = eur(b.bisJeStd); }
Object.assign(w, {
"t.gewinn": eur(t.gewinn), "t.summe": eur(t.summe), "t.summeMonat": eur(t.summe / 12), "t.satz": eur(t.satz), "t.lohnkostensatz": eur(t.lohnkostensatz),
"t.gemein": eur(t.gemeinkostenanteil), "t.umsatz": eur(t.umsatzbedarf), "t.umsatzMonat": eur(t.umsatzbedarf / 12), "t.name": t.name,
});
return w;
}
let W: Record<string, string> = {};
const w = (k: string, klasse = "") => `<span data-w="${k}"${klasse ? ` class="${klasse}"` : ""}>${esc(W[k] ?? "")}</span>`;
const ein = (f: string, wert: string, o: { t?: string; klasse?: string; titel: string; platz?: string } ) =>
`<input data-f="${f}" data-t="${o.t ?? "zahl"}" value="${esc(wert)}" class="${o.klasse ?? "zahl w-kurz"}" aria-label="${esc(o.titel)}" title="${esc(o.titel)}"${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.t === "text" ? "" : ' inputmode="decimal"'}>`;
const wahl = (f: string, optionen: [string, string][], wert: string, titel: string) =>
`<select data-f="${f}" data-t="text" aria-label="${esc(titel)}">${optionen.map(([x, t]) => `<option value="${esc(x)}"${x === wert ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
function zeichne(): void {
const raster = inhalt.querySelector<HTMLElement>(".ss-raster")!;
const e = rechne();
W = werte(e);
const t = tabelle(), te = e.tabellen.find((x) => x.id === t.id)!;
raster.innerHTML = `<aside class="karte ss-links">${linksHtml(e)}</aside>
<div class="ss-rechts"><section class="karte ss-tabelle">${tabelleHtml(t, te, e)}</section>
<section class="karte ss-mittellohn">${mittellohnHtml(e)}</section>
<section class="karte ss-angebot"><h2>So kommt es ins Angebot</h2>
<p>In der Kalkulation einer Position wählst du bei Lohn: <b>Mittellohn</b> · ${v!.daten.tabellen.map((x) => esc(x.name)).join(" · ")}. Der Satz ist der Vollkostensatz und geht als Lohn-EK ins Angebot; der Lohnzuschlag neuer Angebote ist deshalb 0 %, Wagnis und Gewinn kommen wie bisher je Angebot dazu.</p>
<p class="hinweis">Ein Angebot schreibt die Sätze beim Anlegen fest. Gilt später eine neue Version, fragt der Entwurf, ob er sie übernehmen soll.</p></section></div>`;
verbinden(raster);
}
function linksHtml(e: StundensatzErgebnis): string {
return `<h2>Rechentabellen</h2><div class="ss-liste" role="list">${e.tabellen.map((t) =>
`<button role="listitem" class="ss-eintrag${t.id === tabelle().id ? " an" : ""}" data-tab="${t.id}" aria-current="${t.id === tabelle().id}"><span>${esc(t.name)}</span><b>${w(`l.${t.id}`)}</b></button>`).join("")}</div>
<button class="ss-neu" data-a="tabelle-neu">+ Tabelle hinzufügen<small>z. B. Vorarbeiter, Azubi</small></button>
<h2 class="ss-abstand">Ergebnis</h2>
<div class="ss-ergebnis"><span>Mittellohn</span><b>${w("ml.satz")}</b></div>
<div class="ss-ergebnis klein"><span>Umsatzbedarf im Jahr</span><b>${w("ub.jahr")}</b></div>
<div class="ss-ergebnis klein"><span>je Monat</span><b>${w("ub.monat")}</b></div>
<p class="hinweis">Jede Tabelle ist aufgebaut wie dein Excel-Blatt; eine neue startet als Kopie einer vorhandenen.</p>`;
}
function tabelleHtml(t: Rechentabelle, te: TabellenErgebnis, e: StundensatzErgebnis): string {
const z = t.zeit;
const kal = kalender(Number(v!.gilt_ab.slice(0, 4)));
const ausfall = z.ausfall.map((a) => `<tr><td>${ein(`a.${a.id}.name`, a.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td>
<td>${ein(`a.${a.id}.tage`, zahlWert(a.tage), { titel: `${a.name}: Tage im Jahr` })} Tage/Jahr</td><td class="zahl">${w(`a.${a.id}.std`)}</td><td class="zahl">${w(`a.${a.id}.tage`)}</td>
<td><button class="verweis ss-weg" data-weg="a.${a.id}" aria-label="${esc(a.name)} entfernen">×</button></td></tr>`).join("");
const unprod = z.unproduktiv.map((u) => `<tr class="${u.als === "kosten" ? "ss-als-kosten" : ""}"><td>${ein(`u.${u.id}.name`, u.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td>
<td><span class="ss-ansatz">${ein(`u.${u.id}.stunden`, zahlWert(u.stunden), { titel: `${u.name}: Stunden` })} Std ${wahl(`u.${u.id}.je`, [["monat", "je Monat"], ["tag", "je Tag"]], u.je, "Stunden je Monat oder je Arbeitstag")}
${wahl(`u.${u.id}.als`, [["zeit", "als Zeit abziehen"], ["kosten", "als Kosten ansetzen"]], u.als, "Als Zeit abziehen oder als Kosten ansetzen")}</span></td>
<td class="zahl">${w(`u.${u.id}.std`)}</td><td class="zahl">${w(`u.${u.id}.tage`)}</td>
<td><button class="verweis ss-weg" data-weg="u.${u.id}" aria-label="${esc(u.name)} entfernen">×</button></td></tr>`).join("");
const kosten = BLOECKE.map((b) => {
const zeilen = te.zeilen.filter((x) => x.block === b).map((x) => {
const k = t.kosten.find((y) => y.id === x.id);
if (!k) return `<tr class="ss-auszeit"><td>${esc(x.name)}</td><td class="hinweis">${w(`k.${x.id}.rechnung`)} <small>(aus 1 Zeit)</small></td>
<td class="zahl">${w(`k.${x.id}.jahr`)}</td><td class="zahl optional">${w(`k.${x.id}.monat`)}</td><td class="zahl">${w(`k.${x.id}.std`)}</td><td class="zahl optional">${w(`k.${x.id}.anteil`)}</td><td></td></tr>`;
return `<tr><td>${ein(`k.${k.id}.name`, k.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td><td>${ansatzHtml(k)}</td>
<td class="zahl">${w(`k.${k.id}.jahr`)}</td><td class="zahl optional">${w(`k.${k.id}.monat`)}</td><td class="zahl">${w(`k.${k.id}.std`)}</td><td class="zahl optional">${w(`k.${k.id}.anteil`)}</td>
<td><button class="verweis ss-weg" data-weg="k.${k.id}" aria-label="${esc(k.name)} entfernen">×</button></td></tr>`;
}).join("");
return `<tr class="ss-block"><th colspan="7">${b} ${esc(BLOCK_NAME[b])}</th></tr>${zeilen}
<tr><td colspan="7"><button class="verweis" data-neu-kosten="${b}">+ Kostenzeile</button></td></tr>
<tr class="ss-zwischen"><td>Zwischensumme ${b}</td><td></td><td class="zahl">${w(`b.${b}.jahr`)}</td><td class="zahl optional">${w(`b.${b}.monat`)}</td><td class="zahl">${w(`b.${b}.std`)}</td><td class="optional"></td><td></td></tr>
${b === 3 ? `<tr class="ss-info"><td colspan="4">= Lohnkosten je Std (ohne Betriebskosten)</td><td class="zahl">${w("t.lohnkostensatz")}</td><td colspan="2" class="optional"></td></tr>` : ""}`;
}).join("");
return `<div class="ss-kopf"><h2>Rechentabelle ${ein("t.name", t.name, { t: "text", klasse: "ss-titel", titel: "Name der Lohnart" })}</h2>
${v!.daten.tabellen.length > 1 ? `<button class="neben" data-a="tabelle-weg">Tabelle löschen</button>` : ""}</div>
${t.hinweis ? `<p class="hinweis ss-hinweis">${esc(t.hinweis)} <button class="verweis" data-a="hinweis-weg">erledigt</button></p>` : ""}
<div class="ss-rolle"><table class="ss-t ss-zeit"><thead><tr><th>1 Zeit</th><th>Ansatz</th><th class="zahl">Std</th><th class="zahl">Tage</th><th></th></tr></thead><tbody>
<tr><td>Arbeitstage im Jahr</td><td>${ein("z.tageJahr", zahlWert(z.tageJahr), { titel: "Arbeitstage im Jahr (5 Tage × 52 Wochen = 260)" })} Tage × ${ein("z.stundenTag", zahlWert(z.stundenTag), { titel: "Stunden je Tag" })} Std/Tag</td>
<td class="zahl">${w("z.brutto")}</td><td class="zahl">${w("z.tageJahr")}</td><td></td></tr>
<tr><td>− Feiertage SH</td><td>${ein("z.feiertage", zahlWert(z.feiertage), { titel: "Feiertage im Jahr" })} Tage
<small class="hinweis" title="Werktage Mo–Fr und Feiertage, die auf Mo–Fr fallen">Kalender ${kal.jahr}: ${kal.werktage} Werktage, ${kal.feiertage} Feiertage auf Mo–Fr <button class="verweis" data-a="kalender">übernehmen</button></small></td>
<td class="zahl">${w("z.feiertage")}</td><td class="zahl">${w("z.feiertageTage")}</td><td></td></tr>
<tr class="ss-zwischen"><td>= Jahresarbeitszeit</td><td></td><td class="zahl">${w("z.jahresStd")}</td><td class="zahl">${w("z.jahresTage")}</td><td></td></tr>
${ausfall}<tr><td colspan="5"><button class="verweis" data-a="ausfall-neu">+ Ausfallzeit</button></td></tr>
<tr class="ss-zwischen"><td>= Anwesenheit</td><td></td><td class="zahl">${w("z.ausfallStd")}</td><td class="zahl">${w("z.anwesend")}</td><td></td></tr>
${unprod}<tr><td colspan="5"><button class="verweis" data-a="unprod-neu">+ unproduktive Zeit</button></td></tr>
<tr class="ss-ergebniszeile"><td><b>= produktive Stunden</b></td><td></td><td class="zahl"><b>${w("z.produktiv")}</b></td><td class="zahl">${w("z.produktivTage")}</td><td></td></tr>
</tbody></table></div>
<div class="ss-rolle"><table class="ss-t ss-kosten"><thead><tr><th>2 Kosten</th><th>Ansatz</th><th class="zahl">€ / Jahr</th><th class="zahl optional">€ / Monat</th><th class="zahl">€ / Std</th><th class="zahl optional">Anteil</th><th></th></tr></thead><tbody>
${kosten}
<tr><td>kalkulatorischer Gewinn</td><td>${ein("t.gewinn", zahlWert(t.gewinn), { titel: "Gewinn in % der Kosten" })} %</td><td class="zahl">${w("t.gewinn")}</td><td class="optional"></td><td></td><td class="optional"></td><td></td></tr>
<tr class="ss-ergebniszeile"><td colspan="2"><b>3 Stundensatz ${w("t.name")} (Vollkosten)</b><small class="hinweis"> ${w("t.summe")} im Jahr ÷ ${w("z.produktiv")} produktive Std</small></td>
<td class="zahl">${w("t.summe")}</td><td class="zahl optional">${w("t.summeMonat")}</td><td class="zahl ss-gross">${w("t.satz")}</td><td colspan="2" class="optional"></td></tr>
<tr class="ss-info"><td colspan="4">davon Lohnkosten / Gemeinkostenanteil</td><td class="zahl">${w("t.lohnkostensatz")} / ${w("t.gemein")}</td><td colspan="2" class="optional"></td></tr>
</tbody></table></div>
<p class="ss-umsatz">Umsatzbedarf für eine Person: Lohnanteil am Umsatz ${ein("t.lohnanteil", zahlWert(t.lohnanteil), { titel: "Lohnanteil am Umsatz in %" })} %, davon Wagnis ${ein("t.wagnis", zahlWert(t.wagnis), { titel: "Wagnis in %" })} %
→ <b>${w("t.umsatz")}</b> im Jahr, ${w("t.umsatzMonat")} im Monat</p>
<p class="hinweis">Sachkosten „÷ Köpfe“ werden auf ${w("koepfe")} Köpfe verteilt (unten beim Mittellohn änderbar). Akquise und Verwaltung „als Kosten“ zählen mit ${w("bewertung")} je Std, dem Lohnkostensatz von ${esc(v!.daten.tabellen.find((x) => x.id === v!.daten.bewertung)?.name ?? "–")}.</p>`;
}
function ansatzHtml(k: Kostenzeile): string {
const f = (feld: string) => `k.${k.id}.${feld}`;
const betrag = (titel: string) => `${ein(f("betrag"), eurWert(k.betrag), { t: "euro", klasse: "zahl w-euro", titel, platz: "0,00" })} €`;
const werte = {
netto: `${betrag("Monatslohn netto")} ÷ ${ein(f("faktor"), zahlWert(k.faktor ?? 1), { titel: "Faktor netto zu brutto (0,7)" })}`,
monat: `${betrag("Betrag je Monat")} /Monat`,
jahr: `${betrag("Betrag je Jahr")} /Jahr`,
prozent: `${ein(f("prozent"), zahlWert(k.prozent ?? 0), { titel: "Prozent der Lohnsumme" })} %`,
stunden: `${ein(f("stunden"), zahlWert(k.stunden ?? 0), { titel: "Stunden je Monat" })} Std × ${betrag("Euro je Stunde")}`,
laufend: `<button class="neben klein" data-laufend="${k.id}">${(k.laufend ?? []).length ? `${(k.laufend ?? []).length} gewählt` : "wählen …"}</button>`,
}[k.art];
return `<div class="ss-ansatz">${wahl(f("art"), KOSTENARTEN_S.map((x) => [x, KOSTENART_S_NAME[x]]), k.art, "Art der Kosten")} ${werte}</div>
<div class="ss-ansatz klein"><label><input type="checkbox" data-f="${f("koepfe")}" data-t="bool"${k.koepfe ? " checked" : ""}> ÷ Köpfe</label>
<span>Anteil ${ein(f("anteil"), zahlWert(k.anteil ?? 100), { titel: "Anteil in %" })} %</span>
${ein(f("notiz"), k.notiz ?? "", { t: "text", klasse: "ss-notiz", titel: "Notiz", platz: "Notiz" })}</div>
<small class="hinweis">${w(`k.${k.id}.rechnung`)}</small>`;
}
function mittellohnHtml(e: StundensatzErgebnis): string {
const dv = v!.daten;
const zeilen = e.mittellohn.zeilen.map((z) => {
const m = dv.mittellohn[z.id];
return `<tr class="${z.an ? "" : "aus"}"><td><label class="ss-schalter"><input type="checkbox" data-f="m.${z.id}.an" data-t="bool"${z.an ? " checked" : ""} aria-label="${esc(z.name)} im Mittellohn"><i></i></label></td>
<td>${esc(z.name)}</td><td class="zahl">${ein(`m.${z.id}.personen`, zahlWert(m?.personen ?? null), { titel: `Personen ${z.name}`, platz: zahl(z.gezaehlt) })}</td>
<td class="zahl">${w(`ml.${z.id}.std`)}</td><td class="zahl">${w(`ml.${z.id}.satz`)}</td></tr>`;
}).join("");
return `<h2>Mittellohn <small class="hinweis">für die Baustelle: wer mitarbeitet</small></h2>
<div class="ss-rolle"><table class="ss-t"><thead><tr><th>mit</th><th>Lohnart</th><th class="zahl">Personen</th><th class="zahl">prod. Std/Jahr</th><th class="zahl">Satz € / Std</th></tr></thead><tbody>${zeilen}
<tr class="ss-ergebniszeile"><td></td><td><b>Mittellohn</b> <small class="hinweis">gewichtet nach Stunden</small></td><td class="zahl">${w("ml.personen")}</td><td class="zahl">${w("ml.std")}</td><td class="zahl ss-gross">${w("ml.satz")}</td></tr>
<tr class="ss-info"><td></td><td colspan="3">davon Lohnkosten ohne Gemeinkosten</td><td class="zahl">${w("ml.lohn")}</td></tr></tbody></table></div>
<p class="hinweis">Der Schalter nimmt die Lohnart in den Mittellohn auf oder heraus. Personen zählt das Programm aus dem Personal (grau); eine Zahl hier gilt für die Planung. Inhaber ohne Rolle zählt als Chef, Angestellte ohne Rolle als Geselle.</p>
<div class="ss-einstellungen"><label>Sachkosten „÷ Köpfe“ verteilen auf ${ein("v.koepfe", zahlWert(dv.koepfe), { titel: "Köpfe im Betrieb", platz: zahl(umfeld().koepfe) })} Köpfe</label>
<label>Akquise und Verwaltung „als Kosten“ bewerten mit dem Lohnkostensatz von ${wahl("v.bewertung", dv.tabellen.map((t) => [t.id, t.name]), dv.bewertung, "Tabelle für die Bewertung")}</label></div>`;
}
/** Werktage Mo–Fr und Feiertage SH auf Mo–Fr in einem Jahr */
function kalender(jahr: number) {
let werktage = 0;
for (let t = `${jahr}-01-01`; t <= `${jahr}-12-31`; t = plusTage(t, 1)) if (wochentag(t) <= 5) werktage++;
return { jahr, werktage, feiertage: feiertageSH(jahr).filter((f) => wochentag(f.datum) <= 5).length };
}
// ---------- Eingaben ----------
function setze(feld: string, typ: string, roh: string | boolean): void {
const dv = v!.daten, t = tabelle();
const [art, id, name] = feld.split(".");
const wert = typ === "bool" ? roh : typ === "text" ? String(roh) : typ === "euro" ? (String(roh).trim() ? parseEuro(String(roh)) : 0) : leseZahl(String(roh));
if (typeof wert === "number" && wert < 0) throw new Error("Bitte keine negativen Zahlen.");
const satz = (o: object, k: string, x: unknown) => { (o as Record<string, unknown>)[k] = x; };
if (art === "t") satz(t, id!, id === "name" ? String(wert).trim() || t.name : wert);
if (art === "z") satz(t.zeit, id!, wert);
if (art === "a") { const a = t.zeit.ausfall.find((x) => x.id === id); if (a) satz(a, name!, wert); }
if (art === "u") { const u = t.zeit.unproduktiv.find((x) => x.id === id); if (u) satz(u, name!, wert); }
if (art === "k") {
const k = t.kosten.find((x) => x.id === id);
if (!k) return;
if (name === "art") { k.art = wert as Kostenzeile["art"]; if (k.art === "netto" && !k.faktor) k.faktor = 0.7; }
else if (name === "notiz") k.notiz = String(wert).trim() || undefined;
else satz(k, name!, wert);
}
if (art === "m") {
const m = (dv.mittellohn[id!] ??= { an: false, personen: null });
if (name === "an") m.an = !!wert;
else m.personen = String(roh).trim() ? (wert as number) : null;
}
if (art === "v" && id === "koepfe") dv.koepfe = String(roh).trim() && (wert as number) >= 1 ? (wert as number) : null;
if (art === "v" && id === "bewertung") dv.bewertung = String(wert);
}
function verbinden(raster: HTMLElement): void {
raster.addEventListener("input", (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.dataset.f || el.type === "checkbox" || el.tagName === "SELECT") return;
try {
setze(el.dataset.f, el.dataset.t ?? "zahl", el.value);
el.classList.remove("ungueltig"); el.removeAttribute("aria-invalid");
} catch { el.classList.add("ungueltig"); el.setAttribute("aria-invalid", "true"); return; }
W = werte(rechne());
raster.querySelectorAll<HTMLElement>("[data-w]").forEach((x) => { const n = W[x.dataset.w!]; if (n != null && x.textContent !== n) x.textContent = n; });
speichernSpaeter();
});
raster.addEventListener("change", (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.dataset.f) return;
if (el.type === "checkbox" || el.tagName === "SELECT") {
setze(el.dataset.f, el.dataset.t ?? "text", el.type === "checkbox" ? el.checked : el.value);
speichernSpaeter();
zeichne();
}
});
raster.addEventListener("click", (ev) => void klick(ev));
}
async function klick(ev: Event): Promise<void> {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-tab], [data-a], [data-weg], [data-neu-kosten], [data-laufend]");
if (!b) return;
const dv = v!.daten, t = tabelle();
if (b.dataset.tab) { offen = b.dataset.tab; merke("ss-tabelle", offen); return zeichne(); }
if (b.dataset.weg) {
const [art, id] = b.dataset.weg.split(".");
if (art === "a") t.zeit.ausfall = t.zeit.ausfall.filter((x) => x.id !== id);
if (art === "u") t.zeit.unproduktiv = t.zeit.unproduktiv.filter((x) => x.id !== id);
if (art === "k") t.kosten = t.kosten.filter((x) => x.id !== id);
}
if (b.dataset.neuKosten) t.kosten.push({ id: neueId(), block: Number(b.dataset.neuKosten) as Block, name: "", art: Number(b.dataset.neuKosten) === 2 ? "prozent" : "jahr", betrag: 0, prozent: 0 });
if (b.dataset.laufend) { if (!(await laufendWaehlen(t.kosten.find((x) => x.id === b.dataset.laufend)!))) return; }
const a = b.dataset.a;
if (a === "ausfall-neu") t.zeit.ausfall.push({ id: neueId(), name: "", tage: 0 });
if (a === "unprod-neu") t.zeit.unproduktiv.push({ id: neueId(), name: "", stunden: 0, je: "monat", als: "zeit" });
if (a === "hinweis-weg") delete t.hinweis;
if (a === "kalender") { const k = kalender(Number(v!.gilt_ab.slice(0, 4))); t.zeit.tageJahr = k.werktage; t.zeit.feiertage = k.feiertage; }
if (a === "tabelle-neu") {
const e = await dialog("Tabelle hinzufügen", [
{ name: "name", titel: "Lohnart", pflicht: true, hilfe: "z. B. Vorarbeiter, Azubi, 2. Geselle" },
{ name: "von", titel: "Kopie von", art: "auswahl", optionen: dv.tabellen.map((x) => [x.id, x.name]) },
], { von: t.id }, false);
if (e?.aktion !== "speichern") return;
const quelle = dv.tabellen.find((x) => x.id === e.daten.von) ?? t;
const neu: Rechentabelle = { ...structuredClone(quelle), id: schluesselFuer(e.daten.name, dv.tabellen.map((x) => x.id)), name: e.daten.name, hinweis: `Kopie von ${quelle.name}. Bitte Lohn und Zeiten anpassen.` };
dv.tabellen.push(neu);
dv.mittellohn[neu.id] = { an: false, personen: null };
offen = neu.id;
}
if (a === "tabelle-weg") {
const benutzt = dv.bewertung === t.id;
if (!(await bestaetigen(`Tabelle „${t.name}“ löschen?`, { hinweis: "Angebote, die diese Lohnart schon haben, behalten ihren Satz.", ja: "Löschen" }))) return;
dv.tabellen = dv.tabellen.filter((x) => x.id !== t.id);
delete dv.mittellohn[t.id];
if (benutzt) dv.bewertung = dv.tabellen.find((x) => x.id === "geselle")?.id ?? dv.tabellen[0]!.id;
offen = dv.tabellen[0]!.id;
}
speichernSpaeter();
zeichne();
}
/** Auswahl laufender Kosten für eine Kostenzeile „aus laufenden Kosten“ */
function laufendWaehlen(k: Kostenzeile): Promise<boolean> {
return new Promise((fertig) => {
const liste = umfeld().liste;
const gewaehlt = new Set(k.laufend ?? []);
huelle.innerHTML = `<form class="dialog ss-laufend"><h2>Laufende Kosten für „${esc(k.name || "Kostenzeile")}“</h2>
${liste.length ? `<div class="ss-laufend-liste">${liste.map((l) => `<label><input type="checkbox" value="${l.id}"${gewaehlt.has(l.id) ? " checked" : ""}>
<span>${esc(l.bezeichnung)}${l.kategorie ? ` <small class="hinweis">${esc(l.kategorie)}</small>` : ""}</span><b>${eur(l.jahr)}</b></label>`).join("")}</div>`
: '<p class="hinweis">Unter Betrieb → laufende Kosten steht noch nichts.</p>'}
<p class="hinweis">Summe im Jahr ${v!.gilt_ab.slice(0, 4)}; einmalige Kosten zählen nicht. „÷ Köpfe“ und „Anteil“ gelten danach.</p>
<div class="knoepfe"><button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Übernehmen</button></div></form>`;
huelle.hidden = false;
const form = huelle.querySelector("form")!;
const zu = (ja: boolean) => { huelle.hidden = true; huelle.innerHTML = ""; fertig(ja); };
form.querySelector<HTMLElement>('[data-a="abbrechen"]')!.onclick = () => zu(false);
form.onsubmit = (ev) => {
ev.preventDefault();
k.laufend = [...form.querySelectorAll<HTMLInputElement>("input:checked")].map((x) => x.value);
zu(true);
};
});
}
// ---------- Speichern ----------
function speichernSpaeter(): void {
clearTimeout(speichernNach);
document.querySelector(".ss-gespeichert")?.replaceChildren("Speichert …");
speichernNach = setTimeout(() => void speichernJetzt(), 700);
}
async function speichernJetzt(): Promise<void> {
if (!speichernNach || !v) return;
clearTimeout(speichernNach);
speichernNach = undefined;
try {
await api(`stundensaetze/${v.id}`, "PATCH", { daten: v.daten });
document.querySelector(".ss-gespeichert")?.replaceChildren("Gespeichert");
} catch (e) {
document.querySelector(".ss-gespeichert")?.replaceChildren(`Nicht gespeichert: ${(e as Error).message}`);
}
}
window.addEventListener("hashchange", () => void speichernJetzt());