Angebote mit Kalkulation: Leistungsverzeichnis, Kostenzeilen, Versandprüfung, Annehmen macht den Auftrag (0.16.0)
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:
294
src/domain/kalkulation.ts
Normal file
294
src/domain/kalkulation.ts
Normal file
@@ -0,0 +1,294 @@
|
||||
// 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";
|
||||
|
||||
export const KOSTENARTEN = ["lohn", "material", "geraet", "sonstiges"] as const;
|
||||
export type Kostenart = (typeof KOSTENARTEN)[number];
|
||||
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
|
||||
lohn: "Lohn", material: "Material", geraet: "Gerät", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
|
||||
};
|
||||
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
|
||||
export type Lohnart = (typeof LOHNARTEN)[number];
|
||||
export const LOHNART_NAME: Record<Lohnart, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
|
||||
|
||||
// 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<Positionsart, string> = {
|
||||
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<string, string> = {
|
||||
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<Lohnart, Cent>;
|
||||
/** Standardzuschläge in % je Kostenart */
|
||||
zuschlaege: Record<Kostenart, number>;
|
||||
wagnis: number;
|
||||
gewinn: number;
|
||||
ausfall: number;
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
export interface KTitel {
|
||||
id: string;
|
||||
oz?: string | null;
|
||||
bezeichnung: string;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
export interface PositionErgebnis {
|
||||
id: string;
|
||||
/** 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;
|
||||
/** 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<Kostenart, number>;
|
||||
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number }[];
|
||||
}
|
||||
|
||||
export interface KostenartSumme {
|
||||
kosten: Cent;
|
||||
verkauf: Cent;
|
||||
zuschlag: Cent;
|
||||
/** Zuschlag in % der Kosten (null ohne Kosten) */
|
||||
prozent: number | null;
|
||||
}
|
||||
|
||||
export interface AngebotErgebnis {
|
||||
positionen: Record<string, PositionErgebnis>;
|
||||
titel: Record<string, Cent>;
|
||||
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<Kostenart | "ohne", KostenartSumme>;
|
||||
/** 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);
|
||||
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "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);
|
||||
}
|
||||
|
||||
export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis {
|
||||
const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100;
|
||||
const vk = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record<Kostenart, number>;
|
||||
let kostenSumme = 0, std = 0;
|
||||
const zeilen = [];
|
||||
for (const k of kosten) {
|
||||
const ek = ekVon(k, s);
|
||||
const z = zuschlagVon(k, s);
|
||||
const kz = zahl(k.menge) * ek * zahl(k.faktor, 1);
|
||||
const v = kz * (1 + z / 100) * wg;
|
||||
kostenSumme += kz;
|
||||
vk[k.kostenart] += v;
|
||||
if (k.kostenart === "lohn") std += zahl(k.menge);
|
||||
zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z });
|
||||
}
|
||||
const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0));
|
||||
const ep = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : epKalk;
|
||||
const menge = zahl(p.menge);
|
||||
const z = zaehlt(p.art);
|
||||
return {
|
||||
id: p.id, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme),
|
||||
std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: z, 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<string, KKosten[]>();
|
||||
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<string, PositionErgebnis> = {};
|
||||
const titelSumme: Record<string, Cent> = Object.fromEntries(titel.map((t) => [t.id, 0]));
|
||||
const arten = { lohn: [0, 0], material: [0, 0], geraet: [0, 0], sonstiges: [0, 0], ohne: [0, 0] } as Record<Kostenart | "ohne", [number, Cent]>;
|
||||
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
|
||||
const menge = zahl(p.menge);
|
||||
for (const k of jePosition.get(p.id) ?? []) {
|
||||
arten[k.kostenart][0] += menge * zahl(k.menge) * ekVon(k, s) * zahl(k.faktor, 1);
|
||||
}
|
||||
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<Kostenart | "ohne", KostenartSumme>;
|
||||
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<string, string | null | undefined> = {},
|
||||
): 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));
|
||||
for (const x of positionen) {
|
||||
const r = e.positionen[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 (!(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.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)) continue;
|
||||
if (k.kostenart !== "lohn" && !(ekVon(k, { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: { lohn: 0, material: 0, geraet: 0, sonstiges: 0 }, wagnis: 0, gewinn: 0, ausfall: 0 }) > 0)) {
|
||||
const x = positionen.find((y) => y.id === k.position_id)!;
|
||||
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")}`;
|
||||
}
|
||||
@@ -78,7 +78,7 @@ export function einsatzMatrix(vorgaenge: UeVorgang[], besetzungen: UeBesetzung[]
|
||||
}
|
||||
|
||||
export interface Warnung {
|
||||
art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung";
|
||||
art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung" | "angebot";
|
||||
text: string;
|
||||
/** Sprungziel in der App, z. B. "terminplan" */
|
||||
ziel: string;
|
||||
|
||||
Reference in New Issue
Block a user