Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz),
Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau
(80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten.
Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage
bei neuer Version.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-22 06:55:22 +00:00
parent 0d5f11c842
commit 45c21943bf
24 changed files with 1305 additions and 42 deletions

View File

@@ -2,6 +2,14 @@
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. 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 ## 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. - 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.

View File

@@ -21,6 +21,7 @@ import m016 from "../src/server/migrations/016_fahrt.sql";
import m017 from "../src/server/migrations/017_stammdaten.sql"; import m017 from "../src/server/migrations/017_stammdaten.sql";
import m018 from "../src/server/migrations/018_freitage.sql"; import m018 from "../src/server/migrations/018_freitage.sql";
import m019 from "../src/server/migrations/019_jahresplan.sql"; import m019 from "../src/server/migrations/019_jahresplan.sql";
import m020 from "../src/server/migrations/020_stundensaetze.sql";
const MIGRATIONEN: [string, string][] = [ const MIGRATIONEN: [string, string][] = [
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], ["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], ["017_stammdaten.sql", m017],
["018_freitage.sql", m018], ["018_freitage.sql", m018],
["019_jahresplan.sql", m019], ["019_jahresplan.sql", m019],
["020_stundensaetze.sql", m020],
]; ];
export async function starte(db: PGlite, v70?: unknown) { export async function starte(db: PGlite, v70?: unknown) {

View File

@@ -1,6 +1,6 @@
{ {
"name": "betrieb", "name": "betrieb",
"version": "0.25.2", "version": "0.26.0",
"private": true, "private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module", "type": "module",

View File

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

View File

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

270
src/domain/stundensatz.ts Normal file
View File

@@ -0,0 +1,270 @@
// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026, angebote/stundensaetze/stundensatz-konzept.md):
// je Lohnart eine Rechentabelle wie Hennings Excel-Blatt. 1 Zeit: Arbeitstage × Std/Tag − Feiertage − Ausfall
// − unproduktive Zeiten = produktive Stunden. 2 Kosten in fünf Blöcken (Lohn, AG-Anteile, indirekte Personalkosten,
// Sachkosten, Verwaltung) plus kalkulatorischer Gewinn. 3 Stundensatz = Kosten je Jahr ÷ produktive Stunden (Vollkosten).
// Unproduktive Zeiten können statt als Zeitabzug als Kosten zählen (S2): Stunden × Lohnkostensatz der Bewertungs-
// Tabelle (Blöcke 1–3 ÷ produktive Stunden, ohne Gemeinkosten, damit keine Zirkelrechnung entsteht).
// Gerechnet wird ohne Zwischenrundung wie in Excel; gerundet wird nur der Satz auf den Cent.
import type { Cent } from "./geld.js";
export const BLOECKE = [1, 2, 3, 4, 5] as const;
export type Block = (typeof BLOECKE)[number];
export const BLOCK_NAME: Record<Block, string> = {
1: "Lohn (direkter Personalaufwand)", 2: "AG-Anteile, BG, SoKa", 3: "indirekter Personalaufwand", 4: "Sachkosten (Organisationsaufwand)", 5: "zentrale Verwaltung",
};
/** monat/jahr: fester Betrag; netto: Monatslohn netto ÷ Faktor = brutto; prozent: Anteil der Lohnsumme (Block 1);
* stunden: Std je Monat × € je Std; laufend: Summe gewählter laufender Kosten im Jahr */
export const KOSTENARTEN_S = ["netto", "monat", "jahr", "prozent", "stunden", "laufend"] as const;
export type KostenArtS = (typeof KOSTENARTEN_S)[number];
export const KOSTENART_S_NAME: Record<KostenArtS, string> = {
netto: "netto je Monat", monat: "je Monat", jahr: "je Jahr", prozent: "% vom Lohn", stunden: "Std/Monat × €", laufend: "aus laufenden Kosten",
};
export interface Kostenzeile {
id: string;
block: Block;
name: string;
art: KostenArtS;
/** Cent: je Monat (netto, monat), je Jahr (jahr), je Stunde (stunden) */
betrag?: Cent;
/** netto: Anteil, der netto bleibt (0,7) */
faktor?: number;
/** prozent: Prozent der Lohnsumme */
prozent?: number;
/** stunden: Std je Monat */
stunden?: number;
/** laufend: ids der laufenden Kosten */
laufend?: string[];
/** Betrag auf die Köpfe des Betriebs verteilen */
koepfe?: boolean;
/** Anteil in %, Vorgabe 100 */
anteil?: number;
notiz?: string;
}
export interface Ausfall { id: string; name: string; tage: number }
export interface Unproduktiv { id: string; name: string; stunden: number; je: "monat" | "tag"; als: "zeit" | "kosten" }
export interface Rechentabelle {
/** fester Schlüssel, zugleich die Lohnart im Angebot (chef, planer, geselle, helfer, …) */
id: string;
name: string;
hinweis?: string;
zeit: { stundenTag: number; tageJahr: number; feiertage: number; ausfall: Ausfall[]; unproduktiv: Unproduktiv[] };
kosten: Kostenzeile[];
/** kalkulatorischer Gewinn in % der Kosten */
gewinn: number;
/** Umsatzbedarf: Lohnanteil am Umsatz in % und Wagnis darin */
lohnanteil: number;
wagnis: number;
}
export interface StundensatzDaten {
tabellen: Rechentabelle[];
/** Köpfe, auf die Sachkosten verteilt werden; leer = aus dem Personal gezählt */
koepfe: number | null;
/** Tabelle, mit deren Lohnkostensatz unproduktive Zeiten als Kosten bewertet werden (S2) */
bewertung: string;
/** je Tabelle: im Mittellohn an/aus und Personen (leer = aus dem Personal gezählt) */
mittellohn: Record<string, { an: boolean; personen: number | null }>;
}
/** Was das Programm selbst weiß: Köpfe und Personen je Lohnart aus dem Personal, laufende Kosten im Jahr */
export interface Umfeld {
koepfe: number;
personen: Record<string, number>;
laufend: Record<string, Cent>;
}
export interface ZeileErgebnis {
id: string;
block: Block;
name: string;
jahr: number;
monat: number;
jeStd: number;
/** Anteil an den Gesamtkosten in % */
anteil: number;
rechnung: string;
/** aus einer unproduktiven Zeit „als Kosten“ */
ausZeit?: boolean;
}
export interface TabellenErgebnis {
id: string;
name: string;
zeit: {
bruttoStd: number; feiertageStd: number; jahresStd: number; jahresTage: number;
ausfall: { id: string; std: number; tage: number }[]; ausfallStd: number; ausfallTage: number; anwesenheitTage: number;
unproduktiv: { id: string; std: number; tage: number; als: "zeit" | "kosten" }[];
produktiv: number; produktivTage: number;
};
zeilen: ZeileErgebnis[];
/** je Block die Summe und die Zwischensumme bis einschließlich dieses Blocks (wie im Excel-Blatt) */
bloecke: { block: Block; jahr: number; bis: number; bisJeStd: number }[];
/** Blöcke 1–3: Lohnkosten ohne Gemeinkosten */
lohnkosten: number;
lohnkostensatz: Cent;
gewinn: number;
summe: number;
/** Vollkosten-Stundensatz, auf den Cent gerundet */
satz: Cent;
satzGenau: number;
gemeinkostenanteil: Cent;
umsatzbedarf: number;
}
export interface MittellohnErgebnis {
zeilen: { id: string; name: string; an: boolean; personen: number; gezaehlt: number; std: number; satz: Cent; lohnkostensatz: Cent }[];
personen: number;
std: number;
satz: Cent | null;
lohnkostensatz: Cent | null;
}
export interface StundensatzErgebnis {
tabellen: TabellenErgebnis[];
koepfe: number;
bewertungssatz: Cent;
mittellohn: MittellohnErgebnis;
umsatzbedarf: { jahr: number; monat: number; lohn: number; material: number };
}
const zahl = (n: number) => n.toLocaleString("de-DE", { maximumFractionDigits: 2 });
const eur = (c: number) => `${(c / 100).toLocaleString("de-DE", { minimumFractionDigits: 2, maximumFractionDigits: 2 })} €`;
export function zeitRechnen(t: Rechentabelle): TabellenErgebnis["zeit"] {
const z = t.zeit, h = z.stundenTag;
const bruttoStd = z.tageJahr * h, feiertageStd = z.feiertage * h;
const ausfall = z.ausfall.map((a) => ({ id: a.id, std: a.tage * h, tage: a.tage }));
const ausfallStd = ausfall.reduce((s, a) => s + a.std, 0), ausfallTage = ausfall.reduce((s, a) => s + a.tage, 0);
const anwesenheitTage = z.tageJahr - z.feiertage - ausfallTage;
const unproduktiv = z.unproduktiv.map((u) => {
const std = u.stunden * (u.je === "monat" ? 12 : anwesenheitTage);
return { id: u.id, std, tage: h ? Math.ceil(std / h) : 0, als: u.als };
});
const produktiv = bruttoStd - feiertageStd - ausfallStd - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.std, 0);
return {
bruttoStd, feiertageStd, jahresStd: bruttoStd - feiertageStd, jahresTage: z.tageJahr - z.feiertage, ausfall, ausfallStd, ausfallTage, anwesenheitTage,
unproduktiv, produktiv, produktivTage: z.tageJahr - z.feiertage - ausfallTage - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.tage, 0),
};
}
/** Kosten einer Zeile im Jahr (Cent, ungerundet) und wie sie entstehen */
function zeileRechnen(k: Kostenzeile, lohnsumme: number, u: Umfeld): { jahr: number; rechnung: string } {
const anteil = (k.anteil ?? 100) / 100;
const teiler = k.koepfe ? Math.max(1, u.koepfe) : 1;
const nach = (x: number) => (x * anteil) / teiler;
const zusatz = `${anteil !== 1 ? ` × ${zahl(anteil * 100)} %` : ""}${teiler !== 1 ? ` ÷ ${zahl(teiler)} Köpfe` : ""}`;
const b = k.betrag ?? 0;
switch (k.art) {
case "netto": {
const f = k.faktor && k.faktor > 0 ? k.faktor : 1;
return { jahr: nach((b / f) * 12), rechnung: `${eur(b)} netto ÷ ${zahl(f)} = ${eur(b / f)} brutto × 12${zusatz}` };
}
case "monat": return { jahr: nach(b * 12), rechnung: `${eur(b)} × 12${zusatz}` };
case "jahr": return { jahr: nach(b), rechnung: `${eur(b)} im Jahr${zusatz}` };
case "prozent": return { jahr: nach((lohnsumme * (k.prozent ?? 0)) / 100), rechnung: `${zahl(k.prozent ?? 0)} % von ${eur(lohnsumme)}${zusatz}` };
case "stunden": return { jahr: nach((k.stunden ?? 0) * b * 12), rechnung: `${zahl(k.stunden ?? 0)} Std × ${eur(b)} × 12${zusatz}` };
case "laufend": {
const s = (k.laufend ?? []).reduce((x, id) => x + (u.laufend[id] ?? 0), 0);
return { jahr: nach(s), rechnung: `${(k.laufend ?? []).length} laufende Kosten, ${eur(s)} im Jahr${zusatz}` };
}
}
}
function tabelleRechnen(t: Rechentabelle, u: Umfeld, bewertung: (eigen: Cent) => Cent): TabellenErgebnis {
const zeit = zeitRechnen(t);
const prod = zeit.produktiv > 0 ? zeit.produktiv : NaN;
const roh: Omit<ZeileErgebnis, "monat" | "jeStd" | "anteil">[] = [];
let lohnsumme = 0;
for (const block of BLOECKE) {
if (block === 4) {
// Lohnkostensatz steht nach Block 3 fest; unproduktive Zeiten „als Kosten“ kommen in die Sachkosten
const lohnkosten = roh.reduce((s, z) => s + z.jahr, 0);
const satz = bewertung(Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0);
for (const p of t.zeit.unproduktiv) {
if (p.als !== "kosten") continue;
const std = zeit.unproduktiv.find((x) => x.id === p.id)!.std;
roh.push({ id: `zeit-${p.id}`, block: 4, name: p.name, jahr: std * satz, rechnung: `${zahl(std)} Std × ${eur(satz)} Lohnkosten je Std`, ausZeit: true });
}
}
for (const k of t.kosten.filter((x) => x.block === block)) {
const r = zeileRechnen(k, lohnsumme, u);
roh.push({ id: k.id, block, name: k.name, jahr: r.jahr, rechnung: r.rechnung });
}
if (block === 1) lohnsumme = roh.reduce((s, z) => s + z.jahr, 0);
}
const kosten = roh.reduce((s, z) => s + z.jahr, 0);
const gewinn = (kosten * (t.gewinn ?? 0)) / 100;
const summe = kosten + gewinn;
const lohnkosten = roh.filter((z) => z.block <= 3).reduce((s, z) => s + z.jahr, 0);
let bis = 0;
const bloecke = BLOECKE.map((block) => {
const jahr = roh.filter((z) => z.block === block).reduce((s, z) => s + z.jahr, 0);
bis += jahr;
return { block, jahr, bis, bisJeStd: bis / prod };
});
const satzGenau = summe / prod;
const satz = Number.isFinite(satzGenau) ? Math.round(satzGenau) : 0;
const lohnkostensatz = Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0;
const netto = (t.lohnanteil - t.wagnis) / 100;
return {
id: t.id, name: t.name, zeit,
zeilen: roh.map((z) => ({ ...z, monat: z.jahr / 12, jeStd: z.jahr / prod, anteil: summe ? (z.jahr / summe) * 100 : 0 })),
bloecke, lohnkosten, lohnkostensatz, gewinn, summe, satz, satzGenau, gemeinkostenanteil: satz - lohnkostensatz,
umsatzbedarf: netto > 0 ? summe / netto : 0,
};
}
/** Personen je Tabelle: eingetragen oder aus dem Personal gezählt */
export const personenVon = (d: StundensatzDaten, u: Umfeld, id: string) => d.mittellohn[id]?.personen ?? u.personen[id] ?? 0;
export function rechneStundensaetze(d: StundensatzDaten, u: Umfeld): StundensatzErgebnis {
const koepfe = d.koepfe ?? u.koepfe;
const umfeld = { ...u, koepfe };
// Bewertungssatz: Lohnkostensatz der Bewertungs-Tabelle, die ihre eigenen Zeiten dabei nur als Zeit kennt
const bt = d.tabellen.find((t) => t.id === d.bewertung);
const bewertungssatz = bt ? tabelleRechnen(bt, umfeld, (eigen) => eigen).lohnkostensatz : 0;
const tabellen = d.tabellen.map((t) => tabelleRechnen(t, umfeld, (eigen) => (bt ? bewertungssatz : eigen)));
const zeilen = tabellen.map((t) => {
const m = d.mittellohn[t.id];
return { id: t.id, name: t.name, an: m?.an ?? false, personen: personenVon(d, u, t.id), gezaehlt: u.personen[t.id] ?? 0, std: t.zeit.produktiv, satz: t.satz, lohnkostensatz: t.lohnkostensatz };
});
const mit = zeilen.filter((z) => z.an && z.personen > 0 && z.std > 0);
const std = mit.reduce((s, z) => s + z.std * z.personen, 0);
const gewichtet = (f: (z: (typeof mit)[number]) => number) => (std > 0 ? Math.round(mit.reduce((s, z) => s + f(z) * z.std * z.personen, 0) / std) : null);
const jahr = tabellen.reduce((s, t) => s + t.umsatzbedarf * personenVon(d, u, t.id), 0);
const lohn = tabellen.reduce((s, t) => s + t.summe * personenVon(d, u, t.id), 0);
return {
tabellen, koepfe, bewertungssatz,
mittellohn: { zeilen, personen: mit.reduce((s, z) => s + z.personen, 0), std, satz: gewichtet((z) => z.satz), lohnkostensatz: gewichtet((z) => z.lohnkostensatz) },
umsatzbedarf: { jahr, monat: jahr / 12, lohn, material: jahr - lohn },
};
}
export const MITTELLOHN = "mittellohn";
/** Sätze und Lohnarten, wie sie ein Angebot festschreibt (A36): Mittellohn zuerst, dann jede Tabelle */
export function saetzeFuerAngebot(e: StundensatzErgebnis): { stundensaetze: Record<string, Cent>; lohnarten: { id: string; name: string }[] } {
const stundensaetze: Record<string, Cent> = {};
const lohnarten: { id: string; name: string }[] = [];
if (e.mittellohn.satz != null) { stundensaetze[MITTELLOHN] = e.mittellohn.satz; lohnarten.push({ id: MITTELLOHN, name: "Mittellohn" }); }
for (const t of e.tabellen) { stundensaetze[t.id] = t.satz; lohnarten.push({ id: t.id, name: t.name }); }
return { stundensaetze, lohnarten };
}
/** Schlüssel für eine neue Tabelle aus dem Namen: „2. Vorarbeiter“ → „2-vorarbeiter“, eindeutig */
export function schluesselFuer(name: string, vorhanden: string[]): string {
const roh = name.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30) || "lohnart";
let s = roh === MITTELLOHN ? "lohnart" : roh, i = 2;
while (vorhanden.includes(s)) s = `${roh}-${i++}`;
return s;
}
/** Jahressumme einer laufenden Kosten-Position im Jahr (einmalige zählen nicht) */
export function laufendImJahr(k: { betrag: number; rhythmus: string; start: string; ende?: string | null }, jahr: number): Cent {
if (k.rhythmus === "einmalig" || k.start > `${jahr}-12-31` || (k.ende && k.ende < `${jahr}-01-01`)) return 0;
return k.betrag * ({ monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 } as Record<string, number>)[k.rhythmus]!;
}

View File

@@ -13,6 +13,7 @@ import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
import { hatBlatt, vorlagen } from "./leistungen-daten.js"; import { hatBlatt, vorlagen } from "./leistungen-daten.js";
import { plusTage } from "../domain/datum.js"; import { plusTage } from "../domain/datum.js";
import { naechsterArbeitstag } from "../domain/kalender.js"; import { naechsterArbeitstag } from "../domain/kalender.js";
import { aktuelleSaetze } from "./stundensaetze.js";
const IdParam = z.object({ id: z.uuid() }); const IdParam = z.object({ id: z.uuid() });
const heute = () => new Date().toISOString().slice(0, 10); 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 */ /** 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 { export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze {
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen" | "kilometersatz">>; const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen" | "kilometersatz" | "lohnarten" | "stundensatz_version">>;
return { return {
stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) }, stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) },
...(s.lohnarten?.length ? { lohnarten: s.lohnarten } : {}),
stundensatz_version: s.stundensatz_version ?? null,
zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) }, zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) },
wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent), 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 ?? {}) }, 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 nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear());
const k = e.kalkulation; const k = e.kalkulation;
const datum = heute(); 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 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) 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 *`, 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?.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, 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 // 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 (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]); if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
return neu; return neu;
@@ -226,7 +232,36 @@ export function registriereAngebote(
const e = await einstellungen(); const e = await einstellungen();
const x = await ladeAngebot(pool, id, e); const x = await ladeAngebot(pool, id, e);
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" }); 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<Awaited<ReturnType<typeof ladeAngebot>>>) {
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“ // A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“

View File

@@ -39,8 +39,8 @@ function recht(methode: string, muster: string | undefined, url: string): Recht
const k = `${methode} ${muster ?? ""}`; const k = `${methode} ${muster ?? ""}`;
if (OFFEN.has(k)) return "offen"; if (OFFEN.has(k)) return "offen";
if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle"; if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle";
// Jahresplan und BWA (Stufe 5) nur für den 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/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "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"; return muster ? "buero" : "inhaber";
} }

View File

@@ -28,6 +28,7 @@ import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js"; import { vorlageAnwenden } from "./vorlage.js";
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js"; import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
import { registriereStammdaten } from "./stammdaten.js"; import { registriereStammdaten } from "./stammdaten.js";
import { registriereStundensaetze } from "./stundensaetze.js";
import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js"; import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js";
import { planPosten } from "../domain/jahresplan.js"; import { planPosten } from "../domain/jahresplan.js";
import { type BezugArt, bezugsTage } from "../domain/bezug.js"; import { type BezugArt, bezugsTage } from "../domain/bezug.js";
@@ -98,6 +99,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner); registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
registriereStammdaten(app, pool, ladeEinstellungen); registriereStammdaten(app, pool, ladeEinstellungen);
registriereStundensaetze(app, pool);
registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() }); registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() });
app.post("/api/projekte/:id/ordner", async (req, reply) => { app.post("/api/projekte/:id/ordner", async (req, reply) => {

View File

@@ -1,5 +1,6 @@
// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft). // 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. // 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 type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod"; import { z } from "zod";
import { type Client, type Pool, transaktion } from "./db.js"; 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 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; 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, 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<Map<number, Planzeile>> { async function zuordnung(): Promise<Map<number, Planzeile>> {

View File

@@ -1,6 +1,7 @@
// Leistungen und Mengenvorlagen aus Programm und Datenbank, mit den aktuellen Artikelpreisen aus dem Materialstamm. // 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, // 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. // 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 { Pool } from "./db.js";
import type { Einstellungen } from "./einstellungen.js"; import type { Einstellungen } from "./einstellungen.js";
import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js"; import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js";
@@ -32,12 +33,13 @@ export async function artikelNach(c: Pick<Pool, "query">, 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) }])); 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 */ /** Sätze der Stammdaten: wie ein neues Angebot heute, also Stundensätze aus Personal → Stundensätze, sonst Einstellungen */
export function stammSaetze(e: Einstellungen): Saetze { export function stammSaetze(e: Einstellungen, neue?: AngebotsSaetze | null): Saetze {
const k = e.kalkulation; const k = e.kalkulation;
return { 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, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz,
...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
}; };
} }

View File

@@ -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}$');

