From 45c21943bf59230e8cdfe09b1c433a5c392b3003 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 06:55:22 +0000 Subject: [PATCH] =?UTF-8?q?Stundens=C3=A4tze=20im=20Personalmodul,=20?= =?UTF-8?q?=C3=9Cbergabe=20ans=20Angebot=20(0.26.0)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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) Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz --- CHANGELOG.md | 8 + demo/kern.ts | 2 + package.json | 2 +- src/domain/kalkulation.ts | 28 +- src/domain/stundensatz-excel.ts | 93 +++++ src/domain/stundensatz.ts | 270 +++++++++++++ src/server/angebote.ts | 41 +- src/server/anmeldung.ts | 4 +- src/server/app.ts | 2 + src/server/jahresplan.ts | 3 +- src/server/leistungen-daten.ts | 8 +- src/server/migrations/020_stundensaetze.sql | 20 + src/server/stammdaten.ts | 7 +- src/server/stundensaetze.ts | 140 +++++++ src/server/tabellen.ts | 13 +- src/web/angebote.ts | 36 +- src/web/app.ts | 5 +- src/web/mengenblatt.ts | 4 +- src/web/personal.ts | 24 +- src/web/stammdaten.ts | 4 +- src/web/stundensaetze.ts | 404 ++++++++++++++++++++ src/web/styles.css | 70 ++++ test/api.test.ts | 74 ++++ test/stundensatz.test.ts | 85 ++++ 24 files changed, 1305 insertions(+), 42 deletions(-) create mode 100644 src/domain/stundensatz-excel.ts create mode 100644 src/domain/stundensatz.ts create mode 100644 src/server/migrations/020_stundensaetze.sql create mode 100644 src/server/stundensaetze.ts create mode 100644 src/web/stundensaetze.ts create mode 100644 test/stundensatz.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 1c25499..35537b1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.26.0 + +- Personal → Stundensätze (M15–M19, Henning „super, baue das so“, 22.10.2026): je Lohnart eine Rechentabelle wie deine Excel. 1 Zeit (Arbeitstage × Std/Tag, Feiertage, Ausfallzeiten, unproduktive Zeiten mit Schalter „als Zeit abziehen“ oder „als Kosten ansetzen“) → produktive Stunden. 2 Kosten in fünf Blöcken (Lohn netto ÷ Faktor, AG-Anteile in %, indirekte Personalkosten, Sachkosten, Verwaltung) mit „÷ Köpfe“, Anteil in % und Beträgen aus den laufenden Kosten, dazu kalkulatorischer Gewinn. 3 Vollkosten-Stundensatz mit Lohnkosten und Gemeinkostenanteil, Umsatzbedarf je Person. +- Tabellen Chef, Planer, Geselle, Helfer; „+ Tabelle hinzufügen“ als Kopie einer vorhandenen (z. B. Vorarbeiter). Mittellohn mit Schalter je Lohnart, Personen aus dem Personal gezählt oder eingetragen, gewichtet nach Stunden. Nur für den Inhaber. +- „Mit meiner Excel beginnen“ legt zwei Versionen an: genau die Excel vom 26.05.2026 (Abnahme: Chef 80,38 €, Planer 107,81 €, 1.184 produktive Std, centgenau) und ab heute die Fassung nach S2 (Akquise und Verwaltung als Kosten zum Lohnkostensatz des Gesellen, 1.352 Std, Chef 72,38 €). Versionen mit „gilt ab“. +- Angebot: neue Angebote nehmen die Sätze der Version, die heute gilt, und schreiben sie fest (A36); Lohn wählbar als Mittellohn oder einzelne Lohnart, neue Lohnzeilen starten mit Mittellohn. Weil der Satz Vollkosten enthält, ist der Lohnzuschlag neuer Angebote 0 % (A37); Wagnis und Gewinn bleiben je Angebot. Gilt eine neuere Version, fragt ein Entwurf „Übernehmen“ oder „So lassen“. +- Rolle im Personal: die Lohnarten der Stundensätze (auch eigene wie Vorarbeiter). Stammdaten-Leistungen rechnen mit denselben Sätzen; die Jahresplanung zeigt den Mittellohn als Kalkulationssatz. + ## 0.25.2 - Freitag freigeben beim Planen (Henning, 22.10.2026): Wer einen Balken auf einen Freitag zieht, den rechten Rand bis Freitag zieht oder einen Freitag als Anfang oder Ende einträgt (auch am Handy), wird gefragt „Freitag … für „Vorgang“ freigeben?“. Ja gibt diesen Freitag für den Vorgang frei, Nein schiebt wie bisher auf den nächsten Arbeitstag. diff --git a/demo/kern.ts b/demo/kern.ts index 7e3b501..4185f60 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -21,6 +21,7 @@ import m016 from "../src/server/migrations/016_fahrt.sql"; import m017 from "../src/server/migrations/017_stammdaten.sql"; import m018 from "../src/server/migrations/018_freitage.sql"; import m019 from "../src/server/migrations/019_jahresplan.sql"; +import m020 from "../src/server/migrations/020_stundensaetze.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -37,6 +38,7 @@ const MIGRATIONEN: [string, string][] = [ ["017_stammdaten.sql", m017], ["018_freitage.sql", m018], ["019_jahresplan.sql", m019], + ["020_stundensaetze.sql", m020], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index 6ebec3f..228b93b 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.25.2", + "version": "0.26.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/kalkulation.ts b/src/domain/kalkulation.ts index 99eaf25..c897994 100644 --- a/src/domain/kalkulation.ts +++ b/src/domain/kalkulation.ts @@ -13,9 +13,25 @@ export type Kostenart = (typeof KOSTENARTEN)[number]; export const KOSTENART_NAME: Record = { 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 = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; +export type Lohnart = string; +export const LOHNART_NAME: Record = { 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): { 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) => (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; + stundensaetze: Record; + /** 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; 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 { diff --git a/src/domain/stundensatz-excel.ts b/src/domain/stundensatz-excel.ts new file mode 100644 index 0000000..1f20f6a --- /dev/null +++ b/src/domain/stundensatz-excel.ts @@ -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; +} diff --git a/src/domain/stundensatz.ts b/src/domain/stundensatz.ts new file mode 100644 index 0000000..46a5608 --- /dev/null +++ b/src/domain/stundensatz.ts @@ -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 = { + 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 = { + 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; +} + +/** 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; + laufend: Record; +} + +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[] = []; + 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; lohnarten: { id: string; name: string }[] } { + const stundensaetze: Record = {}; + 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)[k.rhythmus]!; +} diff --git a/src/server/angebote.ts b/src/server/angebote.ts index bbdf71d..af6952a 100644 --- a/src/server/angebote.ts +++ b/src/server/angebote.ts @@ -13,6 +13,7 @@ import type { Mengenvorlage } from "../domain/mengenvorlagen.js"; import { hatBlatt, vorlagen } from "./leistungen-daten.js"; import { plusTage } from "../domain/datum.js"; import { naechsterArbeitstag } from "../domain/kalender.js"; +import { aktuelleSaetze } from "./stundensaetze.js"; const IdParam = z.object({ id: z.uuid() }); const heute = () => new Date().toISOString().slice(0, 10); @@ -30,9 +31,11 @@ export class AngebotFehler extends Error { /** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */ export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze { - const s = (a.saetze ?? {}) as Partial>; + const s = (a.saetze ?? {}) as Partial>; return { stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) }, + ...(s.lohnarten?.length ? { lohnarten: s.lohnarten } : {}), + stundensatz_version: s.stundensatz_version ?? null, zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) }, wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent), mengen: { verschnitt: e.kalkulation.verschnitt, oeffnung_ab: e.kalkulation.oeffnungAb, ...(s.mengen ?? {}) }, @@ -205,6 +208,8 @@ export function registriereAngebote( const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear()); const k = e.kalkulation; const datum = heute(); + // M17: Sätze aus den Stundensatz-Tabellen, die heute gelten; Vollkostensatz, daher Lohnzuschlag 0 % (A37, S4) + const neue = await aktuelleSaetze(c, datum); const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined; const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`, @@ -212,7 +217,8 @@ export function registriereAngebote( vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext, vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall, // A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen - { stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum }])).rows[0]; + { stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}), + zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum }])).rows[0]; if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id); if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]); return neu; @@ -226,7 +232,36 @@ export function registriereAngebote( const e = await einstellungen(); const x = await ladeAngebot(pool, id, e); if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" }); - return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz }; + return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz, neue_stundensaetze: await neueSaetze(x) }; + }); + + /** A36: gelten heute andere Stundensätze als im Entwurf festgeschrieben, fragt die Seite, ob sie übernommen werden */ + async function neueSaetze(x: NonNullable>>) { + if (x.angebot.status !== "entwurf") return null; + const neu = await aktuelleSaetze(pool, heute()); + if (!neu) return null; + const alt = x.saetze.stundensaetze; + const gleich = neu.stundensatz_version.id === x.saetze.stundensatz_version?.id && Object.entries(neu.stundensaetze).every(([k, v]) => alt[k] === v); + return gleich ? null : neu; + } + + // neue Stundensätze in den Entwurf übernehmen; ohne Version vorher (alte Sätze aus den Einstellungen) wird der Lohnzuschlag 0 % + app.post("/api/angebote/:id/stundensaetze", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const r = await transaktion(pool, wer(req), async (c) => { + const a = (await c.query("select status, saetze from angebot where id = $1 for update", [id])).rows[0]; + if (!a) return null; + if (a.status !== "entwurf") throw new AngebotFehler("Nur Entwürfe bekommen neue Stundensätze; versendete Angebote bleiben, wie sie sind."); + const neu = await aktuelleSaetze(c, heute()); + if (!neu) throw new AngebotFehler("Es gibt noch keine Stundensätze unter Personal → Stundensätze."); + const s = a.saetze ?? {}; + const saetze = { ...s, stundensaetze: { ...s.stundensaetze, ...neu.stundensaetze }, lohnarten: neu.lohnarten, stundensatz_version: neu.stundensatz_version, + zuschlaege: s.stundensatz_version ? s.zuschlaege : { ...s.zuschlaege, lohn: 0 } }; + await c.query("update angebot set saetze = $2 where id = $1", [id, saetze]); + return saetze; + }); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return r; }); // A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“ diff --git a/src/server/anmeldung.ts b/src/server/anmeldung.ts index 77de075..36048d8 100644 --- a/src/server/anmeldung.ts +++ b/src/server/anmeldung.ts @@ -39,8 +39,8 @@ function recht(methode: string, muster: string | undefined, url: string): Recht const k = `${methode} ${muster ?? ""}`; if (OFFEN.has(k)) return "offen"; if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle"; - // Jahresplan und BWA (Stufe 5) nur für den Inhaber - if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber"; + // Jahresplan und BWA (Stufe 5) und Stundensätze (Löhne, U2) nur für den Inhaber + if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/stundensaetze") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber"; return muster ? "buero" : "inhaber"; } diff --git a/src/server/app.ts b/src/server/app.ts index 023aa0d..7f8025d 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -28,6 +28,7 @@ import { registriereUrlaub, zeitraumText } from "./urlaub.js"; import { vorlageAnwenden } from "./vorlage.js"; import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js"; import { registriereStammdaten } from "./stammdaten.js"; +import { registriereStundensaetze } from "./stundensaetze.js"; import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js"; import { planPosten } from "../domain/jahresplan.js"; import { type BezugArt, bezugsTage } from "../domain/bezug.js"; @@ -98,6 +99,7 @@ export async function baueApp(o: Optionen): Promise { registriereAngebote(app, pool, ladeEinstellungen, mitOrdner); registriereStammdaten(app, pool, ladeEinstellungen); + registriereStundensaetze(app, pool); registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() }); app.post("/api/projekte/:id/ordner", async (req, reply) => { diff --git a/src/server/jahresplan.ts b/src/server/jahresplan.ts index 47997bc..d7e17d2 100644 --- a/src/server/jahresplan.ts +++ b/src/server/jahresplan.ts @@ -1,5 +1,6 @@ // Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft). // Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist. +import { aktuelleSaetze } from "./stundensaetze.js"; import type { FastifyInstance, FastifyRequest } from "fastify"; import { z } from "zod"; import { type Client, type Pool, transaktion } from "./db.js"; @@ -101,7 +102,7 @@ export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfe const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows; return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe, - stundensatzEk: e.kalkulation.stundensaetze.geselle }; + stundensatzEk: (await aktuelleSaetze(pool, heute()))?.stundensaetze.mittellohn ?? e.kalkulation.stundensaetze.geselle }; } async function zuordnung(): Promise> { diff --git a/src/server/leistungen-daten.ts b/src/server/leistungen-daten.ts index a69f3bf..5cad8eb 100644 --- a/src/server/leistungen-daten.ts +++ b/src/server/leistungen-daten.ts @@ -1,6 +1,7 @@ // Leistungen und Mengenvorlagen aus Programm und Datenbank, mit den aktuellen Artikelpreisen aus dem Materialstamm. // Eine Kostenzeile mit Artikel nimmt immer den EK des Artikels: neue Preise rechnen die Leistungen neu, // Angebote behalten ihre Preise, weil die Kostenzeilen dort beim Einfügen festgeschrieben werden. +import type { AngebotsSaetze } from "./stundensaetze.js"; import type { Pool } from "./db.js"; import type { Einstellungen } from "./einstellungen.js"; import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js"; @@ -32,12 +33,13 @@ export async function artikelNach(c: Pick, ids: string[]): Promis return new Map(r.rows.map((a) => [a.id, { ...a, ek: a.ek === null ? null : Number(a.ek), preiseinheit: Number(a.preiseinheit), ek_je_einheit: ekJeEinheit(a) }])); } -/** Sätze der Stammdaten: Vorgaben der Angebote aus den Einstellungen */ -export function stammSaetze(e: Einstellungen): Saetze { +/** Sätze der Stammdaten: wie ein neues Angebot heute, also Stundensätze aus Personal → Stundensätze, sonst Einstellungen */ +export function stammSaetze(e: Einstellungen, neue?: AngebotsSaetze | null): Saetze { const k = e.kalkulation; return { - stundensaetze: { ...k.stundensaetze }, zuschlaege: { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall, + stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, + ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}), }; } diff --git a/src/server/migrations/020_stundensaetze.sql b/src/server/migrations/020_stundensaetze.sql new file mode 100644 index 0000000..372de60 --- /dev/null +++ b/src/server/migrations/020_stundensaetze.sql @@ -0,0 +1,20 @@ +-- Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026): Versionen mit „gilt ab“, je Version die +-- Rechentabellen aller Lohnarten und die Mittellohn-Auswahl als JSON. Ein Angebot nimmt die Version, die an +-- seinem Datum gilt, und schreibt die Sätze fest (A36). +create table stundensatz_version ( + id uuid primary key default gen_random_uuid(), + name text not null check (trim(name) <> ''), + gilt_ab date not null unique, + daten jsonb not null default '{}', + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create trigger stundensatz_version_protokoll before insert or update or delete on stundensatz_version + for each row execute function stempel_und_protokoll(); + +-- Lohnarten sind jetzt die Rechentabellen (Chef, Planer, Geselle, Helfer, eigene) und der Mittellohn +alter table angebot_kosten drop constraint angebot_kosten_lohnart_check; +alter table angebot_kosten add constraint angebot_kosten_lohnart_check check (lohnart ~ '^[a-z0-9-]{1,40}$'); +alter table mitarbeiter drop constraint mitarbeiter_funktion_check; +alter table mitarbeiter add constraint mitarbeiter_funktion_check check (funktion ~ '^[a-z0-9-]{1,40}$'); diff --git a/src/server/stammdaten.ts b/src/server/stammdaten.ts index cc3ef28..e1148a2 100644 --- a/src/server/stammdaten.ts +++ b/src/server/stammdaten.ts @@ -1,5 +1,6 @@ // Stammdaten (Henning, 21.10.2026): Leistungen mit Vorkalkulation, GAEB-Import in Ordner, Materialstamm mit // DATANORM-Import und Rabatten je Lieferant. Siehe Entwürfe 1–4 in stammdaten/entwurf. +import { aktuelleSaetze } from "./stundensaetze.js"; import type { FastifyInstance, FastifyRequest } from "fastify"; import { z } from "zod"; import { type Pool, transaktion } from "./db.js"; @@ -38,7 +39,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell /** Leistungen mit Kosten, VK und Stunden je Einheit (Liste und Katalog im Angebot) */ app.get("/api/leistungen", async () => { - const s = stammSaetze(await einstellungen()); + const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10))); return nurLeistungen(await vorlagen(pool)).map((v) => { const r = rechneLeistung(v, s); return { @@ -56,7 +57,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell const { id } = IdParam.parse(req.params); const v = (await vorlagen(pool)).find((x) => String(x.id) === id); if (!v) return reply.status(404).send({ fehler: "Diese Leistung gibt es nicht (mehr)." }); - const s = stammSaetze(await einstellungen()); + const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10))); const artikel = Object.fromEntries(await artikelNach(pool, (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x))); const angebote = (await pool.query(`select a.id, a.nummer, a.datum from angebot_position p join angebot a on a.id = p.angebot_id where p.aufmass -> 'vorlage' ->> 'id' = $1 order by a.datum desc, a.nummer desc`, [id])).rows; @@ -99,7 +100,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell ordner: z.string().trim().min(1).max(300).optional(), prozent: z.number().min(-90).max(500).optional(), }).parse(req.body ?? {}); - const s = stammSaetze(await einstellungen()); + const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10))); const alle = new Map((await vorlagen(pool)).map((v) => [String(v.id), v])); const gewaehlt = q.ids.map((i) => alle.get(i)).filter((v): v is Mengenvorlage => !!v); const eigene = gewaehlt.filter((v) => !v.fest); diff --git a/src/server/stundensaetze.ts b/src/server/stundensaetze.ts new file mode 100644 index 0000000..9f6f41e --- /dev/null +++ b/src/server/stundensaetze.ts @@ -0,0 +1,140 @@ +// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026). Nur der Inhaber sieht Löhne und Sätze (U2); +// die Namen der Lohnarten (/api/lohnarten) braucht auch das Büro für Personal und Kalkulation. +import type { FastifyInstance, FastifyRequest } from "fastify"; +import { z } from "zod"; +import { type Client, type Pool, transaktion } from "./db.js"; +import { werName } from "./anmeldung.js"; +import { type Block, KOSTENARTEN_S, MITTELLOHN, type StundensatzDaten, type Umfeld, laufendImJahr, rechneStundensaetze, saetzeFuerAngebot } from "../domain/stundensatz.js"; +import { stundensaetzeAusExcel, stundensaetzeNachS2 } from "../domain/stundensatz-excel.js"; +import type { Cent } from "../domain/geld.js"; + +const schluessel = z.string().regex(/^[a-z0-9-]{1,40}$/).refine((s) => s !== MITTELLOHN, "„mittellohn“ ist vergeben"); +const kurz = z.string().trim().max(120); +const zahl = z.number().min(0).max(1e7); +const cent = z.number().int().min(0).max(10_000_000_000); +const kleineId = z.string().min(1).max(40); + +export const DatenSchema = z.object({ + tabellen: z.array(z.object({ + id: schluessel, + name: kurz.min(1), + hinweis: z.string().max(500).optional(), + zeit: z.object({ + stundenTag: z.number().min(0).max(24), tageJahr: z.number().min(0).max(366), feiertage: z.number().min(0).max(366), + ausfall: z.array(z.object({ id: kleineId, name: kurz, tage: z.number().min(0).max(366) })).max(30), + unproduktiv: z.array(z.object({ id: kleineId, name: kurz, stunden: z.number().min(0).max(744), je: z.enum(["monat", "tag"]), als: z.enum(["zeit", "kosten"]) })).max(30), + }), + kosten: z.array(z.object({ + id: kleineId, block: z.number().int().min(1).max(5).transform((b) => b as Block), + name: kurz, art: z.enum(KOSTENARTEN_S), betrag: cent.optional(), faktor: z.number().min(0.01).max(10).optional(), prozent: z.number().min(0).max(1000).optional(), + stunden: z.number().min(0).max(744).optional(), laufend: z.array(z.uuid()).max(200).optional(), koepfe: z.boolean().optional(), + anteil: z.number().min(0).max(1000).optional(), notiz: z.string().max(300).optional(), + })).max(100), + gewinn: z.number().min(0).max(100), lohnanteil: z.number().min(1).max(100), wagnis: z.number().min(0).max(50), + })).min(1).max(30).refine((t) => new Set(t.map((x) => x.id)).size === t.length, "Jede Tabelle braucht einen eigenen Schlüssel"), + koepfe: zahl.min(1).max(500).nullable(), + bewertung: z.string().max(40), + mittellohn: z.record(z.string().max(40), z.object({ an: z.boolean(), personen: z.number().min(0).max(500).nullable() })), +}); + +const Datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/); +const IdParam = z.object({ id: z.uuid() }); + +type Abfrage = Pick; + +/** Köpfe und Personen je Lohnart aus dem Personal (heute beschäftigt): der Inhaber ohne Rolle zählt als Chef, + * Angestellte ohne Rolle als Geselle. Laufende Kosten als Jahressumme im angegebenen Jahr. */ +export async function umfeldLaden(c: Abfrage, jahr: number, heute: string): Promise { + const leute = (await c.query(`select coalesce(funktion, case when angestellt then 'geselle' else 'chef' end) as lohnart, count(*)::int as n from mitarbeiter + where (eintritt is null or eintritt <= $1) and (austritt is null or austritt >= $1) group by 1`, [heute])).rows; + const personen = Object.fromEntries(leute.map((r) => [r.lohnart as string, r.n as number])); + const lk = (await c.query("select id, bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten order by kategorie nulls last, bezeichnung")).rows; + const liste = lk.map((l) => ({ id: l.id as string, bezeichnung: l.bezeichnung as string, kategorie: (l.kategorie ?? null) as string | null, jahr: laufendImJahr({ ...l, betrag: Number(l.betrag) }, jahr) })); + return { koepfe: Math.max(1, leute.reduce((s, r) => s + (r.n as number), 0)), personen, laufend: Object.fromEntries(liste.map((l) => [l.id, l.jahr])), liste }; +} + +/** Version, die an diesem Tag gilt */ +async function geltende(c: Abfrage, datum: string) { + return (await c.query("select id, name, gilt_ab, daten from stundensatz_version where gilt_ab <= $1 order by gilt_ab desc limit 1", [datum])).rows[0] as + { id: string; name: string; gilt_ab: string; daten: StundensatzDaten } | undefined; +} + +export interface AngebotsSaetze { stundensaetze: Record; lohnarten: { id: string; name: string }[]; stundensatz_version: { id: string; name: string; gilt_ab: string } } + +/** Sätze für ein neues Angebot (A36) aus der Version, die am Datum gilt; ohne Version null (dann die Einstellungen) */ +export async function aktuelleSaetze(c: Abfrage, datum: string): Promise { + const v = await geltende(c, datum); + if (!v) return null; + const u = await umfeldLaden(c, Number(v.gilt_ab.slice(0, 4)), datum); + return { ...saetzeFuerAngebot(rechneStundensaetze(v.daten, u)), stundensatz_version: { id: v.id, name: v.name, gilt_ab: v.gilt_ab } }; +} + +export function registriereStundensaetze(app: FastifyInstance, pool: Pool): void { + const wer = (req: FastifyRequest) => werName(req); + const heute = () => new Date().toISOString().slice(0, 10); + const zeile = (r: Record) => ({ id: r.id, name: r.name, gilt_ab: r.gilt_ab, daten: r.daten as StundensatzDaten, geaendert_am: r.geaendert_am }); + + app.get("/api/stundensaetze", async () => { + const versionen = (await pool.query("select * from stundensatz_version order by gilt_ab")).rows.map(zeile); + const gilt = await geltende(pool, heute()); + const jahre = [...new Set(versionen.map((v) => Number(v.gilt_ab.slice(0, 4))).concat(Number(heute().slice(0, 4))))]; + const umfeld: Record>> = {}; + for (const j of jahre) umfeld[j] = await umfeldLaden(pool, j, heute()); + const personal = (await pool.query(`select k.name, m.funktion, m.angestellt from mitarbeiter m join kontakt k on k.id = m.kontakt_id + where (m.eintritt is null or m.eintritt <= $1) and (m.austritt is null or m.austritt >= $1) order by k.name`, [heute()])).rows; + return { versionen, gilt: gilt?.id ?? null, umfeld, personal, heute: heute() }; + }); + + // Lohnarten für Rolle im Personal und Auswahl in der Kalkulation: Tabellen der heute geltenden Version + app.get("/api/lohnarten", async () => { + const v = await geltende(pool, heute()); + const tabellen = v?.daten.tabellen.map((t) => ({ id: t.id, name: t.name })) ?? []; + return tabellen.length ? tabellen : [{ id: "planer", name: "Planer" }, { id: "geselle", name: "Geselle" }, { id: "helfer", name: "Helfer" }]; + }); + + const Neu = z.object({ name: kurz.min(1), gilt_ab: Datum, daten: DatenSchema }); + app.post("/api/stundensaetze", async (req, reply) => { + const q = Neu.parse(req.body); + const r = await transaktion(pool, wer(req), async (c) => { + if ((await c.query("select 1 from stundensatz_version where gilt_ab = $1", [q.gilt_ab])).rowCount) return null; + return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *", [q.name, q.gilt_ab, q.daten])).rows[0]; + }); + if (!r) return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." }); + return reply.status(201).send(zeile(r)); + }); + + // M19: erste Fassung aus Hennings Excel (gilt ab 26.05.2026) und die Fassung nach S2 (gilt ab heute) + app.post("/api/stundensaetze/excel", async (req, reply) => { + const r = await transaktion(pool, wer(req), async (c) => { + if ((await c.query("select 1 from stundensatz_version limit 1")).rowCount) return null; + const excel = stundensaetzeAusExcel(); + await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3)", ["Excel 26.05.2026", "2026-05-26", excel]); + const ab = heute() > "2026-05-26" ? heute() : "2026-05-27"; + return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *", + ["Akquise und Verwaltung als Kosten", ab, stundensaetzeNachS2(excel)])).rows[0]; + }); + if (!r) return reply.status(409).send({ fehler: "Es gibt schon Stundensätze." }); + return reply.status(201).send(zeile(r)); + }); + + const Aenderung = z.object({ name: kurz.min(1).optional(), gilt_ab: Datum.optional(), daten: DatenSchema.optional() }); + app.patch("/api/stundensaetze/:id", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const q = Aenderung.parse(req.body); + const r = await transaktion(pool, wer(req), async (c) => { + if (q.gilt_ab && (await c.query("select 1 from stundensatz_version where gilt_ab = $1 and id <> $2", [q.gilt_ab, id])).rowCount) return "doppelt" as const; + return (await c.query(`update stundensatz_version set name = coalesce($2, name), gilt_ab = coalesce($3, gilt_ab), daten = coalesce($4, daten) + where id = $1 returning *`, [id, q.name ?? null, q.gilt_ab ?? null, q.daten ?? null])).rows[0]; + }); + if (r === "doppelt") return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." }); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return zeile(r); + }); + + app.delete("/api/stundensaetze/:id", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const r = await transaktion(pool, wer(req), (c) => c.query("delete from stundensatz_version where id = $1", [id])); + if (!r.rowCount) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return reply.status(204).send(); + }); +} diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 2e985ab..795dc28 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -25,7 +25,7 @@ const blatt = z.object({ // Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position const ansatz = z.object({ kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]), - lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), + lohnart: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(), beschreibung: z.string().max(300).nullable().optional(), bezug: kurzeFormel.nullable().optional(), menge: z.number().min(0).max(1e9), @@ -147,7 +147,10 @@ export const TABELLEN: Tabelle[] = [ gewinn_prozent: z.number().min(0).max(50).optional(), ausfall_prozent: z.number().min(0).max(50).optional(), saetze: z.object({ - stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(), + stundensaetze: z.record(z.string().regex(/^[a-z0-9-]{1,40}$/), cent.min(0)).optional(), + // Lohnarten aus den Stundensatz-Tabellen und die Version, aus der die Sätze stammen (M17) + lohnarten: z.array(z.object({ id: z.string().regex(/^[a-z0-9-]{1,40}$/), name: z.string().max(120) })).max(40).optional(), + stundensatz_version: z.object({ id: z.string().max(40), name: z.string().max(120), gilt_ab: datum }).nullable().optional(), zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), fahrt: z.number().min(0).max(500), subunternehmer: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(), kilometersatz: z.number().int().min(0).optional(), mengen: z.object({ verschnitt: z.number().min(0).max(100), oeffnung_ab: z.number().min(0).max(100) }).partial().optional(), @@ -198,7 +201,7 @@ export const TABELLEN: Tabelle[] = [ schema: z.object({ position_id: id, kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]), - lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), + lohnart: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(), beschreibung: optText, menge: z.number().min(0).max(1e9).optional(), einheit: optText, @@ -425,7 +428,7 @@ export const TABELLEN: Tabelle[] = [ angestellt: z.boolean().optional(), lohn_cent: cent.min(0).nullable().optional(), urlaubstage: z.number().min(0).max(60).optional(), - funktion: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), + funktion: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(), }), }, { @@ -477,4 +480,6 @@ export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] { name: "jahresplan", pfad: "jahresplaene", sortierung: "jahr, basis desc, angelegt_am" }, { name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" }, { name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" }, + // Stundensätze im Personalmodul (M15–M19) + { name: "stundensatz_version", pfad: "stundensatz_versionen", sortierung: "gilt_ab" }, ]; diff --git a/src/web/angebote.ts b/src/web/angebote.ts index 501f2ad..31c7f11 100644 --- a/src/web/angebote.ts +++ b/src/web/angebote.ts @@ -4,7 +4,7 @@ // Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19). import { formatEuro, parseEuro } from "../domain/geld.js"; -import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME, umgebungVon } from "../domain/kalkulation.js"; +import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, POSITIONSARTEN, POSITIONSART_NAME, lohnartOptionen, lohnartenVon, standardLohnart, umgebungVon } from "../domain/kalkulation.js"; import { benenneUm, zahlDeutsch } from "../domain/formel.js"; import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js"; import type { Mengenvorlage } from "../domain/mengenvorlagen.js"; @@ -240,7 +240,7 @@ async function editor(id: string, gross: string | null): Promise { } if (pfad === "saetze") { // Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben - const s: Zeile = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, kilometersatz: d.saetze.kilometersatz, stand: d.angebot.saetze?.stand ?? heute() }; + const s: Zeile = { stundensaetze: { ...d.saetze.stundensaetze }, lohnarten: d.saetze.lohnarten, stundensatz_version: d.saetze.stundensatz_version ?? null, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, kilometersatz: d.saetze.kilometersatz, stand: d.angebot.saetze?.stand ?? heute() }; if (zid === "km") s.kilometersatz = wert ?? 0; else s[zid][feld] = wert ?? 0; return api(`angebote/${id}`, "PATCH", { saetze: s }); @@ -249,7 +249,7 @@ async function editor(id: string, gross: string | null): Promise { if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null }; if (pfad === "angebot-kosten" && feld === "kostenart") { const kz = d.kosten.find((x: Zeile) => x.id === zid); - body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? "geselle" : null, + body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? standardLohnart(d.saetze) : null, ...(wert === "lohn" ? { einheit: "h" } : wert === "fahrt" ? { einheit: "km" } : ["h", "km"].includes(kz?.einheit) ? { einheit: null } : {}) }; } return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body); @@ -515,6 +515,8 @@ async function editor(id: string, gross: string | null): Promise { merkeTab(p.id, "kalk"); return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`); } + if (a === "saetze-neu") { await api(`angebote/${id}/stundensaetze`, "POST"); return neuLaden("Die neuen Stundensätze gelten jetzt in diesem Angebot."); } + if (a === "saetze-alt") { SAETZE_SO_LASSEN.add(`${id}:${d.neue_stundensaetze?.stundensatz_version.id}`); return zeichne(); } if (a === "vorlage") return await einfuegen("vorlage", z.aktiv ?? z.ziel, zid, b.dataset.in); if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; } if (a === "als-vorlage") return await alsVorlage(zid); @@ -523,7 +525,7 @@ async function editor(id: string, gross: string | null): Promise { const p = pos(zid)!; const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null; const fahrt = art === "fahrt"; - const k = await api("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1, + const k = await api("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? standardLohnart(d.saetze) : null, menge: art === "lohn" ? 0.1 : 1, beschreibung: fahrt ? "Fahrt zur Baustelle" : null, bezug: fahrt ? null : blatt?.menge?.trim() || null, einheit: art === "lohn" ? "h" : fahrt ? "km" : p.einheit ?? null, reihenfolge: kostenVon(zid).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) }); z.auf.add(`${zid}:${art}`); @@ -667,7 +669,7 @@ function handyHtml(d: Zeile, meldung: string): string { return `
←

