// Angebotskalkulation (Stufe 3a, A2, A19, A28, A32, A37): je Position Kostenzeilen für Lohn, Material, Gerät und // Sonstiges. Kosten je Einheit = Menge × EK × Faktor; Verkauf = Kosten × (1 + Zuschlag) × (1 + Wagnis + Gewinn + // Zahlungsausfall). Der Einheitspreis wird auf den Cent gerundet, Gesamt = Menge × EP, Netto = Summe der Positionen, // die zählen. So gibt es keine Rundungsabweichung wie in Plancraft: Zuschlag in € = Verkauf − Kosten. import type { Cent } from "./geld.js"; import { prozentVon } from "./geld.js"; import { type Auswertung, type Blatt, alsBlatt, fehlendePlatzhalter, werteBlatt } from "./mengenblatt.js"; // Subunternehmer eigene Kostenart mit eigenem Zuschlag (Bild 2 vom 21.10.2026); Fahrt für Fahrt- und Transportkosten: // 2 × Strecke × Einsatztage × Fahrzeuge in km, EK je km (Henning, 21.10.2026) export const KOSTENARTEN = ["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"] as const; export type Kostenart = (typeof KOSTENARTEN)[number]; export const KOSTENART_NAME: Record = { lohn: "Lohn", material: "Material", geraet: "Gerät", fahrt: "Fahrt", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation", }; // Lohnarten ohne Stundensatz-Tabellen; mit Tabellen (M17) sind es deren Schlüssel und der Mittellohn export const LOHNARTEN = ["planer", "geselle", "helfer"] as const; export type Lohnart = string; export const LOHNART_NAME: Record = { planer: "Planer", geselle: "Geselle", helfer: "Helfer", chef: "Chef", mittellohn: "Mittellohn" }; /** Lohnarten, die ein Angebot kennt: aus den festgeschriebenen Stundensatz-Tabellen oder die drei festen */ export function lohnartenVon(s: Pick): { id: string; name: string }[] { if (s.lohnarten?.length) return s.lohnarten; return Object.keys(s.stundensaetze).map((id) => ({ id, name: LOHNART_NAME[id] ?? id })); } /** Auswahl für eine Lohnzeile; eine Lohnart, die das Angebot nicht kennt, bleibt sichtbar */ export function lohnartOptionen(liste: { id: string; name: string }[], aktuell: string | null | undefined): [string, string][] { const o = liste.map((x): [string, string] => [x.id, x.name]); if (aktuell && !o.some(([id]) => id === aktuell)) o.push([aktuell, LOHNART_NAME[aktuell] ?? aktuell]); return o; } /** Lohnarten für Vorlagen ohne Angebot: Mittellohn und die üblichen Tabellen */ export const VORLAGE_LOHNARTEN = ["mittellohn", "chef", "planer", "geselle", "helfer"].map((id) => ({ id, name: LOHNART_NAME[id]! })); /** Lohnart neuer Lohnzeilen: Mittellohn, wenn das Angebot einen hat, sonst Geselle */ export const standardLohnart = (s: Pick) => (s.stundensaetze.mittellohn != null ? "mittellohn" : "geselle"); // A28: Alternativ- und Eventualpositionen stehen mit Preis da, zählen aber nicht; „eventual_summe“ ist einkalkuliert export const POSITIONSARTEN = ["normal", "alternativ", "eventual", "eventual_summe"] as const; export type Positionsart = (typeof POSITIONSARTEN)[number]; export const POSITIONSART_NAME: Record = { normal: "Normal", alternativ: "Alternativ", eventual: "Eventual", eventual_summe: "Eventual, einkalkuliert", }; export const zaehlt = (art: Positionsart | string | null | undefined) => !art || art === "normal" || art === "eventual_summe"; // VOB/C ATV DIN 18334, Abschnitt 0.5 (Henning, 19.10.2026): einheitliche Schreibweise export const EINHEITEN = ["m", "m²", "m³", "St", "kg", "t", "h", "psch"] as const; const SCHREIBWEISE: Record = { lfm: "m", lfdm: "m", "m1": "m", m2: "m²", qm: "m²", m3: "m³", cbm: "m³", stk: "St", "stk.": "St", stck: "St", "st.": "St", stück: "St", std: "h", "std.": "h", stunde: "h", stunden: "h", psch: "psch", "psch.": "psch", pauschal: "psch", pausch: "psch", }; /** Richtige Schreibweise einer Einheit, oder undefined, wenn sie unbekannt ist */ export function einheitRichtig(e: string): string | undefined { const t = e.trim(); if ((EINHEITEN as readonly string[]).includes(t)) return t; return SCHREIBWEISE[t.toLowerCase()]; } export interface Saetze { /** EK-Stundensätze in Cent je Lohnart, beim Anlegen des Angebots festgeschrieben (A36) */ stundensaetze: Record; /** Lohnarten mit Namen aus den Stundensatz-Tabellen (M17), Mittellohn zuerst */ lohnarten?: { id: string; name: string }[]; /** Version der Stundensätze, aus der die Sätze stammen */ stundensatz_version?: { id: string; name: string; gilt_ab: string } | null; /** Standardzuschläge in % je Kostenart */ zuschlaege: Record; wagnis: number; gewinn: number; ausfall: number; /** Vorgaben für Mengenblätter: Verschnitt in %, Öffnungen werden ab dieser Fläche (m²) abgezogen (E28) */ mengen?: { verschnitt: number; oeffnung_ab: number }; /** EK je gefahrenem km in Cent, Vorschlag für Fahrtkosten */ kilometersatz?: Cent; } /** feste Größen, die jedes Mengenblatt kennt */ export function umgebungVon(s: Pick): Record { return { VERSCHNITT: (s.mengen?.verschnitt ?? 10) / 100, ÖFFNUNG_AB: s.mengen?.oeffnung_ab ?? 2.5 }; } export interface KKosten { id?: string; position_id: string; kostenart: Kostenart; lohnart?: Lohnart | null; beschreibung?: string | null; /** je Einheit der Position, bei Lohn in Stunden */ menge: number | string; einheit?: string | null; /** Cent je Einheit der Kostenzeile; bei Lohn ohne Wert gilt der Stundensatz der Lohnart */ ek?: number | string | null; faktor?: number | string | null; zuschlag_prozent?: number | string | null; /** Kürzel oder Formel aus dem Mengenblatt; leer = Menge der Position, „menge“ ist dann je Einheit */ bezug?: string | null; personen?: number | string | null; /** abgewählt („nicht notwendig“): bleibt sichtbar, zählt nicht */ aktiv?: boolean | null; reihenfolge?: number; } export interface KPosition { id: string; titel_id?: string | null; oz?: string | null; kurztext: string; menge: number | string; einheit: string; art?: Positionsart | null; /** fester Einheitspreis in Cent (Position ohne Kalkulation oder „Preis anpassen“) */ ep_fest?: number | string | null; /** aus: fester Preis (ep_fest); an: Preis aus den Kostenzeilen, ep_fest ist dann „Preis anpassen“ */ mit_kalkulation?: boolean | null; /** an: die Menge kommt aus dem Mengenblatt */ mit_aufmass?: boolean | null; aufmass?: Blatt | null; /** reine Textzeile im Leistungsverzeichnis, ohne Menge und Preis */ textzeile?: boolean | null; reihenfolge?: number; } export interface KTitel { id: string; oz?: string | null; bezeichnung: string; reihenfolge?: number; } export interface PositionErgebnis { id: string; /** Menge, mit der gerechnet wird: aus dem Mengenblatt, wenn Aufmaß an ist */ menge: number; /** Fehler im Mengenblatt (dann zählt die eingetragene Menge) */ aufmass_fehler: string | null; /** Einheitspreis in Cent */ ep: Cent; /** Gesamtbetrag in Cent (zählt nur bei normal und eventual_summe) */ gb: Cent; /** Einheitspreis aus der Kalkulation, auch wenn ein fester Preis gilt */ ep_kalkuliert: Cent; kosten_je_einheit: Cent; /** Kosten der ganzen Position (ungerundet je Einheit × Menge, dann auf Cent) */ kosten_gesamt: Cent; /** Stunden je Einheit und gesamt */ std_je_einheit: number; stunden: number; zaehlt: boolean; /** Verkauf je Kostenart (Cent je Einheit, ungerundet) für die Kalkulationsübersicht */ vk_je_einheit: Record; /** je Kostenzeile, in der Reihenfolge der Zeilen: Kosten und Verkauf je Einheit, Menge für die ganze Position */ kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number; menge_gesamt: number; aktiv: boolean; fehler: string | null }[]; } export interface KostenartSumme { kosten: Cent; verkauf: Cent; zuschlag: Cent; /** Zuschlag in % der Kosten (null ohne Kosten) */ prozent: number | null; } export interface AngebotErgebnis { positionen: Record; titel: Record; netto: Cent; ust: Cent; brutto: Cent; stunden: number; kosten: Cent; /** „möglicher Überschuss“ wie in Plancraft: (Netto − Kosten) / Kosten */ ueberschuss_prozent: number | null; kostenarten: Record; /** Verkaufswert je Lohnstunde */ stundensatz_verkauf: Cent | null; /** § 35a EStG (A34): Arbeits- und Maschinenkosten brutto, für Privatkunden */ arbeitskosten_brutto: Cent; } const zahl = (v: number | string | null | undefined, sonst = 0) => (v === null || v === undefined || v === "" ? sonst : Number(v)); /** Kaufmännisch auf ganze Cent; kleine Gleitkommafehler (2,675 → 267,49999…) werden vorher ausgeglichen */ export function rundeCent(x: number): Cent { const a = Math.abs(x); const r = Math.floor(a + 0.5 + 1e-7); return x < 0 ? -r : r; } /** Ein Betrag nach Gewichten aufgeteilt, Rest nach größtem Bruchteil (Summe stimmt auf den Cent) */ export function verteile(betrag: Cent, gewichte: number[]): Cent[] { const summe = gewichte.reduce((s, g) => s + g, 0); if (!(summe > 0)) return gewichte.map(() => 0); const roh = gewichte.map((g) => (betrag * g) / summe); const teile = roh.map((r) => Math.floor(r + 1e-9)); let rest = betrag - teile.reduce((s, t) => s + t, 0); const reihenfolge = roh.map((r, i) => [r - Math.floor(r + 1e-9), i] as const).sort((a, b) => b[0] - a[0]); for (let k = 0; rest > 0 && k < reihenfolge.length; k++, rest--) teile[reihenfolge[k]![1]]! += 1; return teile; } /** EK einer Kostenzeile in Cent je ihrer Einheit */ export function ekVon(k: KKosten, s: Saetze): number { if (k.ek !== null && k.ek !== undefined && k.ek !== "") return Number(k.ek); if (k.kostenart === "fahrt") return s.kilometersatz ?? 50; return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? s.stundensaetze.geselle ?? 0 : 0; } export function zuschlagVon(k: KKosten, s: Saetze): number { return k.zuschlag_prozent === null || k.zuschlag_prozent === undefined || k.zuschlag_prozent === "" ? s.zuschlaege[k.kostenart] ?? 0 : Number(k.zuschlag_prozent); } const leereArten = () => Object.fromEntries(KOSTENARTEN.map((a) => [a, 0])) as Record; /** Mengenblatt einer Position ausrechnen (nur wenn Aufmaß an ist) */ export function aufmassVon(p: Pick, s: Pick): Auswertung | null { return p.mit_aufmass && p.aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(s)) : null; } export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis { const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100; const vk = leereArten(); let kostenSumme = 0, std = 0; const zeilen = []; const blatt = aufmassVon(p, s); const aufmassFehler = blatt ? (Object.values(blatt.fehler)[0] ?? (blatt.menge === null ? "keine Menge" : null)) : null; const menge = p.textzeile ? 0 : blatt && blatt.menge !== null && !blatt.fehler.menge ? blatt.menge : zahl(p.menge); const kalk = p.mit_kalkulation !== false && !p.textzeile; for (const k of kosten) { const ek = ekVon(k, s); const z = zuschlagVon(k, s); const personen = zahl(k.personen, 1); // Menge je Einheit der Position; mit Bezug: Bezug × Ansatz × Personen für die ganze Position let jeEinheit = zahl(k.menge) * personen, gesamt = jeEinheit * menge, fehler: string | null = null; if (k.kostenart === "fahrt") { // Fahrt: Bezug = Strecke einfach in km, Ansatz = Einsatztage, Personen = Fahrzeuge; hin und zurück try { if (!k.bezug || !k.bezug.trim()) throw new Error("Strecke in km fehlt"); const umg = blatt ?? werteBlatt({ werte: [], listen: [], zeilen: [] }, umgebungVon(s)); gesamt = 2 * umg.rechne(k.bezug) * zahl(k.menge) * personen; jeEinheit = menge > 0 ? gesamt / menge : 0; } catch (e) { fehler = (e as Error).message; gesamt = 0; jeEinheit = 0; } } else if (k.bezug && k.bezug.trim()) { try { const umg = blatt ?? werteBlatt({ werte: [], listen: [], zeilen: [] }, umgebungVon(s)); const bezug = /^\s*menge\s*$/i.test(k.bezug) ? menge : umg.rechne(k.bezug.replace(/\bMENGE\b/g, String(menge))); gesamt = bezug * zahl(k.menge) * personen; jeEinheit = menge > 0 ? gesamt / menge : 0; } catch (e) { fehler = (e as Error).message; gesamt = 0; jeEinheit = 0; } } const aktiv = k.aktiv !== false; const kz = aktiv ? jeEinheit * ek * zahl(k.faktor, 1) : 0; const v = kz * (1 + z / 100) * wg; if (kalk) { kostenSumme += kz; vk[k.kostenart] += v; if (k.kostenart === "lohn" && aktiv) std += jeEinheit; } zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z, menge_gesamt: Math.round(gesamt * 10000) / 10000, aktiv, fehler }); } const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0)); const fest = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : null; const ep = p.textzeile ? 0 : kalk ? fest ?? epKalk : fest ?? 0; return { id: p.id, menge, aufmass_fehler: aufmassFehler, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme), kosten_gesamt: rundeCent(kostenSumme * menge), std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: !p.textzeile && zaehlt(p.art), vk_je_einheit: vk, kostenzeilen: zeilen, }; } export function berechneAngebot( a: { ust_satz?: number }, titel: KTitel[], positionen: KPosition[], kosten: KKosten[], s: Saetze, ): AngebotErgebnis { const jePosition = new Map(); for (const k of [...kosten].sort((x, y) => (x.reihenfolge ?? 0) - (y.reihenfolge ?? 0))) { jePosition.set(k.position_id, [...(jePosition.get(k.position_id) ?? []), k]); } const erg: Record = {}; const titelSumme: Record = Object.fromEntries(titel.map((t) => [t.id, 0])); const arten = Object.fromEntries([...KOSTENARTEN, "ohne"].map((a) => [a, [0, 0]])) as Record; let netto = 0, stunden = 0; for (const p of positionen) { const r = berechnePosition(p, jePosition.get(p.id) ?? [], s); erg[p.id] = r; if (!r.zaehlt) continue; netto += r.gb; stunden += r.stunden; if (p.titel_id && p.titel_id in titelSumme) titelSumme[p.titel_id]! += r.gb; // Kosten und Verkauf je Kostenart: der Gesamtbetrag der Position wird nach den Verkaufswerten aufgeteilt if (p.mit_kalkulation !== false) { (jePosition.get(p.id) ?? []).forEach((k, i) => (arten[k.kostenart][0] += r.menge * (r.kostenzeilen[i]?.kosten ?? 0))); } const gewichte = KOSTENARTEN.map((x) => r.vk_je_einheit[x]); if (gewichte.some((g) => g > 0)) verteile(r.gb, gewichte).forEach((t, i) => (arten[KOSTENARTEN[i]!][1] += t)); else arten.ohne[1] += r.gb; } const kostenarten = {} as Record; let kostenGesamt = 0; for (const [art, [k, v]] of Object.entries(arten) as [Kostenart | "ohne", [number, Cent]][]) { const kc = rundeCent(k); kostenGesamt += kc; kostenarten[art] = { kosten: kc, verkauf: v, zuschlag: v - kc, prozent: kc > 0 ? Math.round(((v - kc) / kc) * 10000) / 100 : null }; } const satz = a.ust_satz ?? 19; const ust = prozentVon(netto, satz); const arbeit = kostenarten.lohn.verkauf + kostenarten.geraet.verkauf; return { positionen: erg, titel: titelSumme, netto, ust, brutto: netto + ust, stunden: Math.round(stunden * 100) / 100, kosten: kostenGesamt, ueberschuss_prozent: kostenGesamt > 0 ? Math.round(((netto - kostenGesamt) / kostenGesamt) * 1000) / 10 : null, kostenarten, stundensatz_verkauf: stunden > 0 ? rundeCent(kostenarten.lohn.verkauf / stunden) : null, arbeitskosten_brutto: arbeit + prozentVon(arbeit, satz), }; } export interface Pruefpunkt { /** fehler: so nicht versenden; hinweis: bitte ansehen */ stufe: "fehler" | "hinweis"; text: string; position_id?: string; } const PLATZHALTER = [/\bx-[^\s]*-x\b/i, /\?\?\?/, /\bxxx+\b/i, /\[\s*\]/, /<\s*bitte[^>]*>/i, /\.\.\.\s*$/]; /** A14 Versandprüfung: Platzhalter, Preise, Einheiten, Bindefrist */ export function pruefeAngebot( a: { datum: string; bindefrist?: string | null; kopftext?: string | null; schlusstext?: string | null; betreff?: string | null; empfaenger?: boolean }, titel: KTitel[], positionen: KPosition[], kosten: KKosten[], e: AngebotErgebnis, langtexte: Record = {}, ): Pruefpunkt[] { const p: Pruefpunkt[] = []; const name = (x: KPosition) => `${x.oz ? `${x.oz} ` : ""}${x.kurztext}`; if (!positionen.length) p.push({ stufe: "fehler", text: "Das Angebot hat noch keine Position." }); if (a.empfaenger === false) p.push({ stufe: "fehler", text: "Beim Projekt ist kein Bauherr als Empfänger eingetragen." }); if (a.bindefrist && a.bindefrist < a.datum) p.push({ stufe: "fehler", text: "Die Bindefrist liegt vor dem Angebotsdatum." }); for (const [feld, text] of [["Betreff", a.betreff], ["Einleitung", a.kopftext], ["Schlusstext", a.schlusstext]] as const) { if (text && PLATZHALTER.some((r) => r.test(text))) p.push({ stufe: "fehler", text: `Im ${feld} steht noch ein Platzhalter.` }); } for (const t of titel) { if (/^neuer titel$/i.test(t.bezeichnung.trim())) p.push({ stufe: "fehler", text: "Ein Titel heißt noch „Neuer Titel“." }); if (!positionen.some((x) => x.titel_id === t.id)) p.push({ stufe: "hinweis", text: `Titel „${t.bezeichnung}“ hat keine Position.` }); } const ids = new Set(positionen.map((x) => x.id)); const saetzeLeer = { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: leereArten(), wagnis: 0, gewinn: 0, ausfall: 0 }; for (const x of positionen) { const r = e.positionen[x.id]; if (x.textzeile) { if (PLATZHALTER.some((re) => re.test(x.kurztext))) p.push({ stufe: "fehler", text: `Textzeile „${x.kurztext.slice(0, 30)}“: Platzhalter im Text.`, position_id: x.id }); continue; } if (r?.aufmass_fehler) p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Aufmaß ist ein Fehler (${r.aufmass_fehler}).`, position_id: x.id }); const fehlend = [...fehlendePlatzhalter(x.kurztext, aufmassVon(x, { mengen: undefined })), ...fehlendePlatzhalter(langtexte[x.id], aufmassVon(x, { mengen: undefined }))]; if (fehlend.length) p.push({ stufe: "fehler", text: `Position ${name(x)}: {${fehlend[0]}} im Text gibt es im Mengenblatt nicht.`, position_id: x.id }); const kaputt = r?.kostenzeilen.find((z) => z.fehler); if (kaputt && x.mit_kalkulation !== false) p.push({ stufe: "fehler", text: `Position ${name(x)}: Bezug einer Kostenzeile geht nicht (${kaputt.fehler}).`, position_id: x.id }); if (/^neue position$/i.test(x.kurztext.trim())) p.push({ stufe: "fehler", text: `Position ${name(x)}: Der Kurztext fehlt noch.`, position_id: x.id }); else if (PLATZHALTER.some((re) => re.test(x.kurztext) || re.test(langtexte[x.id] ?? ""))) { p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Text steht noch ein Platzhalter.`, position_id: x.id }); } if (!((r?.menge ?? zahl(x.menge)) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, position_id: x.id }); if (r && r.ep <= 0) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keinen Preis.`, position_id: x.id }); const richtig = einheitRichtig(x.einheit); if (!richtig) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ gibt es nach DIN 18334 nicht.`, position_id: x.id }); else if (richtig !== x.einheit) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ bitte als „${richtig}“ schreiben.`, position_id: x.id }); if (r && x.mit_kalkulation !== false && x.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) { p.push({ stufe: "hinweis", text: `Position ${name(x)}: Der feste Preis liegt unter den Kosten.`, position_id: x.id }); } if (x.art === "alternativ" && !(x as { grundposition_id?: string | null }).grundposition_id) { p.push({ stufe: "hinweis", text: `Alternativposition ${name(x)} ist keiner Grundposition zugeordnet.`, position_id: x.id }); } } for (const k of kosten) { if (!ids.has(k.position_id) || k.aktiv === false) continue; const x = positionen.find((y) => y.id === k.position_id)!; if (x.mit_kalkulation === false || x.textzeile) continue; if (k.kostenart !== "lohn" && !(ekVon(k, saetzeLeer) > 0)) { p.push({ stufe: "hinweis", text: `Position ${name(x)}: ${KOSTENART_NAME[k.kostenart]} „${k.beschreibung || "ohne Text"}“ hat keinen Preis.`, position_id: x.id }); } } return p; } /** Nächste freie Angebotsnummer im Jahr, Format A-26-121 (wie in Plancraft) */ export function naechsteNummer(vorhanden: string[], jahr: number): string { const jj = String(jahr % 100).padStart(2, "0"); let max = 0; for (const n of vorhanden) { const m = /^[AP]-(\d{2})-(\d{1,4})/.exec(n.trim()); if (m && m[1] === jj) max = Math.max(max, Number(m[2])); } return `A-${jj}-${String(max + 1).padStart(3, "0")}`; }