View File

@@ -1,5 +1,6 @@
// Stammdaten (Henning, 21.10.2026): Leistungen mit Vorkalkulation, GAEB-Import in Ordner, Materialstamm mit // 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. // 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 type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod"; import { z } from "zod";
import { type Pool, transaktion } from "./db.js"; 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) */ /** Leistungen mit Kosten, VK und Stunden je Einheit (Liste und Katalog im Angebot) */
app.get("/api/leistungen", async () => { 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) => { return nurLeistungen(await vorlagen(pool)).map((v) => {
const r = rechneLeistung(v, s); const r = rechneLeistung(v, s);
return { return {
@@ -56,7 +57,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell
const { id } = IdParam.parse(req.params); const { id } = IdParam.parse(req.params);
const v = (await vorlagen(pool)).find((x) => String(x.id) === id); 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)." }); 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 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 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; 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(), ordner: z.string().trim().min(1).max(300).optional(),
prozent: z.number().min(-90).max(500).optional(), prozent: z.number().min(-90).max(500).optional(),
}).parse(req.body ?? {}); }).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 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 gewaehlt = q.ids.map((i) => alle.get(i)).filter((v): v is Mengenvorlage => !!v);
const eigene = gewaehlt.filter((v) => !v.fest); const eigene = gewaehlt.filter((v) => !v.fest);

140
src/server/stundensaetze.ts Normal file
View File

@@ -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<Pool | Client, "query">;
/** 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<Umfeld & { liste: { id: string; bezeichnung: string; kategorie: string | null; jahr: Cent }[] }> {
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<string, Cent>; 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<AngebotsSaetze | null> {
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<string, any>) => ({ 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<number, Awaited<ReturnType<typeof umfeldLaden>>> = {};
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();
});
}

View File

@@ -25,7 +25,7 @@ const blatt = z.object({
// Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position // Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position
const ansatz = z.object({ const ansatz = z.object({
kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]), 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(), beschreibung: z.string().max(300).nullable().optional(),
bezug: kurzeFormel.nullable().optional(), bezug: kurzeFormel.nullable().optional(),
menge: z.number().min(0).max(1e9), menge: z.number().min(0).max(1e9),
@@ -147,7 +147,10 @@ export const TABELLEN: Tabelle[] = [
gewinn_prozent: z.number().min(0).max(50).optional(), gewinn_prozent: z.number().min(0).max(50).optional(),
ausfall_prozent: z.number().min(0).max(50).optional(), ausfall_prozent: z.number().min(0).max(50).optional(),
saetze: z.object({ 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(), 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(), 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(), 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({ schema: z.object({
position_id: id, position_id: id,
kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]), 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, beschreibung: optText,
menge: z.number().min(0).max(1e9).optional(), menge: z.number().min(0).max(1e9).optional(),
einheit: optText, einheit: optText,
@@ -425,7 +428,7 @@ export const TABELLEN: Tabelle[] = [
angestellt: z.boolean().optional(), angestellt: z.boolean().optional(),
lohn_cent: cent.min(0).nullable().optional(), lohn_cent: cent.min(0).nullable().optional(),
urlaubstage: z.number().min(0).max(60).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: "jahresplan", pfad: "jahresplaene", sortierung: "jahr, basis desc, angelegt_am" },
{ name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" }, { name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" },
{ name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" }, { name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" },
// Stundensätze im Personalmodul (M15–M19)
{ name: "stundensatz_version", pfad: "stundensatz_versionen", sortierung: "gilt_ab" },
]; ];

View File

@@ -4,7 +4,7 @@
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19). // Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
import { formatEuro, parseEuro } from "../domain/geld.js"; 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 { benenneUm, zahlDeutsch } from "../domain/formel.js";
import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js"; import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js";
import type { Mengenvorlage } from "../domain/mengenvorlagen.js"; import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
@@ -240,7 +240,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
} }
if (pfad === "saetze") { if (pfad === "saetze") {
// Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben // 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; if (zid === "km") s.kilometersatz = wert ?? 0;
else s[zid][feld] = wert ?? 0; else s[zid][feld] = wert ?? 0;
return api(`angebote/${id}`, "PATCH", { saetze: s }); return api(`angebote/${id}`, "PATCH", { saetze: s });
@@ -249,7 +249,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null }; if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null };
if (pfad === "angebot-kosten" && feld === "kostenart") { if (pfad === "angebot-kosten" && feld === "kostenart") {
const kz = d.kosten.find((x: Zeile) => x.id === zid); 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 } : {}) }; ...(wert === "lohn" ? { einheit: "h" } : wert === "fahrt" ? { einheit: "km" } : ["h", "km"].includes(kz?.einheit) ? { einheit: null } : {}) };
} }
return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body); return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body);
@@ -515,6 +515,8 @@ async function editor(id: string, gross: string | null): Promise<void> {
merkeTab(p.id, "kalk"); merkeTab(p.id, "kalk");
return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`); 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 === "vorlage") return await einfuegen("vorlage", z.aktiv ?? z.ziel, zid, b.dataset.in);
if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; } if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; }
if (a === "als-vorlage") return await alsVorlage(zid); if (a === "als-vorlage") return await alsVorlage(zid);
@@ -523,7 +525,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
const p = pos(zid)!; const p = pos(zid)!;
const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null; const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null;
const fahrt = art === "fahrt"; const fahrt = art === "fahrt";
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1, const k = await api<Zeile>("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, 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) }); 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}`); z.auf.add(`${zid}:${art}`);
@@ -667,7 +669,7 @@ function handyHtml(d: Zeile, meldung: string): string {
return `<div class="angebot-handy"> return `<div class="angebot-handy">
<div class="kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a> <div class="kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
<h1>${esc(a.nummer)} <span class="nummer">${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}</div> <h1>${esc(a.nummer)} <span class="nummer">${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}</div>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""} ${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}${neueSaetzeHtml(d)}
<p class="hinweis ah-banner">Am Handy: ansehen, Mengen und Preise ändern, freigeben. Kalkulation und Vorlagen bearbeiten am PC.</p> <p class="hinweis ah-banner">Am Handy: ansehen, Mengen und Preise ändern, freigeben. Kalkulation und Vorlagen bearbeiten am PC.</p>
<section class="karte ah-lv">${lv || '<p class="hinweis leer">Noch keine Positionen.</p>'}</section> <section class="karte ah-lv">${lv || '<p class="hinweis leer">Noch keine Positionen.</p>'}</section>
<section class="karte stand-zahlen"><div><small>Netto</small><b>${euro(e.netto)}</b></div><div><small>Brutto</small><b>${euro(e.brutto)}</b></div> <section class="karte stand-zahlen"><div><small>Netto</small><b>${euro(e.netto)}</b></div><div><small>Brutto</small><b>${euro(e.brutto)}</b></div>
@@ -739,7 +741,7 @@ function kostenTabelle(d: Zeile, p: Zeile, frei: boolean, auf?: Set<string>): st
<td>${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}` })}</td> <td>${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}` })}</td>
<td>${mitPers ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: fahrt ? "Fahrzeuge" : "Personen" }) : ""}</td> <td>${mitPers ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: fahrt ? "Fahrzeuge" : "Personen" }) : ""}</td>
<td class="zahl"><b>${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}</b>${lohn ? " h" : fahrt ? " km" : ""}</td> <td class="zahl"><b>${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}</b>${lohn ? " h" : fahrt ? " km" : ""}</td>
<td>${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" })}</td> <td>${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" })}</td>
<td>${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}` })}</td> <td>${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}` })}</td>
<td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })}</td> <td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })}</td>
<td class="zahl">${betrag(z.kosten * menge)}</td> <td class="zahl">${betrag(z.kosten * menge)}</td>
@@ -959,7 +961,8 @@ function kiHtml(z: Zustand, leistungen: Zeile[]): string {
function vorgabenHtml(d: Zeile, frei: boolean): string { function vorgabenHtml(d: Zeile, frei: boolean): string {
const a = d.angebot, s = d.saetze; const a = d.angebot, s = d.saetze;
const feld = feldBau(frei); const feld = feldBau(frei);
return `<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]}${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")} const v = s.stundensatz_version;
return `<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${lohnartenVon(s).map((x) => `<label>${esc(x.name)}${feld(`saetze:stundensaetze:${x.id}`, euroFeld(s.stundensaetze[x.id]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
<span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")} <span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")}
<span class="t">Wagnis und Gewinn</span> <span class="t">Wagnis und Gewinn</span>
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label> <label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
@@ -969,7 +972,22 @@ function vorgabenHtml(d: Zeile, frei: boolean): string {
<span class="t">Mengen</span> <span class="t">Mengen</span>
<label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label> <label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
<label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div> <label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div>
<p class="hinweis-k">Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.</p>`; <p class="hinweis-k">${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.</p>`;
}
/** A36: gelten heute andere Stundensätze, fragt das Angebot, ob es sie übernehmen soll */
const SAETZE_SO_LASSEN = new Set<string>();
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<string, number>;
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 `<div class="hinweis-band neue-saetze" role="status"><span>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."}</span>
<button class="haupt" data-a="saetze-neu">Übernehmen</button><button class="neben" data-a="saetze-alt">So lassen</button></div>`;
} }
const pruefungListe = (d: Zeile) => (d.pruefung.length const pruefungListe = (d: Zeile) => (d.pruefung.length
@@ -1063,7 +1081,7 @@ function titelleiste(d: Zeile, meldung: string): string {
return `<div class="kopf angebot-kopf am-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a> return `<div class="kopf angebot-kopf am-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)} · ${esc(a.projekt_name)}</span></h1>${angebotMarke(a)} <h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)} · ${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}
<span class="kopf-knoepfe">${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}</span></div> <span class="kopf-knoepfe">${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}</span></div>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}`; ${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}${neueSaetzeHtml(d)}`;
} }
/** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */ /** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */

