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

404
src/web/stundensaetze.ts Normal file
View File

@@ -0,0 +1,404 @@
// 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());