Neue Angebotsmaske: Mengenblatt mit Formeln, Musterpositionen und Mengenvorlagen im Katalog, Kostenzeilen mit Bezug, Subunternehmer (0.17.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:
@@ -4,11 +4,13 @@
|
||||
// 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";
|
||||
|
||||
export const KOSTENARTEN = ["lohn", "material", "geraet", "sonstiges"] as const;
|
||||
// Subunternehmer eigene Kostenart mit eigenem Zuschlag (Bild 2 vom 21.10.2026)
|
||||
export const KOSTENARTEN = ["lohn", "material", "geraet", "subunternehmer", "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",
|
||||
lohn: "Lohn", material: "Material", geraet: "Gerät", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
|
||||
};
|
||||
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
|
||||
export type Lohnart = (typeof LOHNARTEN)[number];
|
||||
@@ -43,6 +45,13 @@ export interface Saetze {
|
||||
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 };
|
||||
}
|
||||
|
||||
/** feste Größen, die jedes Mengenblatt kennt */
|
||||
export function umgebungVon(s: Pick<Saetze, "mengen">): Record<string, number> {
|
||||
return { VERSCHNITT: (s.mengen?.verschnitt ?? 10) / 100, ÖFFNUNG_AB: s.mengen?.oeffnung_ab ?? 2.5 };
|
||||
}
|
||||
|
||||
export interface KKosten {
|
||||
@@ -58,6 +67,11 @@ export interface KKosten {
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -71,6 +85,13 @@ export interface KPosition {
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -83,6 +104,10 @@ export interface KTitel {
|
||||
|
||||
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) */
|
||||
@@ -90,13 +115,16 @@ export interface PositionErgebnis {
|
||||
/** 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<Kostenart, number>;
|
||||
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number }[];
|
||||
/** 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 {
|
||||
@@ -155,28 +183,52 @@ 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<Kostenart, number>;
|
||||
|
||||
/** Mengenblatt einer Position ausrechnen (nur wenn Aufmaß an ist) */
|
||||
export function aufmassVon(p: Pick<KPosition, "mit_aufmass" | "aufmass">, s: Pick<Saetze, "mengen">): 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 = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record<Kostenart, number>;
|
||||
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 kz = zahl(k.menge) * ek * zahl(k.faktor, 1);
|
||||
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.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;
|
||||
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 });
|
||||
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 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);
|
||||
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, 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,
|
||||
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,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -190,7 +242,7 @@ export function berechneAngebot(
|
||||
}
|
||||
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]>;
|
||||
const arten = Object.fromEntries([...KOSTENARTEN, "ohne"].map((a) => [a, [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);
|
||||
@@ -200,9 +252,8 @@ export function berechneAngebot(
|
||||
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);
|
||||
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));
|
||||
@@ -254,18 +305,28 @@ export function pruefeAngebot(
|
||||
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 (!(zahl(x.menge) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, 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.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) {
|
||||
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) {
|
||||
@@ -273,9 +334,10 @@ export function pruefeAngebot(
|
||||
}
|
||||
}
|
||||
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)!;
|
||||
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 });
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user