View File

@@ -890,7 +890,7 @@ async function daten(): Promise<void> {
const kalkFelder: Feld[] = [ const kalkFelder: Feld[] = [
{ name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" }, { name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" },
{ name: "geselle", titel: "Stundensatz Geselle (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_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_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" }, { name: "z_fahrt", titel: "Zuschlag Fahrt (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" },
@@ -1121,7 +1121,7 @@ async function zeige(): Promise<void> {
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1]; const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
const mitarbeiter = /^mitarbeiter-([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) // 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 kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1];
const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1]; const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1];
const zuPersonal = mitarbeiter || personalTeil || kolonne || sub; const zuPersonal = mitarbeiter || personalTeil || kolonne || sub;
@@ -1173,6 +1173,7 @@ async function start(): Promise<void> {
sitzung = s; sitzung = s;
abgemeldet.melden = () => { location.hash = ""; location.reload(); }; abgemeldet.melden = () => { location.hash = ""; location.reload(); };
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter"); document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
document.body.classList.toggle("rolle-inhaber", s.benutzer.rolle === "inhaber");
REITER = reiterFuer(s); REITER = reiterFuer(s);
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join(""); nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
werLeiste(s); werLeiste(s);

View File

@@ -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 Auswertung, type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js"; import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js";
import { formatEuro, parseEuro } from "../domain/geld.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"; 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(".", ",")); 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; } } catch (e) { fehler = (e as Error).message; }
const k = (f: string) => `vb:ansaetze.${i}.${f}`; const k = (f: string) => `vb:ansaetze.${i}.${f}`;
return `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}"><td><select data-k="${k("kostenart")}" data-typ="roh" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ANSATZ_ARTEN, z.kostenart)}</select></td> return `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}"><td><select data-k="${k("kostenart")}" data-typ="roh" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ANSATZ_ARTEN, z.kostenart)}</select></td>
<td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td> <td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(lohnartOptionen(VORLAGE_LOHNARTEN, z.lohnart), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td>
<td>${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })}</td> <td>${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })}</td>
<td>${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 })}</td> <td>${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 })}</td>
<td>${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 })}</td> <td>${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 })}</td>