${esc(a.nummer)} ${esc(a.projekt_name)}

${angebotMarke(a)}
- ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""} + ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""}${neueSaetzeHtml(d)}

Am Handy: ansehen, Mengen und Preise ändern, freigeben. Kalkulation und Vorlagen bearbeiten am PC.

${lv || '

Noch keine Positionen.

'}
Netto${euro(e.netto)}
Brutto${euro(e.brutto)}
@@ -739,7 +741,7 @@ function kostenTabelle(d: Zeile, p: Zeile, frei: boolean, auf?: Set): st ${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-ansatz am-eingabe", titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", platz: fahrt ? "Tage" : "", spalte: `km-${p.id}` })} ${mitPers ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: fahrt ? "Fahrzeuge" : "Personen" }) : ""} ${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}${lohn ? " h" : fahrt ? " km" : ""} - ${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : fahrt ? "" : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })} + ${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, lohnartOptionen(lohnartenVon(s), k.lohnart), k.lohnart ?? "geselle", "Lohnart") : fahrt ? "" : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })} ${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-ek", leer: "null", titel: fahrt ? "Kosten je km" : "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00", spalte: `ke-${p.id}` })} ${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })} ${betrag(z.kosten * menge)} @@ -959,7 +961,8 @@ function kiHtml(z: Zustand, leistungen: Zeile[]): string { function vorgabenHtml(d: Zeile, frei: boolean): string { const a = d.angebot, s = d.saetze; const feld = feldBau(frei); - return `
Stundensätze (EK)${LOHNARTEN.map((x) => ``).join("")} + const v = s.stundensatz_version; + return `
Stundensätze (EK)${lohnartenVon(s).map((x) => ``).join("")} Zuschläge${KOSTENARTEN.map((x) => ``).join("")} Wagnis und Gewinn @@ -969,7 +972,22 @@ function vorgabenHtml(d: Zeile, frei: boolean): string { Mengen
-

Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.

`; +

${v ? `Stundensätze aus „${esc(v.name)}“ (gilt ab ${dat(v.gilt_ab)}), Vollkosten: der Lohnzuschlag enthält nur noch, was du dazuschlagen willst; Wagnis und Gewinn kommen oben dazu.` + : `Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen.`} Hier je Angebot änderbar.

`; +} + +/** A36: gelten heute andere Stundensätze, fragt das Angebot, ob es sie übernehmen soll */ +const SAETZE_SO_LASSEN = new Set(); +function neueSaetzeHtml(d: Zeile): string { + const n = d.neue_stundensaetze; + if (!n || SAETZE_SO_LASSEN.has(`${d.angebot.id}:${n.stundensatz_version.id}`)) return ""; + const alt = d.saetze.stundensaetze as Record; + const wichtig = (n.lohnarten as { id: string; name: string }[]).filter((x) => alt[x.id] !== n.stundensaetze[x.id]) + .sort((a, b) => Number(b.id === "mittellohn") - Number(a.id === "mittellohn") || Number(alt[b.id] != null) - Number(alt[a.id] != null)).slice(0, 3) + .map((x) => `${esc(x.name)} ${betrag(n.stundensaetze[x.id])} €${alt[x.id] != null ? ` statt ${betrag(alt[x.id]!)} €` : ""}`).join(", "); + return `
Seit ${dat(n.stundensatz_version.gilt_ab)} gelten neue Stundensätze („${esc(n.stundensatz_version.name)}“)${wichtig ? `: ${wichtig}` : ""}. + ${d.saetze.stundensatz_version ? "" : " Der Lohnzuschlag wird dann 0 %, weil der Satz die Gemeinkosten schon enthält."} +
`; } const pruefungListe = (d: Zeile) => (d.pruefung.length @@ -1063,7 +1081,7 @@ function titelleiste(d: Zeile, meldung: string): string { return `
←

${esc(BELEGART[a.belegart])} ${esc(a.nummer)} · ${esc(a.projekt_name)}

${angebotMarke(a)} ${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}
- ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""}`; + ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""}${neueSaetzeHtml(d)}`; } /** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */ diff --git a/src/web/app.ts b/src/web/app.ts index 92ca68c..dab7dc8 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -890,7 +890,7 @@ async function daten(): Promise { const kalkFelder: Feld[] = [ { name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" }, { name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" }, - { name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Gilt für neue Angebote. Die genauen Sätze kommen aus deiner Stundensatz-Tabelle." }, + { name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Nur solange unter Personal → Stundensätze keine Version gilt; dann kommen die Sätze von dort und der Lohnzuschlag neuer Angebote ist 0 %." }, { name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" }, { name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_subunternehmer", titel: "Zuschlag Subunternehmer (%)", art: "zahl" }, { name: "z_fahrt", titel: "Zuschlag Fahrt (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" }, @@ -1121,7 +1121,7 @@ async function zeige(): Promise { const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1]; const mitarbeiter = /^mitarbeiter-([0-9a-f-]{36})$/.exec(id)?.[1]; // Personal mit Reitern, Kolonne und Subunternehmer (0.15) - const personalTeil = /^personal-(kolonnen|subunternehmer|urlaub|zeiten)$/.exec(id)?.[1]; + const personalTeil = /^personal-(kolonnen|subunternehmer|urlaub|zeiten|stundensaetze)$/.exec(id)?.[1]; const kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1]; const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1]; const zuPersonal = mitarbeiter || personalTeil || kolonne || sub; @@ -1173,6 +1173,7 @@ async function start(): Promise { sitzung = s; abgemeldet.melden = () => { location.hash = ""; location.reload(); }; document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter"); + document.body.classList.toggle("rolle-inhaber", s.benutzer.rolle === "inhaber"); REITER = reiterFuer(s); nav.innerHTML = REITER.map(([id, titel]) => ``).join(""); werLeiste(s); diff --git a/src/web/mengenblatt.ts b/src/web/mengenblatt.ts index f7806a3..3dce7e7 100644 --- a/src/web/mengenblatt.ts +++ b/src/web/mengenblatt.ts @@ -6,7 +6,7 @@ import { benenneUm, FUNKTIONEN, zahlDeutsch } from "../domain/formel.js"; import { type Auswertung, type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js"; import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js"; import { formatEuro, parseEuro } from "../domain/geld.js"; -import { KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js"; +import { KOSTENARTEN, KOSTENART_NAME, VORLAGE_LOHNARTEN, lohnartOptionen, umgebungVon } from "../domain/kalkulation.js"; import { type Zeile, api, bestaetigen, dialog, esc, hinweis, inhalt, istHandy, optionenHtml } from "./ui.js"; export const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ",")); @@ -284,7 +284,7 @@ function ansaetzeHtml(v: Mengenvorlage, a: Auswertung, frei: boolean): string { } catch (e) { fehler = (e as Error).message; } const k = (f: string) => `vb:ansaetze.${i}.${f}`; return ` - ${lohn ? `` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })} + ${lohn ? `` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })} ${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })} ${feld(k("menge"), zahlText(z.menge), { klasse: "am-eingabe zahl w-menge", titel: lohn ? "Std je Einheit des Bezugs" : "Menge je Einheit des Bezugs", frei })} ${lohn ? feld(k("personen"), zahlText(z.personen ?? 1), { klasse: "am-eingabe zahl w-kurz", titel: "Personen", frei }) : feld(k("faktor"), zahlText(z.faktor ?? 1), { klasse: "zahl w-kurz", titel: "Faktor", frei })} diff --git a/src/web/personal.ts b/src/web/personal.ts index 6214684..7ca4843 100644 --- a/src/web/personal.ts +++ b/src/web/personal.ts @@ -7,6 +7,7 @@ import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/per import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js"; import { liste as tabelle } from "./liste.js"; import { entscheiden } from "./urlaub.js"; +import { stundensaetzeTeil } from "./stundensaetze.js"; const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; const zahl = (h: number | null | undefined) => (h == null ? "" : String(Math.round(h * 100) / 100).replace(".", ",")); @@ -26,10 +27,17 @@ function heuteText(t: Zeile | undefined): string { return `${zahl(t.soll)} Std.`; } -const FUNKTION: Record = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; -const FUNKTIONEN = Object.entries(FUNKTION) as [string, string][]; -// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026) -const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"]]; +// Rolle = Lohnart der Stundensätze (M17): die Tabellen der heute geltenden Version, sonst Planer, Geselle, Helfer +const FUNKTION: Record = { chef: "Chef", planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; +let FUNKTIONEN = Object.entries(FUNKTION).filter(([k]) => k !== "chef") as [string, string][]; +async function rollenLaden(): Promise { + const l = await api<{ id: string; name: string }[]>("lohnarten").catch(() => null); + if (!l) return; + for (const x of l) FUNKTION[x.id] = x.name; + FUNKTIONEN = l.map((x) => [x.id, x.name]); +} +// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026); Stundensätze nur für den Inhaber (U2) +const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"], ["stundensaetze", "Stundensätze"]]; const subName = (k: Zeile) => (k.firma?.trim() ? k.firma : k.name) as string; const prozent = (n: number | null | undefined) => (n == null ? "" : `${String(Number(n)).replace(".", ",")} %`); /** Stunden pro Arbeitstag Mo–Do aus dem Arbeitszeitmodell (Woche Mo … So) */ @@ -38,7 +46,8 @@ const tagesStunden = (stunden: number[] | undefined, vorgabe: number) => (stunde function teileLeiste(aktiv: string): void { const kopf = document.createElement("div"); kopf.className = "teile-kopf personal-teile"; - kopf.innerHTML = ``; + const inhaber = document.body.classList.contains("rolle-inhaber"); + kopf.innerHTML = ``; kopf.addEventListener("click", (ev) => { const t = (ev.target as HTMLElement).closest("[data-teil]")?.dataset.teil; if (t) location.hash = t === "mitarbeiter" ? "personal" : `personal-${t}`; @@ -58,7 +67,9 @@ export async function personalSeite(teil = "mitarbeiter"): Promise { if (teil === "subunternehmer") return subunternehmerTeil(); if (teil === "urlaub") return urlaubTeil(); if (teil === "zeiten") return zeitenTeil(); - const [liste, tp, kolonnen, mitglieder] = await Promise.all([ + if (teil === "stundensaetze") return stundensaetzeTeil(teileLeiste); + const [, liste, tp, kolonnen, mitglieder] = await Promise.all([ + rollenLaden(), api(`personal?heute=${heute()}`), api("terminplan"), api("kolonnen"), api("kolonnen-mitglieder"), ]); seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter }); @@ -485,6 +496,7 @@ async function neuerMitarbeiter(): Promise { export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise { const jahr = Number(heute().slice(0, 4)); const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10); + await rollenLaden(); const [kontakt, liste, alleStamm, modelle, abw, konten, verf, kolonnen, mitglieder] = await Promise.all([ api(`kontakte/${kontaktId}`), api(`personal?heute=${heute()}`), diff --git a/src/web/stammdaten.ts b/src/web/stammdaten.ts index c1591b2..47591cc 100644 --- a/src/web/stammdaten.ts +++ b/src/web/stammdaten.ts @@ -5,7 +5,7 @@ import { type Auswertung, alsBlatt, werteBlatt } from "../domain/mengenblatt.js"; import type { Ansatz, Mengenvorlage } from "../domain/mengenvorlagen.js"; import { formatEuro, parseEuro } from "../domain/geld.js"; -import { KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js"; +import { KOSTENARTEN, KOSTENART_NAME, lohnartOptionen, lohnartenVon, umgebungVon } from "../domain/kalkulation.js"; import { zahlDeutsch } from "../domain/formel.js"; import { dateiText } from "../domain/kodierung.js"; import { type Datanorm, ekNetto, leseDatanorm } from "../domain/datanorm.js"; @@ -269,7 +269,7 @@ export async function leistungSeite(id: string): Promise { ${feld(k("bezug"), z.bezug, { titel: fahrt ? "Strecke einfach in km" : "Bezug (Kürzel aus dem Mengenblatt, leer = je Einheit)", klasse: `am-formel w-bezug${r?.fehler ? " mit-fehler" : ""}`, platz: fahrt ? "km" : `je ${einheit}`, liste: "sd-kuerzel" })}${r?.fehler ? `${esc(r.fehler)}` : ""} ${feld(k("menge"), zahlText(z.menge), { titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", klasse: "zahl w-ansatz am-eingabe", typ: "zahl" })} ${mitPers ? feld(k("personen"), zahlText(z.personen ?? 1), { titel: fahrt ? "Fahrzeuge" : "Personen", klasse: "zahl w-pers am-eingabe", typ: "zahl" }) : ""} - ${lohn ? `` + ${lohn ? `` : fahrt ? "km" : feld(k("einheit"), z.einheit, { titel: "Einheit", klasse: "w-einheit", liste: "sd-einheiten" })} ${feld(k("ek"), z.artikel_id ? euroFeld(art?.ek_je_einheit ?? z.ek) : euroFeld(z.ek), { titel: z.artikel_id ? "EK aus dem Materialstamm (ändern löst den Artikel)" : "EK je Einheit", klasse: "zahl w-ek", typ: "euro", platz: lohn ? euroFeld(s.stundensaetze[z.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00" })} diff --git a/src/web/stundensaetze.ts b/src/web/stundensaetze.ts new file mode 100644 index 0000000..f0a7223 --- /dev/null +++ b/src/web/stundensaetze.ts @@ -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 | 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 { + teile = kopf; + d = await api("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 = '

Personal

'; + 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 = ` + `; + 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 = `

Noch keine Stundensätze

+

Das Programm rechnet je Lohnart wie deine Excel-Tabelle: Zeit, Kosten, Stundensatz. Am einfachsten beginnst du mit deiner Excel vom 26.05.2026.

+

Es entstehen zwei Versionen: genau deine Excel (Chef 80,38 €, Planer 107,81 €) und ab heute 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.

+ `; + inhalt.append(k); + k.querySelector('[data-a="excel"]')!.onclick = async () => { + const neu = await api("stundensaetze/excel", "POST"); + merke("ss-version", neu.id); + void stundensaetzeTeil(teile); + }; +} + +async function leisteKlick(ev: Event): Promise { + const b = (ev.target as HTMLElement).closest("[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("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 { + const w: Record = {}; + 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 = {}; +const w = (k: string, klasse = "") => `${esc(W[k] ?? "")}`; +const ein = (f: string, wert: string, o: { t?: string; klasse?: string; titel: string; platz?: string } ) => + ``; +const wahl = (f: string, optionen: [string, string][], wert: string, titel: string) => + ``; + +function zeichne(): void { + const raster = inhalt.querySelector(".ss-raster")!; + const e = rechne(); + W = werte(e); + const t = tabelle(), te = e.tabellen.find((x) => x.id === t.id)!; + raster.innerHTML = ` +
${tabelleHtml(t, te, e)}
+
${mittellohnHtml(e)}
+

So kommt es ins Angebot

+

In der Kalkulation einer Position wählst du bei Lohn: Mittellohn · ${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.

+

Ein Angebot schreibt die Sätze beim Anlegen fest. Gilt später eine neue Version, fragt der Entwurf, ob er sie übernehmen soll.

`; + verbinden(raster); +} + +function linksHtml(e: StundensatzErgebnis): string { + return `

Rechentabellen

${e.tabellen.map((t) => + ``).join("")}
+ +

Ergebnis

+
Mittellohn${w("ml.satz")}
+
Umsatzbedarf im Jahr${w("ub.jahr")}
+
je Monat${w("ub.monat")}
+

Jede Tabelle ist aufgebaut wie dein Excel-Blatt; eine neue startet als Kopie einer vorhandenen.

`; +} + +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) => `${ein(`a.${a.id}.name`, a.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })} + ${ein(`a.${a.id}.tage`, zahlWert(a.tage), { titel: `${a.name}: Tage im Jahr` })} Tage/Jahr${w(`a.${a.id}.std`)}${w(`a.${a.id}.tage`)} + `).join(""); + const unprod = z.unproduktiv.map((u) => `${ein(`u.${u.id}.name`, u.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })} + ${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")} + ${w(`u.${u.id}.std`)}${w(`u.${u.id}.tage`)} + `).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 `${esc(x.name)}${w(`k.${x.id}.rechnung`)} (aus 1 Zeit) + ${w(`k.${x.id}.jahr`)}${w(`k.${x.id}.monat`)}${w(`k.${x.id}.std`)}${w(`k.${x.id}.anteil`)}`; + return `${ein(`k.${k.id}.name`, k.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}${ansatzHtml(k)} + ${w(`k.${k.id}.jahr`)}${w(`k.${k.id}.monat`)}${w(`k.${k.id}.std`)}${w(`k.${k.id}.anteil`)} + `; + }).join(""); + return `${b} ${esc(BLOCK_NAME[b])}${zeilen} + + Zwischensumme ${b}${w(`b.${b}.jahr`)}${w(`b.${b}.monat`)}${w(`b.${b}.std`)} + ${b === 3 ? `= Lohnkosten je Std (ohne Betriebskosten)${w("t.lohnkostensatz")}` : ""}`; + }).join(""); + return `

Rechentabelle ${ein("t.name", t.name, { t: "text", klasse: "ss-titel", titel: "Name der Lohnart" })}

+ ${v!.daten.tabellen.length > 1 ? `` : ""}
+ ${t.hinweis ? `

${esc(t.hinweis)}

` : ""} +
+ + + + + + ${ausfall} + + ${unprod} + +
1 ZeitAnsatzStdTage
Arbeitstage im Jahr${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${w("z.brutto")}${w("z.tageJahr")}
− Feiertage SH${ein("z.feiertage", zahlWert(z.feiertage), { titel: "Feiertage im Jahr" })} Tage + Kalender ${kal.jahr}: ${kal.werktage} Werktage, ${kal.feiertage} Feiertage auf Mo–Fr ${w("z.feiertage")}${w("z.feiertageTage")}
= Jahresarbeitszeit${w("z.jahresStd")}${w("z.jahresTage")}
= Anwesenheit${w("z.ausfallStd")}${w("z.anwesend")}
= produktive Stunden${w("z.produktiv")}${w("z.produktivTage")}
+
+ ${kosten} + + + + +
2 KostenAnsatz€ / Jahr€ / Monat€ / StdAnteil
kalkulatorischer Gewinn${ein("t.gewinn", zahlWert(t.gewinn), { titel: "Gewinn in % der Kosten" })} %${w("t.gewinn")}
3 Stundensatz ${w("t.name")} (Vollkosten) ${w("t.summe")} im Jahr ÷ ${w("z.produktiv")} produktive Std${w("t.summe")}${w("t.summeMonat")}${w("t.satz")}
davon Lohnkosten / Gemeinkostenanteil${w("t.lohnkostensatz")} / ${w("t.gemein")}
+

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 %" })} % + → ${w("t.umsatz")} im Jahr, ${w("t.umsatzMonat")} im Monat

+

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 ?? "–")}.

`; +} + +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: ``, + }[k.art]; + return `
${wahl(f("art"), KOSTENARTEN_S.map((x) => [x, KOSTENART_S_NAME[x]]), k.art, "Art der Kosten")} ${werte}
+
+ Anteil ${ein(f("anteil"), zahlWert(k.anteil ?? 100), { titel: "Anteil in %" })} % + ${ein(f("notiz"), k.notiz ?? "", { t: "text", klasse: "ss-notiz", titel: "Notiz", platz: "Notiz" })}
+ ${w(`k.${k.id}.rechnung`)}`; +} + +function mittellohnHtml(e: StundensatzErgebnis): string { + const dv = v!.daten; + const zeilen = e.mittellohn.zeilen.map((z) => { + const m = dv.mittellohn[z.id]; + return ` + ${esc(z.name)}${ein(`m.${z.id}.personen`, zahlWert(m?.personen ?? null), { titel: `Personen ${z.name}`, platz: zahl(z.gezaehlt) })} + ${w(`ml.${z.id}.std`)}${w(`ml.${z.id}.satz`)}`; + }).join(""); + return `

Mittellohn für die Baustelle: wer mitarbeitet

+
${zeilen} + +
mitLohnartPersonenprod. Std/JahrSatz € / Std
Mittellohn gewichtet nach Stunden${w("ml.personen")}${w("ml.std")}${w("ml.satz")}
davon Lohnkosten ohne Gemeinkosten${w("ml.lohn")}
+

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.

+
+
`; +} + +/** 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)[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("[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 { + const b = (ev.target as HTMLElement).closest("[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 { + return new Promise((fertig) => { + const liste = umfeld().liste; + const gewaehlt = new Set(k.laufend ?? []); + huelle.innerHTML = `

Laufende Kosten für „${esc(k.name || "Kostenzeile")}“

+ ${liste.length ? `
${liste.map((l) => ``).join("")}
` + : '

Unter Betrieb → laufende Kosten steht noch nichts.

'} +

Summe im Jahr ${v!.gilt_ab.slice(0, 4)}; einmalige Kosten zählen nicht. „÷ Köpfe“ und „Anteil“ gelten danach.

+
`; + huelle.hidden = false; + const form = huelle.querySelector("form")!; + const zu = (ja: boolean) => { huelle.hidden = true; huelle.innerHTML = ""; fertig(ja); }; + form.querySelector('[data-a="abbrechen"]')!.onclick = () => zu(false); + form.onsubmit = (ev) => { + ev.preventDefault(); + k.laufend = [...form.querySelectorAll("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 { + 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()); diff --git a/src/web/styles.css b/src/web/styles.css index f091d1d..109f224 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -1754,3 +1754,73 @@ button.speichern-gruen:hover { background: var(--ein); } } .handy-reiter.nur-handy { display: none; } @media (max-width: 640px) { .handy-reiter.nur-handy { display: flex; } } + +/* ---------- Personal → Stundensätze (M15–M19) ---------- */ +.ss-leiste { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; justify-content: space-between; } +.ss-leiste .chip-knopf small { font-weight: 400; color: var(--leise); } +.ss-raster { display: grid; grid-template-columns: 230px minmax(0, 1fr); gap: 16px; align-items: start; } +.ss-rechts { display: grid; gap: 16px; min-width: 0; } +.ss-raster .karte h2 { font-size: 16px; margin: 0 0 8px; } +.ss-links { position: sticky; top: 12px; } +.ss-liste { display: grid; gap: 4px; } +.ss-eintrag { display: flex; justify-content: space-between; gap: 8px; padding: 8px 10px; border: 1px solid transparent; border-radius: 8px; background: none; color: var(--text); font: inherit; cursor: pointer; text-align: left; } +.ss-eintrag:hover { background: var(--titel-bg); } +.ss-eintrag.an { border-color: var(--akzent); background: var(--akzent-hell); } +.ss-eintrag b, .ss-ergebnis b { font-variant-numeric: tabular-nums; white-space: nowrap; } +.ss-neu { display: grid; width: 100%; margin-top: 8px; padding: 8px; border: 1px dashed var(--akzent); border-radius: 8px; background: none; color: var(--akzent); font: inherit; cursor: pointer; } +.ss-neu small { color: var(--leise); font-size: 12px; } +.ss-abstand { margin-top: 16px !important; } +.ss-ergebnis { display: flex; justify-content: space-between; gap: 8px; flex-wrap: wrap; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; margin-bottom: 4px; } +.ss-ergebnis b { color: var(--akzent); font-size: 18px; } +.ss-ergebnis.klein { border: 0; padding: 2px 10px; } +.ss-ergebnis.klein b { font-size: 14px; color: var(--text); } +.ss-kopf { display: flex; justify-content: space-between; align-items: center; gap: 10px; flex-wrap: wrap; } +.ss-kopf h2 { display: flex; align-items: center; gap: 6px; } +input.ss-titel { font: inherit; font-weight: 700; width: 12em; padding: 2px 6px; } +.ss-hinweis { background: var(--markiert); border-radius: 8px; padding: 6px 10px; } +.ss-rolle { overflow-x: auto; margin-top: 10px; } +table.ss-t { width: 100%; border-collapse: collapse; font-size: 13.5px; } +table.ss-t th, table.ss-t td { padding: 5px 6px; border-bottom: 1px solid var(--linie); text-align: left; vertical-align: middle; } +table.ss-t th { font-size: 12.5px; color: var(--leise); font-weight: 600; } +table.ss-t th.zahl, table.ss-t td.zahl { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; } +table.ss-t tr.ss-block th { padding-top: 12px; color: var(--text); font-size: 13.5px; border-bottom: 2px solid var(--linie); } +table.ss-t tr.ss-zwischen td { font-weight: 600; background: var(--titel-bg); } +table.ss-t tr.ss-info td { color: var(--leise); font-size: 12.5px; } +table.ss-t tr.ss-ergebniszeile td { border-top: 2px solid var(--text); border-bottom: 0; padding-top: 8px; } +table.ss-t tr.ss-auszeit td, table.ss-t tr.ss-als-kosten td { color: var(--leise); } +table.ss-t tr.aus td { color: var(--leise); } +table.ss-t input { font: inherit; padding: 3px 5px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; } +table.ss-t input.zahl { text-align: right; } +table.ss-t input.w-kurz { width: 4.5em; } +table.ss-t input.w-euro { width: 7em; } +table.ss-t input.ss-name { width: 100%; min-width: 14em; background: transparent; border-color: transparent; color: var(--text); } +table.ss-t input.ss-name:hover, table.ss-t input.ss-name:focus { border-color: var(--linie); } +table.ss-t input.ss-notiz { width: 9em; background: transparent; border-color: transparent; color: var(--leise); } +table.ss-t select { font: inherit; font-size: 12.5px; padding: 2px 4px; } +.ss-ansatz { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 6px; } +.ss-ansatz.klein { font-size: 12px; color: var(--leise); margin-top: 3px; } +.ss-ansatz.klein input.w-kurz { width: 3.6em; } +.ss-gross, .ss-gross span { font-size: 18px; font-weight: 700; color: var(--akzent); } +.ss-umsatz { margin: 12px 0 4px; } +.ss-umsatz input { font: inherit; width: 3.6em; text-align: right; padding: 2px 4px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; } +.ss-einstellungen { display: grid; gap: 8px; margin-top: 8px; } +.ss-einstellungen input { font: inherit; width: 4em; text-align: right; padding: 2px 4px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; } +.ss-schalter { position: relative; display: inline-block; width: 34px; height: 19px; } +.ss-schalter input { position: absolute; inset: 0; opacity: 0; margin: 0; cursor: pointer; } +.ss-schalter i { position: absolute; inset: 0; border-radius: 99px; background: var(--linie); pointer-events: none; transition: background .15s; } +.ss-schalter i::after { content: ""; position: absolute; top: 2px; left: 2px; width: 15px; height: 15px; border-radius: 50%; background: var(--fl); transition: left .15s; } +.ss-schalter input:checked + i { background: var(--akzent); } +.ss-schalter input:checked + i::after { left: 17px; } +.ss-schalter input:focus-visible + i { outline: 2px solid var(--akzent); outline-offset: 2px; } +.ss-weg { text-decoration: none !important; color: var(--leise) !important; font-size: 16px; } +.ss-leer { max-width: 640px; } +.ss-laufend-liste { display: grid; gap: 4px; max-height: 50vh; overflow: auto; margin-bottom: 8px; } +.ss-laufend-liste label { display: grid; grid-template-columns: auto 1fr auto; gap: 8px; align-items: center; padding: 4px 0; border-bottom: 1px solid var(--linie); } +.neue-saetze { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; background: var(--markiert); border: 1px solid var(--eingabe-linie); border-radius: 10px; padding: 8px 12px; margin-bottom: 12px; } +.neue-saetze span { flex: 1 1 280px; } +@media (max-width: 900px) { + .ss-raster { grid-template-columns: 1fr; } + .ss-links { position: static; } + table.ss-t .optional { display: none; } +} +table.ss-t input.ungueltig, .ss-umsatz input.ungueltig, .ss-einstellungen input.ungueltig { background: var(--warnung-bg); color: var(--warnung-text); border-color: var(--warn); } diff --git a/test/api.test.ts b/test/api.test.ts index 323e2bb..b4e5ea1 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -543,6 +543,9 @@ describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(200); expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403); expect((await als(b, "GET", "/api/export")).statusCode).toBe(403); + // Stundensätze zeigen Löhne (U2): nur Inhaber; die Namen der Lohnarten braucht das Büro + expect((await als(b, "GET", "/api/stundensaetze")).statusCode).toBe(403); + expect((await als(b, "GET", "/api/lohnarten")).statusCode).toBe(200); expect((await als(b, "PATCH", `/api/projekte/${p2.id}`, { notiz: "Büro war hier" })).statusCode).toBe(200); const j = await anmelden("jan", "jan123456"); @@ -1282,3 +1285,74 @@ describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => { .toEqual([{ id: "x1", menge: 12.5, grund: "a" }, { id: "x2", menge: null, grund: "" }]); }); }); + +describe.skipIf(!url)("Stundensätze im Personalmodul (M15–M19)", () => { + let pool: Pool; + let app: FastifyInstance; + + beforeAll(async () => { + pool = erstellePool(url!); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); + }); + afterAll(async () => { + await app?.close(); + await pool?.end(); + }); + + const neu = async (pfad: string, body: object = {}) => { + const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body }); + expect(r.statusCode, r.body).toBe(201); + return r.json(); + }; + const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json(); + + it("Excel übernehmen, Personen zählen, ins Angebot festschreiben, neue Version nachfragen (A36, A37)", async () => { + const chef = await neu("kontakte", { name: "Henning", rolle: "mitarbeiter" }); + const ges = await neu("kontakte", { name: "Rosty", rolle: "mitarbeiter" }); + await neu("mitarbeiter", { kontakt_id: chef.id, angestellt: false }); + await neu("mitarbeiter", { kontakt_id: ges.id, angestellt: true }); + const p = await neu("projekte", { nummer: "A-26-140", bezeichnung: "Dach Probe", status: "anfrage" }); + const alt = await neu("angebote/neu", { projekt_id: p.id }); + expect(alt.saetze.stundensaetze).toEqual({ planer: 8000, geselle: 5831, helfer: 5000 }); + + const v2 = await neu("stundensaetze/excel"); + expect((await app.inject({ method: "POST", url: "/api/stundensaetze/excel" })).statusCode).toBe(409); + const s = await hole("stundensaetze"); + expect(s.versionen.map((v: { name: string }) => v.name)).toEqual(["Excel 26.05.2026", "Akquise und Verwaltung als Kosten"]); + expect(s.gilt).toBe(v2.id); + const jahr = Number(v2.gilt_ab.slice(0, 4)); + expect(s.umfeld[jahr]).toMatchObject({ koepfe: 2, personen: { chef: 1, geselle: 1 } }); + + const a = await neu("angebote/neu", { projekt_id: p.id }); + expect(a.saetze).toMatchObject({ stundensaetze: { mittellohn: 7238, chef: 7238, planer: 10101, geselle: 7238 }, zuschlaege: { lohn: 0 }, + stundensatz_version: { id: v2.id } }); + expect(a.saetze.lohnarten[0]).toEqual({ id: "mittellohn", name: "Mittellohn" }); + const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Abbund", menge: 10, einheit: "m" }); + await neu("angebot-kosten", { position_id: pos.id, kostenart: "lohn", lohnart: "mittellohn", menge: 1 }); + expect((await hole(`angebote/${a.id}/voll`)).ergebnis.positionen[pos.id].kosten_je_einheit).toBe(7238); + expect((await hole(`angebote/${a.id}/voll`)).neue_stundensaetze).toBeNull(); + + // das alte Angebot (Sätze aus den Einstellungen) fragt nach; Übernehmen setzt den Lohnzuschlag auf 0 % + expect((await hole(`angebote/${alt.id}/voll`)).neue_stundensaetze.stundensatz_version.id).toBe(v2.id); + const r = await app.inject({ method: "POST", url: `/api/angebote/${alt.id}/stundensaetze` }); + expect(r.json()).toMatchObject({ stundensaetze: { mittellohn: 7238 }, zuschlaege: { lohn: 0 } }); + + // Gesellenlohn ändern: das Angebot behält seinen Satz, bis es übernimmt + const d = structuredClone(v2.daten); + d.tabellen.find((t: { id: string }) => t.id === "geselle").kosten[0].betrag = 250000; + expect((await app.inject({ method: "PATCH", url: `/api/stundensaetze/${v2.id}`, payload: { daten: d } })).statusCode).toBe(200); + const voll = await hole(`angebote/${a.id}/voll`); + expect(voll.saetze.stundensaetze.mittellohn).toBe(7238); + expect(voll.neue_stundensaetze.stundensaetze.mittellohn).toBeLessThan(7238); + + // Lohnarten für die Rolle im Personal; eigene Lohnart als Rolle speicherbar + expect((await hole("lohnarten")).map((x: { id: string }) => x.id)).toEqual(["chef", "planer", "geselle", "helfer"]); + const m = (await hole("mitarbeiter")).find((x: { kontakt_id: string }) => x.kontakt_id === ges.id); + expect((await app.inject({ method: "PATCH", url: `/api/mitarbeiter/${m.id}`, payload: { funktion: "vorarbeiter" } })).statusCode).toBe(200); + + // gleiches „gilt ab“ zweimal geht nicht + expect((await app.inject({ method: "POST", url: "/api/stundensaetze", payload: { name: "x", gilt_ab: v2.gilt_ab, daten: d } })).statusCode).toBe(409); + }); +}); diff --git a/test/stundensatz.test.ts b/test/stundensatz.test.ts new file mode 100644 index 0000000..69b0949 --- /dev/null +++ b/test/stundensatz.test.ts @@ -0,0 +1,85 @@ +import { describe, expect, it } from "vitest"; +import { rechneStundensaetze, saetzeFuerAngebot, schluesselFuer, zeitRechnen } from "../src/domain/stundensatz.js"; +import { stundensaetzeAusExcel, stundensaetzeNachS2 } from "../src/domain/stundensatz-excel.js"; + +const umfeld = { koepfe: 2, personen: { chef: 1, geselle: 1 }, laufend: {} }; + +describe("Stundensätze wie Hennings Excel (Abnahme M19)", () => { + const e = rechneStundensaetze(stundensaetzeAusExcel(), umfeld); + const t = (id: string) => e.tabellen.find((x) => x.id === id)!; + + it("Personalzeit: 2.000 Std Jahresarbeitszeit, 208 Tage anwesend, 1.184 produktive Std", () => { + const z = t("chef").zeit; + expect(z.jahresStd).toBe(2000); + expect(z.ausfallStd).toBe(336); + expect(z.anwesenheitTage).toBe(208); + expect(z.produktiv).toBe(1184); + expect(z.unproduktiv.map((u) => u.tage)).toEqual([11, 11, 26, 13]); + }); + + it("Chef: 95.174,51 € im Jahr = 80,38 €/Std", () => { + expect(t("chef").summe / 100).toBeCloseTo(95174.51237, 2); + expect(t("chef").satz).toBe(8038); + expect(t("chef").bloecke.map((b) => Math.round(b.bis) / 100)).toEqual([51548.57, 71137.03, 71787.03, 86981.44, 95174.51]); + }); + + it("Planer: 127.648,54 € im Jahr = 107,81 €/Std", () => { + expect(t("planer").summe / 100).toBeCloseTo(127648.544, 2); + expect(t("planer").satz).toBe(10781); + }); + + it("Mittellohn 60,63 € und Gemeinkostenanteil 19,75 € beim Chef", () => { + expect(t("chef").lohnkostensatz).toBe(6063); + expect(t("chef").gemeinkostenanteil).toBe(1975); + }); + + it("Umsatzbedarf 183.027,91 € (Chef-Blatt) und 131.596,44 € (Planer-Blatt)", () => { + expect(Math.round(t("chef").umsatzbedarf) / 100).toBe(183027.91); + expect(Math.round(t("planer").umsatzbedarf) / 100).toBe(131596.44); + }); + + it("Mittellohn gewichtet nach Stunden: Chef und Geselle gleich", () => { + expect(e.mittellohn.satz).toBe(8038); + expect(e.mittellohn.personen).toBe(2); + expect(saetzeFuerAngebot(e).stundensaetze).toMatchObject({ mittellohn: 8038, chef: 8038, planer: 10781, geselle: 8038 }); + }); +}); + +describe("Fassung nach S2: Akquise und Verwaltung als Kosten", () => { + const d = stundensaetzeNachS2(stundensaetzeAusExcel()); + const e = rechneStundensaetze(d, umfeld); + const chef = e.tabellen.find((x) => x.id === "chef")!; + + it("kein Zeitabzug mehr: 1.352 produktive Std", () => expect(chef.zeit.produktiv).toBe(1352)); + + it("14 Std/Monat × Lohnkostensatz des Gesellen, keine pauschalen 65 € mehr", () => { + const lks = Math.round(7178702.857142859 / 1352); + expect(e.bewertungssatz).toBe(lks); + const z = chef.zeilen.filter((x) => x.ausZeit); + expect(z.map((x) => x.jahr)).toEqual([84 * lks, 84 * lks]); + expect(chef.zeilen.some((x) => x.name === "Verwaltung" && !x.ausZeit)).toBe(false); + expect(chef.satz).toBe(Math.round((9517451.237156226 - 624000 + 168 * lks) / 1352)); + }); + + it("Mittellohn gewichtet: Σ(Satz × Std × Personen) ÷ Σ(Std × Personen)", () => { + const x = structuredClone(d); + x.tabellen.find((t) => t.id === "geselle")!.kosten[0]!.betrag = 250000; + x.mittellohn.geselle = { an: true, personen: 2 }; + const r = rechneStundensaetze(x, umfeld); + const c = r.tabellen.find((t) => t.id === "chef")!, g = r.tabellen.find((t) => t.id === "geselle")!; + expect(r.mittellohn.satz).toBe(Math.round((c.satz * c.zeit.produktiv + g.satz * g.zeit.produktiv * 2) / (c.zeit.produktiv + g.zeit.produktiv * 2))); + }); +}); + +describe("Hilfen", () => { + it("Schlüssel aus dem Namen, eindeutig", () => { + expect(schluesselFuer("2. Vorarbeiter", [])).toBe("2-vorarbeiter"); + expect(schluesselFuer("Geselle", ["geselle"])).toBe("geselle-2"); + expect(schluesselFuer("Mittellohn", [])).toBe("lohnart"); + }); + it("Rüstzeit je Anwesenheitstag", () => { + const t = stundensaetzeAusExcel().tabellen[0]!; + t.zeit.ausfall[0]!.tage = 25; + expect(zeitRechnen(t).unproduktiv[2]!.std).toBe(213); + }); +});