View File

@@ -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 { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js";
import { liste as tabelle } from "./liste.js"; import { liste as tabelle } from "./liste.js";
import { entscheiden } from "./urlaub.js"; import { entscheiden } from "./urlaub.js";
import { stundensaetzeTeil } from "./stundensaetze.js";
const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
const zahl = (h: number | null | undefined) => (h == null ? "" : String(Math.round(h * 100) / 100).replace(".", ",")); 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.`; return `${zahl(t.soll)} Std.`;
} }
const FUNKTION: Record<string, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; // Rolle = Lohnart der Stundensätze (M17): die Tabellen der heute geltenden Version, sonst Planer, Geselle, Helfer
const FUNKTIONEN = Object.entries(FUNKTION) as [string, string][]; const FUNKTION: Record<string, string> = { chef: "Chef", planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026) let FUNKTIONEN = Object.entries(FUNKTION).filter(([k]) => k !== "chef") as [string, string][];
const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"]]; async function rollenLaden(): Promise<void> {
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 subName = (k: Zeile) => (k.firma?.trim() ? k.firma : k.name) as string;
const prozent = (n: number | null | undefined) => (n == null ? "" : `${String(Number(n)).replace(".", ",")} %`); const prozent = (n: number | null | undefined) => (n == null ? "" : `${String(Number(n)).replace(".", ",")} %`);
/** Stunden pro Arbeitstag Mo–Do aus dem Arbeitszeitmodell (Woche Mo … So) */ /** 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 { function teileLeiste(aktiv: string): void {
const kopf = document.createElement("div"); const kopf = document.createElement("div");
kopf.className = "teile-kopf personal-teile"; kopf.className = "teile-kopf personal-teile";
kopf.innerHTML = `<nav class="teile">${TEILE.map(([t, titel]) => `<button data-teil="${t}" class="${t === aktiv ? "aktiv" : ""}">${titel}</button>`).join("")}</nav>`; const inhaber = document.body.classList.contains("rolle-inhaber");
kopf.innerHTML = `<nav class="teile">${TEILE.filter(([t]) => inhaber || t !== "stundensaetze").map(([t, titel]) => `<button data-teil="${t}" class="${t === aktiv ? "aktiv" : ""}">${titel}</button>`).join("")}</nav>`;
kopf.addEventListener("click", (ev) => { kopf.addEventListener("click", (ev) => {
const t = (ev.target as HTMLElement).closest<HTMLElement>("[data-teil]")?.dataset.teil; const t = (ev.target as HTMLElement).closest<HTMLElement>("[data-teil]")?.dataset.teil;
if (t) location.hash = t === "mitarbeiter" ? "personal" : `personal-${t}`; if (t) location.hash = t === "mitarbeiter" ? "personal" : `personal-${t}`;
@@ -58,7 +67,9 @@ export async function personalSeite(teil = "mitarbeiter"): Promise<void> {
if (teil === "subunternehmer") return subunternehmerTeil(); if (teil === "subunternehmer") return subunternehmerTeil();
if (teil === "urlaub") return urlaubTeil(); if (teil === "urlaub") return urlaubTeil();
if (teil === "zeiten") return zeitenTeil(); 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<Zeile[]>(`personal?heute=${heute()}`), api<Zeile>("terminplan"), api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"), api<Zeile[]>(`personal?heute=${heute()}`), api<Zeile>("terminplan"), api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
]); ]);
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter }); seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
@@ -485,6 +496,7 @@ async function neuerMitarbeiter(): Promise<void> {
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> { export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
const jahr = Number(heute().slice(0, 4)); const jahr = Number(heute().slice(0, 4));
const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10); 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([ const [kontakt, liste, alleStamm, modelle, abw, konten, verf, kolonnen, mitglieder] = await Promise.all([
api<Zeile>(`kontakte/${kontaktId}`), api<Zeile>(`kontakte/${kontaktId}`),
api<Zeile[]>(`personal?heute=${heute()}`), api<Zeile[]>(`personal?heute=${heute()}`),

View File

@@ -5,7 +5,7 @@
import { type Auswertung, alsBlatt, werteBlatt } from "../domain/mengenblatt.js"; import { type Auswertung, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
import type { Ansatz, Mengenvorlage } from "../domain/mengenvorlagen.js"; import type { Ansatz, Mengenvorlage } from "../domain/mengenvorlagen.js";
import { formatEuro, parseEuro } from "../domain/geld.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 { zahlDeutsch } from "../domain/formel.js";
import { dateiText } from "../domain/kodierung.js"; import { dateiText } from "../domain/kodierung.js";
import { type Datanorm, ekNetto, leseDatanorm } from "../domain/datanorm.js"; import { type Datanorm, ekNetto, leseDatanorm } from "../domain/datanorm.js";
@@ -269,7 +269,7 @@ export async function leistungSeite(id: string): Promise<void> {
<td>${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 ? `<span class="am-fehler">${esc(r.fehler)}</span>` : ""}</td> <td>${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 ? `<span class="am-fehler">${esc(r.fehler)}</span>` : ""}</td>
<td>${feld(k("menge"), zahlText(z.menge), { titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", klasse: "zahl w-ansatz am-eingabe", typ: "zahl" })}</td> <td>${feld(k("menge"), zahlText(z.menge), { titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", klasse: "zahl w-ansatz am-eingabe", typ: "zahl" })}</td>
<td>${mitPers ? feld(k("personen"), zahlText(z.personen ?? 1), { titel: fahrt ? "Fahrzeuge" : "Personen", klasse: "zahl w-pers am-eingabe", typ: "zahl" }) : ""}</td> <td>${mitPers ? feld(k("personen"), zahlText(z.personen ?? 1), { titel: fahrt ? "Fahrzeuge" : "Personen", klasse: "zahl w-pers am-eingabe", typ: "zahl" }) : ""}</td>
<td>${lohn ? `<select data-k="${k("lohnart")}" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>` <td>${lohn ? `<select data-k="${k("lohnart")}" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(lohnartOptionen(lohnartenVon(s), z.lohnart), z.lohnart ?? "geselle")}</select>`
: fahrt ? "km" : feld(k("einheit"), z.einheit, { titel: "Einheit", klasse: "w-einheit", liste: "sd-einheiten" })}</td> : fahrt ? "km" : feld(k("einheit"), z.einheit, { titel: "Einheit", klasse: "w-einheit", liste: "sd-einheiten" })}</td>
<td>${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", <td>${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" })}</td> platz: lohn ? euroFeld(s.stundensaetze[z.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00" })}</td>

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

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

View File

@@ -1754,3 +1754,73 @@ button.speichern-gruen:hover { background: var(--ein); }
} }
.handy-reiter.nur-handy { display: none; } .handy-reiter.nur-handy { display: none; }
@media (max-width: 640px) { .handy-reiter.nur-handy { display: flex; } } @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); }

View File

@@ -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/projekte")).statusCode).toBe(200);
expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403); expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403);
expect((await als(b, "GET", "/api/export")).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); expect((await als(b, "PATCH", `/api/projekte/${p2.id}`, { notiz: "Büro war hier" })).statusCode).toBe(200);
const j = await anmelden("jan", "jan123456"); 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: "" }]); .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);
});
});

85
test/stundensatz.test.ts Normal file
View File

@@ -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);
});
});