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:
302
src/domain/formel.ts
Normal file
302
src/domain/formel.ts
Normal file
@@ -0,0 +1,302 @@
|
||||
// Formeln für Aufmaß und Mengenblatt (Stufe 3a, A22, Henning 21.10.2026): rechnen mit Kürzeln statt Zellbezügen,
|
||||
// z. B. (B/2+UET)/cos(DN). Komma oder Punkt als Dezimalzeichen, Semikolon trennt Argumente: runden(x; 2).
|
||||
// Winkel in Grad wie auf der Baustelle. Ein unbekanntes Kürzel ist ein Fehler, keine stille Null.
|
||||
|
||||
export type Wert = number | string;
|
||||
|
||||
export class FormelFehler extends Error {}
|
||||
|
||||
type Knoten =
|
||||
| { t: "n"; v: number }
|
||||
| { t: "s"; v: string }
|
||||
| { t: "id"; name: string }
|
||||
| { t: "f"; name: string; args: Knoten[] }
|
||||
| { t: "op"; op: string; a: Knoten; b: Knoten }
|
||||
| { t: "neg"; a: Knoten }
|
||||
| { t: "pct"; a: Knoten };
|
||||
|
||||
type Token = { t: "n"; v: number } | { t: "s"; v: string } | { t: "id"; v: string } | { t: "o"; v: string };
|
||||
|
||||
const BUCHSTABE = /[\p{L}_]/u;
|
||||
const ZEICHEN = /[\p{L}\p{N}_]/u;
|
||||
|
||||
function zerlege(f: string): Token[] {
|
||||
const t: Token[] = [];
|
||||
let i = 0;
|
||||
while (i < f.length) {
|
||||
const c = f[i]!;
|
||||
if (/\s/.test(c)) { i++; continue; }
|
||||
if (/\d/.test(c) || (c === "," || c === ".") && /\d/.test(f[i + 1] ?? "")) {
|
||||
const m = /^\d*(?:[.,]\d+)?/.exec(f.slice(i))!;
|
||||
t.push({ t: "n", v: Number(m[0].replace(",", ".")) });
|
||||
i += m[0].length;
|
||||
// „2,5 m“ oder „31°“: Einheit hinter einer Zahl überlesen
|
||||
const e = /^\s*(?:°|m³|m²|m(?![\p{L}\p{N}_(]))/u.exec(f.slice(i));
|
||||
if (e) i += e[0].length;
|
||||
continue;
|
||||
}
|
||||
if (c === '"' || c === "„" || c === "“" || c === "'") {
|
||||
const ende = f.slice(i + 1).search(/["“”']/);
|
||||
if (ende < 0) throw new FormelFehler("Anführungszeichen nicht geschlossen");
|
||||
t.push({ t: "s", v: f.slice(i + 1, i + 1 + ende) });
|
||||
i += ende + 2;
|
||||
continue;
|
||||
}
|
||||
if (BUCHSTABE.test(c)) {
|
||||
let j = i + 1;
|
||||
while (j < f.length && (ZEICHEN.test(f[j]!) || (f[j] === "." && BUCHSTABE.test(f[j + 1] ?? "")))) j++;
|
||||
t.push({ t: "id", v: f.slice(i, j) });
|
||||
i = j;
|
||||
continue;
|
||||
}
|
||||
const zwei = f.slice(i, i + 2);
|
||||
if (["<>", "!=", "<=", ">="].includes(zwei)) { t.push({ t: "o", v: zwei === "!=" ? "<>" : zwei }); i += 2; continue; }
|
||||
const eins: Record<string, string> = { "×": "*", "·": "*", "≠": "<>", "≤": "<=", "≥": ">=", "−": "-", ",": ";" };
|
||||
if ("+-*/^();%=<>".includes(c) || c in eins) { t.push({ t: "o", v: eins[c] ?? c }); i++; continue; }
|
||||
throw new FormelFehler(`Zeichen „${c}“ ist nicht erlaubt`);
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
function parse(f: string): Knoten {
|
||||
const t = zerlege(f);
|
||||
let i = 0;
|
||||
const ist = (v: string) => t[i]?.t === "o" && t[i]!.v === v;
|
||||
const erwarte = (v: string) => {
|
||||
if (!ist(v)) throw new FormelFehler(v === ")" ? "Klammer zu fehlt" : `„${v}“ fehlt`);
|
||||
i++;
|
||||
};
|
||||
const ausdruck = (): Knoten => {
|
||||
const a = summe();
|
||||
for (const op of ["=", "<>", "<=", ">=", "<", ">"]) if (ist(op)) { i++; return { t: "op", op, a, b: summe() }; }
|
||||
return a;
|
||||
};
|
||||
const summe = (): Knoten => {
|
||||
let a = produkt();
|
||||
while (ist("+") || ist("-")) { const op = (t[i++] as { v: string }).v; a = { t: "op", op, a, b: produkt() }; }
|
||||
return a;
|
||||
};
|
||||
const produkt = (): Knoten => {
|
||||
let a = vorzeichen();
|
||||
while (ist("*") || ist("/")) { const op = (t[i++] as { v: string }).v; a = { t: "op", op, a, b: vorzeichen() }; }
|
||||
return a;
|
||||
};
|
||||
const vorzeichen = (): Knoten => {
|
||||
if (ist("-")) { i++; return { t: "neg", a: vorzeichen() }; }
|
||||
if (ist("+")) { i++; return vorzeichen(); }
|
||||
return potenz();
|
||||
};
|
||||
const potenz = (): Knoten => {
|
||||
const a = prozent();
|
||||
if (ist("^")) { i++; return { t: "op", op: "^", a, b: vorzeichen() }; }
|
||||
return a;
|
||||
};
|
||||
const prozent = (): Knoten => {
|
||||
let a = einfach();
|
||||
while (ist("%")) { i++; a = { t: "pct", a }; }
|
||||
return a;
|
||||
};
|
||||
const einfach = (): Knoten => {
|
||||
const x = t[i];
|
||||
if (!x) throw new FormelFehler(t.length ? "Formel unvollständig" : "leer");
|
||||
i++;
|
||||
if (x.t === "n") return { t: "n", v: x.v };
|
||||
if (x.t === "s") return { t: "s", v: x.v };
|
||||
if (x.t === "id") {
|
||||
if (!ist("(")) return { t: "id", name: x.v };
|
||||
i++;
|
||||
const args: Knoten[] = [];
|
||||
if (!ist(")")) {
|
||||
args.push(ausdruck());
|
||||
while (ist(";")) { i++; args.push(ausdruck()); }
|
||||
}
|
||||
erwarte(")");
|
||||
return { t: "f", name: x.v.toLowerCase(), args };
|
||||
}
|
||||
if (x.v === "(") { const a = ausdruck(); erwarte(")"); return a; }
|
||||
throw new FormelFehler(`„${x.v}“ an dieser Stelle geht nicht`);
|
||||
};
|
||||
const a = ausdruck();
|
||||
if (i < t.length) {
|
||||
const x = t[i]!;
|
||||
throw new FormelFehler(x.t === "o" && x.v === ")" ? "Klammer auf fehlt" : `Nach „${f.slice(0, 20)}“ fehlt ein Rechenzeichen`);
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
const SPEICHER = new Map<string, Knoten | FormelFehler>();
|
||||
function uebersetzt(f: string): Knoten {
|
||||
let k = SPEICHER.get(f);
|
||||
if (!k) {
|
||||
try { k = parse(f); } catch (e) { k = e instanceof FormelFehler ? e : new FormelFehler(String(e)); }
|
||||
if (SPEICHER.size > 5000) SPEICHER.clear();
|
||||
SPEICHER.set(f, k);
|
||||
}
|
||||
if (k instanceof FormelFehler) throw k;
|
||||
return k;
|
||||
}
|
||||
|
||||
export interface Kontext {
|
||||
/** Wert eines Kürzels; unbekannt → FormelFehler */
|
||||
wert(name: string): Wert;
|
||||
/** Spalte einer Liste („Wand.Breite“) für summe(), summewenn() und anzahl() */
|
||||
spalte?(liste: string, spalte: string): Wert[];
|
||||
/** Zeilenzahl einer Liste */
|
||||
zeilen?(liste: string): number;
|
||||
}
|
||||
|
||||
const GRAD = Math.PI / 180;
|
||||
const zahl = (w: Wert, wo = "Wert"): number => {
|
||||
if (typeof w === "number") return w;
|
||||
const n = Number(w.trim().replace(",", "."));
|
||||
if (w.trim() === "" ) return 0;
|
||||
if (!Number.isFinite(n)) throw new FormelFehler(`${wo} „${w}“ ist keine Zahl`);
|
||||
return n;
|
||||
};
|
||||
const gleich = (a: Wert, b: Wert) =>
|
||||
typeof a === "string" || typeof b === "string" ? String(a).trim().toLowerCase() === String(b).trim().toLowerCase() : Math.abs(a - b) < 1e-9;
|
||||
const stellen = (args: number[]) => 10 ** Math.round(args[1] ?? 0);
|
||||
|
||||
// gleiche Namen wie in Excel gehen auch, damit Formeln aus den Musterpositionen passen
|
||||
const NAMEN: Record<string, string> = {
|
||||
roundup: "aufrunden", obergrenze: "aufrunden", rounddown: "abrunden", untergrenze: "abrunden", round: "runden", sqrt: "wurzel",
|
||||
if: "wenn", and: "und", or: "oder", not: "nicht", choose: "wahl", sum: "summe", count: "anzahl", sumif: "summewenn", countif: "anzahlwenn",
|
||||
atan: "arctan", asin: "arcsin", acos: "arccos", mod: "rest", int: "ganzzahl",
|
||||
};
|
||||
export const FUNKTIONEN = ["aufrunden", "abrunden", "runden", "min", "max", "abs", "wurzel", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "pi",
|
||||
"wenn", "und", "oder", "nicht", "wahl", "summe", "anzahl", "summewenn", "anzahlwenn", "rest", "ganzzahl"];
|
||||
|
||||
function rechne(k: Knoten, x: Kontext): Wert {
|
||||
switch (k.t) {
|
||||
case "n": case "s": return k.v;
|
||||
case "id":
|
||||
if (k.name.includes(".")) throw new FormelFehler(`„${k.name}“ ist eine Listenspalte; nutze summe(${k.name})`);
|
||||
return x.wert(k.name);
|
||||
case "neg": return -zahl(rechne(k.a, x));
|
||||
case "pct": return zahl(rechne(k.a, x)) / 100;
|
||||
case "op": {
|
||||
const a = rechne(k.a, x), b = rechne(k.b, x);
|
||||
switch (k.op) {
|
||||
case "=": return gleich(a, b) ? 1 : 0;
|
||||
case "<>": return gleich(a, b) ? 0 : 1;
|
||||
case "<": return zahl(a) < zahl(b) - 1e-12 ? 1 : 0;
|
||||
case ">": return zahl(a) > zahl(b) + 1e-12 ? 1 : 0;
|
||||
case "<=": return zahl(a) <= zahl(b) + 1e-12 ? 1 : 0;
|
||||
case ">=": return zahl(a) >= zahl(b) - 1e-12 ? 1 : 0;
|
||||
case "+": return zahl(a) + zahl(b);
|
||||
case "-": return zahl(a) - zahl(b);
|
||||
case "*": return zahl(a) * zahl(b);
|
||||
case "/": { const n = zahl(b); if (n === 0) throw new FormelFehler("Teilen durch 0"); return zahl(a) / n; }
|
||||
case "^": return zahl(a) ** zahl(b);
|
||||
}
|
||||
throw new FormelFehler(`Rechenzeichen ${k.op}`);
|
||||
}
|
||||
case "f": return funktion(NAMEN[k.name] ?? k.name, k.args, x);
|
||||
}
|
||||
}
|
||||
|
||||
/** Werte einer Listenspalte, oder einzelne Zahlen, für summe() und Co. */
|
||||
function sammle(args: Knoten[], x: Kontext): Wert[] {
|
||||
const aus: Wert[] = [];
|
||||
for (const a of args) {
|
||||
if (a.t === "id" && a.name.includes(".")) {
|
||||
const [l, s] = a.name.split(".") as [string, string];
|
||||
if (!x.spalte) throw new FormelFehler(`Liste „${l}“ gibt es hier nicht`);
|
||||
aus.push(...x.spalte(l, s));
|
||||
} else aus.push(rechne(a, x));
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
function funktion(name: string, args: Knoten[], x: Kontext): Wert {
|
||||
const n = () => args.map((a) => zahl(rechne(a, x)));
|
||||
const genau = (anzahl: number, bis = anzahl) => {
|
||||
if (args.length < anzahl || args.length > bis) throw new FormelFehler(`${name}() braucht ${anzahl === bis ? anzahl : `${anzahl} bis ${bis}`} ${bis === 1 ? "Wert" : "Werte"}`);
|
||||
};
|
||||
switch (name) {
|
||||
case "aufrunden": { genau(1, 2); const v = n(), f = stellen(v); return Math.ceil(v[0]! * f - 1e-9) / f; }
|
||||
case "abrunden": { genau(1, 2); const v = n(), f = stellen(v); return Math.floor(v[0]! * f + 1e-9) / f; }
|
||||
case "runden": { genau(1, 2); const v = n(), f = stellen(v); return Math.sign(v[0]!) * Math.round(Math.abs(v[0]!) * f + 1e-9) / f; }
|
||||
case "ganzzahl": genau(1); return Math.trunc(n()[0]!);
|
||||
case "rest": { genau(2); const [a, b] = n() as [number, number]; if (b === 0) throw new FormelFehler("Teilen durch 0"); return a - b * Math.floor(a / b); }
|
||||
case "min": case "max": {
|
||||
const v = sammle(args, x).map((w) => zahl(w));
|
||||
if (!v.length) throw new FormelFehler(`${name}() braucht Werte`);
|
||||
return name === "min" ? Math.min(...v) : Math.max(...v);
|
||||
}
|
||||
case "abs": genau(1); return Math.abs(n()[0]!);
|
||||
case "wurzel": { genau(1); const v = n()[0]!; if (v < 0) throw new FormelFehler("Wurzel aus einer negativen Zahl"); return Math.sqrt(v); }
|
||||
case "sin": genau(1); return Math.sin(n()[0]! * GRAD);
|
||||
case "cos": genau(1); return Math.cos(n()[0]! * GRAD);
|
||||
case "tan": genau(1); return Math.tan(n()[0]! * GRAD);
|
||||
case "arcsin": genau(1); return Math.asin(n()[0]!) / GRAD;
|
||||
case "arccos": genau(1); return Math.acos(n()[0]!) / GRAD;
|
||||
case "arctan": genau(1); return Math.atan(n()[0]!) / GRAD;
|
||||
case "pi": genau(0); return Math.PI;
|
||||
case "wenn": genau(2, 3); return zahl(rechne(args[0]!, x)) !== 0 ? rechne(args[1]!, x) : args[2] ? rechne(args[2], x) : 0;
|
||||
case "und": return args.every((a) => zahl(rechne(a, x)) !== 0) ? 1 : 0;
|
||||
case "oder": return args.some((a) => zahl(rechne(a, x)) !== 0) ? 1 : 0;
|
||||
case "nicht": genau(1); return zahl(rechne(args[0]!, x)) === 0 ? 1 : 0;
|
||||
case "wahl": {
|
||||
if (args.length < 2) throw new FormelFehler("wahl() braucht eine Nummer und Werte");
|
||||
const i = Math.round(zahl(rechne(args[0]!, x)));
|
||||
if (i < 1 || i >= args.length) throw new FormelFehler(`wahl(): ${i} gibt es nicht`);
|
||||
return rechne(args[i]!, x);
|
||||
}
|
||||
case "summe": return sammle(args, x).reduce((s: number, w) => s + zahl(w), 0);
|
||||
case "anzahl": {
|
||||
if (args.length === 1 && args[0]!.t === "id" && !args[0]!.name.includes(".")) {
|
||||
const l = args[0]!.name;
|
||||
if (x.zeilen) { const z = x.zeilen(l); if (z >= 0) return z; }
|
||||
}
|
||||
return sammle(args, x).filter((w) => String(w).trim() !== "").length;
|
||||
}
|
||||
case "summewenn": case "anzahlwenn": {
|
||||
const mitSumme = name === "summewenn";
|
||||
genau(mitSumme ? 3 : 2);
|
||||
const werte = mitSumme ? sammle([args[0]!], x) : [];
|
||||
const kriterien = sammle([args[mitSumme ? 1 : 0]!], x);
|
||||
const soll = rechne(args[mitSumme ? 2 : 1]!, x);
|
||||
let s = 0;
|
||||
kriterien.forEach((k, i) => { if (gleich(k, soll)) s += mitSumme ? zahl(werte[i] ?? 0) : 1; });
|
||||
return s;
|
||||
}
|
||||
}
|
||||
throw new FormelFehler(`Funktion „${name}“ gibt es nicht`);
|
||||
}
|
||||
|
||||
/** Eine Formel ausrechnen; Fehler als FormelFehler */
|
||||
export function berechne(formel: string, x: Kontext): Wert {
|
||||
return rechne(uebersetzt(formel), x);
|
||||
}
|
||||
|
||||
/** Nur prüfen, ob die Formel lesbar ist (ohne Kürzel aufzulösen) */
|
||||
export function formelFehler(formel: string): string | null {
|
||||
try { uebersetzt(formel); return null; } catch (e) { return (e as Error).message; }
|
||||
}
|
||||
|
||||
/** Alle Kürzel, die eine Formel benutzt (ohne Funktionsnamen) */
|
||||
export function kuerzelIn(formel: string): string[] {
|
||||
try {
|
||||
return zerlege(formel).filter((t, i, a) => t.t === "id" && !(a[i + 1]?.t === "o" && a[i + 1]!.v === "(")).map((t) => t.v as string);
|
||||
} catch { return []; }
|
||||
}
|
||||
|
||||
export const KUERZEL = /^[\p{L}_][\p{L}\p{N}_]*$/u;
|
||||
|
||||
/** Kürzel in einer Formel umbenennen (nicht in Texten in Anführungszeichen, nicht hinter einem Punkt) */
|
||||
export function benenneUm(formel: string, alt: string, neu: string): string {
|
||||
if (!alt || !neu || alt === neu) return formel;
|
||||
const teile = formel.split(/(["„“'][^"“”']*["“”'])/);
|
||||
return teile.map((t, i) => (i % 2 ? t : t.replace(new RegExp(`(?<![\\p{L}\\p{N}_.])${alt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}_(])`, "gu"), neu))).join("");
|
||||
}
|
||||
|
||||
/** Zahl für Mengenblatt und Texte: ganze Zahlen ohne Komma, sonst bis 3 Stellen, mindestens 2 */
|
||||
export function zahlDeutsch(n: number, einheit?: string | null): string {
|
||||
if (!Number.isFinite(n)) return "–";
|
||||
const ganz = Math.abs(n - Math.round(n)) < 1e-9;
|
||||
const flaeche = einheit && /^(m|m²|m³|lfm|h)$/.test(einheit);
|
||||
const r = Math.round(n * 1000) / 1000;
|
||||
const min = ganz && !flaeche ? 0 : 2;
|
||||
return r.toLocaleString("de-DE", { minimumFractionDigits: min, maximumFractionDigits: Math.max(min, 3) });
|
||||
}
|
||||
@@ -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 });
|
||||
}
|
||||
}
|
||||
|
||||
197
src/domain/mengenblatt.ts
Normal file
197
src/domain/mengenblatt.ts
Normal file
@@ -0,0 +1,197 @@
|
||||
// Mengenblatt je Position (A22): Eingaben und Formeln mit Kürzeln, Listen wie die Wandliste W/F/G und freie
|
||||
// Aufmaßzeilen wie in Plancraft (Beschreibung, Formel, Ergebnis). Eine Formel oder die Summe der Aufmaßzeilen ist
|
||||
// die Menge der Position; Kostenzeilen beziehen sich mit Kürzeln darauf (z. B. Abbund = HL × 0,03 Std × 2 Personen).
|
||||
import { type Kontext, type Wert, FormelFehler, berechne, zahlDeutsch } from "./formel.js";
|
||||
|
||||
export interface BlattWert {
|
||||
kz: string;
|
||||
bez?: string | null;
|
||||
einheit?: string | null;
|
||||
/** Wert oder Formel als Text, so wie eingetippt */
|
||||
formel: string;
|
||||
/** gelb: wird beim Einfügen abgefragt und auf der Baustelle gemessen */
|
||||
eingabe?: boolean;
|
||||
}
|
||||
|
||||
export interface BlattSpalte {
|
||||
kz: string;
|
||||
bez?: string | null;
|
||||
einheit?: string | null;
|
||||
/** Text (z. B. Kennung W/F/G) oder Zahl */
|
||||
art?: "text" | "zahl";
|
||||
/** berechnete Spalte: Formel mit den Kürzeln der Spalten dieser Zeile */
|
||||
formel?: string | null;
|
||||
}
|
||||
|
||||
export interface BlattListe {
|
||||
kz: string;
|
||||
name?: string | null;
|
||||
spalten: BlattSpalte[];
|
||||
zeilen: Record<string, string>[];
|
||||
}
|
||||
|
||||
export interface AufmassZeile {
|
||||
text?: string | null;
|
||||
formel: string;
|
||||
}
|
||||
|
||||
export interface Blatt {
|
||||
vorlage?: { id: string; name: string } | null;
|
||||
werte: BlattWert[];
|
||||
listen: BlattListe[];
|
||||
zeilen: AufmassZeile[];
|
||||
/** Kürzel oder Formel für die Menge; leer = Summe der Aufmaßzeilen */
|
||||
menge?: string | null;
|
||||
}
|
||||
|
||||
export const leeresBlatt = (): Blatt => ({ werte: [], listen: [], zeilen: [] });
|
||||
|
||||
export function alsBlatt(x: unknown): Blatt {
|
||||
const b = (x && typeof x === "object" ? x : {}) as Partial<Blatt>;
|
||||
return {
|
||||
vorlage: b.vorlage ?? null, menge: b.menge ?? null,
|
||||
werte: Array.isArray(b.werte) ? b.werte : [], listen: Array.isArray(b.listen) ? b.listen : [], zeilen: Array.isArray(b.zeilen) ? b.zeilen : [],
|
||||
};
|
||||
}
|
||||
|
||||
export interface Auswertung {
|
||||
/** Ergebnis je Kürzel (nur fehlerfreie) */
|
||||
werte: Record<string, number>;
|
||||
/** Ergebnis je Eintrag: w:i, z:i, l:i:zeile:spalte; null bei Fehler */
|
||||
ergebnis: Record<string, Wert | null>;
|
||||
/** Fehler je Eintrag (gleiche Schlüssel, dazu „menge“) */
|
||||
fehler: Record<string, string>;
|
||||
summeZeilen: number;
|
||||
/** Menge der Position aus dem Blatt, null wenn nichts eingetragen oder fehlerhaft */
|
||||
menge: number | null;
|
||||
/** eine weitere Formel mit den Kürzeln des Blatts rechnen (Bezug einer Kostenzeile) */
|
||||
rechne(formel: string): number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Das Blatt ausrechnen. Werte werden erst bei Bedarf und je einmal gerechnet; ein Kreisbezug ist ein Fehler.
|
||||
* `umgebung` liefert feste Größen wie VERSCHNITT oder ÖFFNUNG_AB aus den Vorgaben des Angebots.
|
||||
*/
|
||||
export function werteBlatt(blatt: Blatt, umgebung: Record<string, number> = {}): Auswertung {
|
||||
const b = alsBlatt(blatt);
|
||||
const ergebnis: Record<string, Wert | null> = {};
|
||||
const fehler: Record<string, string> = {};
|
||||
const werte: Record<string, number> = {};
|
||||
const wertIndex = new Map<string, number>();
|
||||
b.werte.forEach((w, i) => {
|
||||
const kz = (w.kz ?? "").trim();
|
||||
if (!kz) return;
|
||||
if (wertIndex.has(kz)) fehler[`w:${i}`] = `Kürzel „${kz}“ gibt es zweimal`;
|
||||
else wertIndex.set(kz, i);
|
||||
});
|
||||
const listen = new Map(b.listen.map((l, i) => [l.kz, i] as const));
|
||||
|
||||
const fertig = new Map<string, Wert>();
|
||||
const kaputt = new Map<string, string>();
|
||||
const inArbeit = new Set<string>();
|
||||
const merke = (schluessel: string, rechnen: () => Wert): Wert => {
|
||||
if (fertig.has(schluessel)) return fertig.get(schluessel)!;
|
||||
if (kaputt.has(schluessel)) throw new FormelFehler(kaputt.get(schluessel)!);
|
||||
if (inArbeit.has(schluessel)) throw new FormelFehler("Kreisbezug: die Formel braucht ihr eigenes Ergebnis");
|
||||
inArbeit.add(schluessel);
|
||||
try {
|
||||
const v = rechnen();
|
||||
if (typeof v === "number" && !Number.isFinite(v)) throw new FormelFehler("Ergebnis ist keine Zahl");
|
||||
fertig.set(schluessel, v);
|
||||
return v;
|
||||
} catch (e) {
|
||||
const m = e instanceof FormelFehler ? e.message : String(e);
|
||||
kaputt.set(schluessel, m);
|
||||
throw new FormelFehler(m);
|
||||
} finally {
|
||||
inArbeit.delete(schluessel);
|
||||
}
|
||||
};
|
||||
const leer = (f: string | null | undefined) => !f || !f.trim();
|
||||
|
||||
const wertVon = (i: number): Wert => merke(`w:${i}`, () => {
|
||||
const w = b.werte[i]!;
|
||||
return leer(w.formel) ? 0 : berechne(w.formel, global);
|
||||
});
|
||||
const zelle = (li: number, zi: number, spalte: string): Wert => merke(`l:${li}:${zi}:${spalte}`, () => {
|
||||
const l = b.listen[li]!;
|
||||
const s = l.spalten.find((x) => x.kz === spalte);
|
||||
if (!s) throw new FormelFehler(`Spalte „${spalte}“ gibt es in ${l.name || l.kz} nicht`);
|
||||
const roh = s.formel?.trim() ? s.formel : l.zeilen[zi]?.[spalte] ?? "";
|
||||
if (s.art === "text" && !s.formel?.trim()) return String(roh).trim();
|
||||
if (leer(roh)) return 0;
|
||||
return berechne(roh, zeilenKontext(li, zi));
|
||||
});
|
||||
|
||||
const kennt = (name: string): Wert => {
|
||||
const i = wertIndex.get(name);
|
||||
if (i !== undefined) {
|
||||
try { return wertVon(i); } catch (e) {
|
||||
throw new FormelFehler((e as Error).message.startsWith("Kreisbezug") ? (e as Error).message : `„${name}“ hat selbst einen Fehler`);
|
||||
}
|
||||
}
|
||||
if (name in umgebung) return umgebung[name]!;
|
||||
throw new FormelFehler(`„${name}“ unbekannt`);
|
||||
};
|
||||
const spalteVon = (liste: string, spalte: string): Wert[] => {
|
||||
const li = listen.get(liste);
|
||||
if (li === undefined) throw new FormelFehler(`Liste „${liste}“ unbekannt`);
|
||||
const l = b.listen[li]!;
|
||||
if (!l.spalten.some((s) => s.kz === spalte)) throw new FormelFehler(`Spalte „${spalte}“ gibt es in ${l.name || liste} nicht`);
|
||||
return l.zeilen.map((_, zi) => {
|
||||
try { return zelle(li, zi, spalte); } catch { throw new FormelFehler(`${l.name || liste}, Zeile ${zi + 1}, ${spalte} hat einen Fehler`); }
|
||||
});
|
||||
};
|
||||
const zeilenZahl = (liste: string) => { const li = listen.get(liste); return li === undefined ? -1 : b.listen[li]!.zeilen.length; };
|
||||
const global: Kontext = { wert: kennt, spalte: spalteVon, zeilen: zeilenZahl };
|
||||
const zeilenKontext = (li: number, zi: number): Kontext => ({
|
||||
...global,
|
||||
wert: (name) => (b.listen[li]!.spalten.some((s) => s.kz === name) ? zelle(li, zi, name) : kennt(name)),
|
||||
});
|
||||
|
||||
const zahl = (v: Wert) => (typeof v === "number" ? v : Number.NaN);
|
||||
const versuche = (schluessel: string, f: () => Wert) => {
|
||||
try { ergebnis[schluessel] = f(); } catch (e) { ergebnis[schluessel] = null; fehler[schluessel] ??= (e as Error).message; }
|
||||
};
|
||||
b.werte.forEach((w, i) => {
|
||||
versuche(`w:${i}`, () => wertVon(i));
|
||||
const v = ergebnis[`w:${i}`];
|
||||
if (typeof v === "number" && w.kz && !fehler[`w:${i}`]) werte[w.kz.trim()] = v;
|
||||
});
|
||||
b.listen.forEach((l, li) => l.zeilen.forEach((_, zi) => l.spalten.forEach((s) => versuche(`l:${li}:${zi}:${s.kz}`, () => zelle(li, zi, s.kz)))));
|
||||
let summeZeilen = 0;
|
||||
b.zeilen.forEach((z, i) => {
|
||||
if (leer(z.formel)) { ergebnis[`z:${i}`] = null; return; }
|
||||
versuche(`z:${i}`, () => berechne(z.formel, global));
|
||||
const v = ergebnis[`z:${i}`];
|
||||
if (typeof v === "number") summeZeilen += v;
|
||||
});
|
||||
|
||||
let menge: number | null = null;
|
||||
if (!leer(b.menge)) {
|
||||
try { menge = zahl(berechne(b.menge!, global)); if (!Number.isFinite(menge)) throw new FormelFehler("Menge ist keine Zahl"); }
|
||||
catch (e) { menge = null; fehler.menge = (e as Error).message; }
|
||||
} else if (b.zeilen.some((z) => !leer(z.formel))) menge = summeZeilen;
|
||||
if (menge !== null) menge = Math.round(menge * 10000) / 10000;
|
||||
|
||||
return {
|
||||
werte, ergebnis, fehler, summeZeilen: Math.round(summeZeilen * 10000) / 10000, menge,
|
||||
rechne: (f) => {
|
||||
const v = berechne(f, global);
|
||||
if (typeof v !== "number" || !Number.isFinite(v)) throw new FormelFehler("Ergebnis ist keine Zahl");
|
||||
return v;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** {Z} und {K} im Kurz- oder Langtext durch die Werte des Mengenblatts ersetzen (Bild 6 vom 21.10.2026) */
|
||||
export function textMitWerten(text: string, a: Pick<Auswertung, "werte"> | null, einheiten: Record<string, string | null | undefined> = {}): string {
|
||||
if (!text.includes("{")) return text;
|
||||
return text.replace(/\{([\p{L}_][\p{L}\p{N}_]*)\}/gu, (ganz, kz: string) => (a && kz in a.werte ? zahlDeutsch(a.werte[kz]!, einheiten[kz]) : ganz));
|
||||
}
|
||||
|
||||
/** Platzhalter {KZ}, die im Mengenblatt fehlen */
|
||||
export function fehlendePlatzhalter(text: string | null | undefined, a: Pick<Auswertung, "werte"> | null): string[] {
|
||||
if (!text) return [];
|
||||
return [...text.matchAll(/\{([\p{L}_][\p{L}\p{N}_]*)\}/gu)].map((m) => m[1]!).filter((kz) => !a || !(kz in a.werte) && kz !== "bindefrist");
|
||||
}
|
||||
235
src/domain/mengenvorlagen.ts
Normal file
235
src/domain/mengenvorlagen.ts
Normal file
@@ -0,0 +1,235 @@
|
||||
// Mitgelieferte Mengenvorlagen und Musterpositionen (A23). Grundlage: die Musterformeln vom 19.10.2026
|
||||
// (angebote/mengenermittlung/Musterformeln_Mengenermittlung.xlsx), die Pfettendach-Mengenermittlung aus Hennings
|
||||
// Excel und die Bilder der Angebotsmaske vom 21.10.2026. Werte sind Beispiele; Querschnitte aus der Statik.
|
||||
// Die Vorlagen stehen im Programm, nicht in der Datenbank: Kopieren macht daraus eine eigene, änderbare Vorlage.
|
||||
import type { Blatt, BlattListe, BlattWert } from "./mengenblatt.js";
|
||||
import type { Kostenart, Lohnart } from "./kalkulation.js";
|
||||
|
||||
export interface Ansatz {
|
||||
kostenart: Kostenart;
|
||||
lohnart?: Lohnart | null;
|
||||
beschreibung?: string | null;
|
||||
/** Kürzel oder Formel; leer = Menge der Position */
|
||||
bezug?: string | null;
|
||||
/** Std (Lohn) oder Menge je Bezugseinheit */
|
||||
menge: number;
|
||||
personen?: number;
|
||||
einheit?: string | null;
|
||||
/** Cent je Einheit; leer = Stundensatz der Lohnart oder noch kein Preis */
|
||||
ek?: number | null;
|
||||
faktor?: number;
|
||||
aktiv?: boolean;
|
||||
}
|
||||
|
||||
export interface Mengenvorlage {
|
||||
id: string;
|
||||
art: "mengen" | "muster";
|
||||
gruppe: string;
|
||||
name: string;
|
||||
beschreibung?: string | null;
|
||||
kurztext?: string | null;
|
||||
langtext?: string | null;
|
||||
einheit?: string | null;
|
||||
inhalt: Blatt & { ansaetze: Ansatz[] };
|
||||
/** mitgeliefert, nicht änderbar */
|
||||
fest?: boolean;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
const e = (kz: string, bez: string, einheit: string, formel: string): BlattWert => ({ kz, bez, einheit, formel, eingabe: true });
|
||||
const f = (kz: string, bez: string, einheit: string, formel: string): BlattWert => ({ kz, bez, einheit, formel });
|
||||
const lohn = (beschreibung: string, bezug: string, menge: number, personen = 1): Ansatz => ({ kostenart: "lohn", lohnart: "geselle", beschreibung, bezug, menge, personen, einheit: "h" });
|
||||
const material = (beschreibung: string, bezug: string, einheit: string, menge = 1): Ansatz => ({ kostenart: "material", beschreibung, bezug, menge, einheit });
|
||||
const blatt = (werte: BlattWert[], menge: string, listen: BlattListe[] = []): Blatt => ({ werte, listen, zeilen: [], menge });
|
||||
|
||||
const SATTELDACH = [
|
||||
e("DN", "Dachneigung", "°", "35"), e("L", "Gebäudelänge (Außenkante Wand)", "m", "10"), e("B", "Gebäudebreite (Außenkante Wand)", "m", "8"),
|
||||
e("UET", "Dachüberstand Traufe, waagerecht", "m", "0,5"), e("UEO", "Dachüberstand Ortgang", "m", "0,4"), e("a", "Sparrenabstand (Achsmaß)", "m", "0,8"),
|
||||
e("sb", "Sparrenbreite", "m", "0,08"), e("sh", "Sparrenhöhe", "m", "0,2"), e("LA", "Lattabstand (Ziegel)", "m", "0,33"),
|
||||
e("VS", "Verschnitt Platten/Bahnen", "", "VERSCHNITT"),
|
||||
f("LD", "Dachlänge inkl. Ortgang", "m", "L + 2*UEO"), f("SL", "Sparrenlänge je Seite", "m", "(B/2 + UET) / cos(DN)"),
|
||||
f("FH", "Firsthöhe über Wandoberkante", "m", "B/2 * tan(DN)"), f("SA", "Sparrenanzahl beide Seiten", "St", "(aufrunden(LD/a) + 1) * 2"),
|
||||
f("SLM", "Sparren gesamt", "m", "SA * SL"), f("SV", "Sparren Holzvolumen", "m³", "SLM * sb * sh"), f("AD", "Dachfläche (geneigt)", "m²", "2 * SL * LD"),
|
||||
f("AG", "Grundfläche überdacht", "m²", "(B + 2*UET) * LD"), f("LAT", "Dachlattung", "m", "2 * (aufrunden(SL/LA) + 1) * LD"),
|
||||
f("KL", "Konterlattung", "m", "SLM"), f("USB", "Unterspannbahn inkl. Überlappung", "m²", "AD * (1 + VS)"),
|
||||
f("ZSD", "Zwischensparrendämmung", "m²", "AD * (1 - sb/a)"), f("ZSDV", "Zwischensparrendämmung Volumen", "m³", "ZSD * sh"),
|
||||
f("TR", "Traufe beidseitig", "m", "2 * LD"), f("OG", "Ortgang (4 Kanten)", "m", "4 * SL"), f("FI", "First", "m", "LD"),
|
||||
];
|
||||
|
||||
const WANDLISTE: BlattListe = {
|
||||
kz: "Wand", name: "Wandliste",
|
||||
spalten: [
|
||||
{ kz: "Kennung", bez: "Kennung", art: "text" }, { kz: "Bezeichnung", bez: "Bezeichnung", art: "text" },
|
||||
{ kz: "Breite", bez: "Breite", einheit: "m" }, { kz: "Höhe", bez: "Höhe", einheit: "m" },
|
||||
// W Wand, G Giebel (Dreieck aus Breite und Höhe), F Öffnung (abgezogen ab ÖFFNUNG_AB, E28)
|
||||
{ kz: "Fläche", bez: "Fläche", einheit: "m²", formel: 'wenn(Kennung = "G"; Breite * Höhe / 2; wenn(Kennung = "F"; wenn(Breite * Höhe > ÖFFNUNG_AB; -Breite * Höhe; 0); Breite * Höhe))' },
|
||||
{ kz: "Schräge", bez: "Giebelrähm", einheit: "m", formel: 'wenn(Kennung = "G"; 2 * wurzel((Breite/2)^2 + Höhe^2); 0)' },
|
||||
{ kz: "Umfang", bez: "Laibung", einheit: "m", formel: 'wenn(Kennung = "F"; 2 * (Breite + Höhe); 0)' },
|
||||
],
|
||||
zeilen: [
|
||||
{ Kennung: "W", Bezeichnung: "Außenwand Nord", Breite: "10,00", Höhe: "2,75" }, { Kennung: "W", Bezeichnung: "Außenwand Süd", Breite: "10,00", Höhe: "2,75" },
|
||||
{ Kennung: "W", Bezeichnung: "Außenwand Ost", Breite: "8,00", Höhe: "2,75" }, { Kennung: "W", Bezeichnung: "Außenwand West", Breite: "8,00", Höhe: "2,75" },
|
||||
{ Kennung: "G", Bezeichnung: "Giebel Ost", Breite: "8,00", Höhe: "2,40" }, { Kennung: "G", Bezeichnung: "Giebel West", Breite: "8,00", Höhe: "2,40" },
|
||||
{ Kennung: "F", Bezeichnung: "Fenster Küche", Breite: "1,26", Höhe: "1,385" }, { Kennung: "F", Bezeichnung: "Terrassentür", Breite: "2,01", Höhe: "2,26" },
|
||||
{ Kennung: "F", Bezeichnung: "Fenster Wohnen", Breite: "2,01", Höhe: "1,385" },
|
||||
],
|
||||
};
|
||||
|
||||
const BAUTEILE: BlattListe = {
|
||||
kz: "BT", name: "Bauteilliste",
|
||||
spalten: [
|
||||
{ kz: "Bauteil", bez: "Bauteil", art: "text" }, { kz: "b", bez: "b", einheit: "m" }, { kz: "h", bez: "h", einheit: "m" },
|
||||
{ kz: "Länge", bez: "Länge", einheit: "m" }, { kz: "Anzahl", bez: "Anzahl", einheit: "St" },
|
||||
{ kz: "lfm", bez: "lfm", einheit: "m", formel: "Länge * Anzahl" }, { kz: "m3", bez: "m³", einheit: "m³", formel: "b * h * lfm" },
|
||||
],
|
||||
zeilen: [
|
||||
{ Bauteil: "Sparren", b: "0,08", h: "0,20", Länge: "10,00", Anzahl: "14" },
|
||||
{ Bauteil: "Schwellen / Pfetten", b: "0,06", h: "0,12", Länge: "LP", Anzahl: "2" },
|
||||
{ Bauteil: "Mittelpfette / Firstpfette", b: "0,20", h: "0,12", Länge: "LP", Anzahl: "2" },
|
||||
{ Bauteil: "Stützen", b: "0,12", h: "0,12", Länge: "2,50", Anzahl: "ST" },
|
||||
],
|
||||
};
|
||||
|
||||
export const STANDARD_VORLAGEN: Mengenvorlage[] = [
|
||||
{
|
||||
id: "std-pfettendach", art: "muster", gruppe: "Dach", name: "Pfettendach abbinden und richten",
|
||||
beschreibung: "Bauteilliste, Zeitansätze Abbund und Richten aus deiner Excel-Mengenermittlung",
|
||||
kurztext: "Pfettendach abbinden und richten, KVH NSi Fi/Ta", einheit: "m",
|
||||
langtext: "Dachstuhl als Pfettendach nach Statik und Werkplanung abbinden, liefern und richten. Bauholz KVH NSi Fichte/Tanne C24, technisch getrocknet, gehobelt und gefast. Verbindungsmittel und Kranstellung sind in eigenen Positionen enthalten.",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("LP", "Pfettenlänge", "m", "10,00"), e("SA", "Stützenabstand", "m", "2,60"), e("GP", "gestützte Pfetten", "St", "2"),
|
||||
f("ST", "Anzahl Stützen", "St", "aufrunden(LP / SA) * GP"), e("VS", "Verschnitt", "", "1 + VERSCHNITT"),
|
||||
f("HL", "Holz gesamt", "m", "summe(BT.lfm)"), f("HV", "Holzvolumen", "m³", "summe(BT.m3)"),
|
||||
f("SPL", "Sparren", "m", 'summewenn(BT.lfm; BT.Bauteil; "Sparren")'), f("PFL", "Pfetten, Schwellen, Stützen", "m", "HL - SPL"),
|
||||
], "HL", [BAUTEILE]),
|
||||
ansaetze: [
|
||||
lohn("Auf- und Abladen (Abbund)", "HV", 1, 2), lohn("Rüstzeit Abbund", "1", 1.5, 2), lohn("Abbund", "HL", 0.03, 2),
|
||||
lohn("Auf- und Abladen (Richten)", "HV", 1, 3), lohn("Rüstzeit Richten", "1", 1.5, 3), lohn("Richten", "HL", 0.09, 3),
|
||||
material("KVH 8/20 C24 NSi (Sparren)", "SPL * VS", "m"), material("KVH 6/12, 20/12, 12/12 C24 NSi", "PFL * VS", "m"),
|
||||
{ kostenart: "geraet", beschreibung: "Autokran 30 t", bezug: "1", menge: 1, einheit: "Tag", aktiv: false },
|
||||
],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-satteldach", art: "mengen", gruppe: "Dach", name: "Sparrendach / Satteldach", beschreibung: "aus Neigung, Länge und Breite; Menge = Dachfläche",
|
||||
einheit: "m²", inhalt: { ...blatt(SATTELDACH, "AD"), ansaetze: [] },
|
||||
},
|
||||
{
|
||||
id: "std-dachlattung", art: "mengen", gruppe: "Dach", name: "Dachlattung und Konterlattung", beschreibung: "Satteldach; Menge = Lattung in m",
|
||||
einheit: "m", inhalt: { ...blatt(SATTELDACH, "LAT + KL"), ansaetze: [] },
|
||||
},
|
||||
{
|
||||
id: "std-pultdach", art: "mengen", gruppe: "Dach", name: "Pultdach", beschreibung: "Menge = Dachfläche", einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("DN", "Dachneigung", "°", "10"), e("L", "Gebäudelänge", "m", "10"), e("B", "Gebäudebreite", "m", "6"), e("UET", "Überstand Traufe", "m", "0,5"),
|
||||
e("UEF", "Überstand hohe Seite", "m", "0,3"), e("UEO", "Überstand Ortgang", "m", "0,4"), e("a", "Sparrenabstand", "m", "0,8"),
|
||||
e("sb", "Sparrenbreite", "m", "0,08"), e("sh", "Sparrenhöhe", "m", "0,2"),
|
||||
f("LD", "Dachlänge inkl. Ortgang", "m", "L + 2*UEO"), f("PSL", "Sparrenlänge", "m", "(B + UET + UEF) / cos(DN)"),
|
||||
f("PSA", "Sparrenanzahl", "St", "aufrunden(LD/a) + 1"), f("PSLM", "Sparren gesamt", "m", "PSA * PSL"), f("PSV", "Sparren Holzvolumen", "m³", "PSLM * sb * sh"),
|
||||
f("PAD", "Dachfläche", "m²", "PSL * LD"), f("PH", "Höhenunterschied Traufe–First", "m", "B * tan(DN)"),
|
||||
], "PAD"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-walmdach", art: "mengen", gruppe: "Dach", name: "Walmdach mit Graten", beschreibung: "gleiche Neigung ringsum; Menge = Dachfläche", einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("DN", "Dachneigung", "°", "35"), e("L", "Gebäudelänge", "m", "10"), e("B", "Gebäudebreite", "m", "8"), e("UET", "Überstand ringsum", "m", "0,5"),
|
||||
f("WL", "Dachgrundriss Länge", "m", "L + 2*UET"), f("WB", "Dachgrundriss Breite", "m", "B + 2*UET"),
|
||||
f("WAD", "Dachfläche Walmdach", "m²", "WL * WB / cos(DN)"), f("WFL", "Firstlänge", "m", "max(WL - WB; 0)"),
|
||||
f("WGR", "Gratlänge je Grat", "m", "wurzel(2*(WB/2)^2 + (WB/2*tan(DN))^2)"), f("WGRS", "Grate gesamt", "m", "4 * WGR"),
|
||||
], "WAD"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-holzrahmenwand", art: "mengen", gruppe: "Wand", name: "Holzrahmenwand (Wandliste W/F/G)",
|
||||
beschreibung: "W Wand, G Giebel, F Öffnung; Öffnungen ab der Vorgabe abgezogen; Menge = Wandfläche netto", einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("RA", "Ständerabstand", "m", "0,625"), e("NE", "Wandecken und Anschlüsse", "St", "4"), e("NR", "Lagen Schwelle + Rähm", "", "2"),
|
||||
e("stb", "Ständerbreite", "m", "0,06"), e("sth", "Ständertiefe", "m", "0,16"), e("VSW", "Verschnitt Beplankung", "", "0,08"),
|
||||
f("LW", "Wandlänge", "m", 'summewenn(Wand.Breite; Wand.Kennung; "W")'),
|
||||
f("AB", "Wandfläche brutto", "m²", 'summewenn(Wand.Fläche; Wand.Kennung; "W") + summewenn(Wand.Fläche; Wand.Kennung; "G")'),
|
||||
f("AO", "Abzug Öffnungen", "m²", '-summewenn(Wand.Fläche; Wand.Kennung; "F")'), f("AN", "Wandfläche netto", "m²", "AB - AO"),
|
||||
f("NOE", "Öffnungen", "St", 'anzahlwenn(Wand.Kennung; "F")'), f("STA", "Ständer", "St", "aufrunden(LW/RA) + 1 + 2*NOE + NE"),
|
||||
f("SR", "Schwelle und Rähm", "m", "LW * NR"), f("GR", "Giebelrähm", "m", "summe(Wand.Schräge)"),
|
||||
f("BPI", "Beplankung innen", "m²", "AN * (1 + VSW)"), f("BPA", "Beplankung außen", "m²", "AN * (1 + VSW)"),
|
||||
f("DAE", "Dämmung zwischen Ständern", "m²", "AN * (1 - stb/RA)"), f("LAI", "Laibungen", "m", "summe(Wand.Umfang)"),
|
||||
], "AN", [WANDLISTE]), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-fassade", art: "mengen", gruppe: "Wand", name: "Wandbekleidung / Fassade", beschreibung: "Lattung, Schalung, Bretter je Verlegeart; Menge = Fassadenfläche",
|
||||
einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("AF", "Fassadenfläche netto", "m²", "95"), e("HF", "Fassadenhöhe", "m", "2,75"), e("UF", "Fassadenumfang", "m", "36"), e("NEK", "Außenecken", "St", "4"),
|
||||
e("aG", "Abstand Grundlattung", "m", "0,625"), e("aT", "Abstand Traglattung", "m", "0,5"), e("bD", "Deckbreite Brett", "m", "0,12"),
|
||||
e("ue", "Überdeckung (Stülpschalung)", "m", "0,02"), e("abd", "Achsabstand Bodenbretter", "m", "0,18"), e("VSF", "Verschnitt Schalung", "", "0,12"),
|
||||
e("BOEF", "Summe Öffnungsbreiten", "m", "9,6"), e("HOEF", "Summe Öffnungshöhen", "m", "11,4"),
|
||||
f("FV", "Fassadenbahn inkl. Überlappung", "m²", "AF * 1,1"), f("GL", "Grundlattung", "m", "AF / aG"), f("TL", "Traglattung", "m", "AF / aT"),
|
||||
f("ZL", "Zusatzlatten an Öffnungen", "m", "2*BOEF + 2*HOEF"), f("SCH", "Schalung mit Verschnitt", "m²", "AF * (1 + VSF)"),
|
||||
f("BDS", "Boden-Deckel: Bretter", "m", "AF / abd * 2 * (1 + VSF)"), f("STS", "Stülpschalung: Bretter", "m", "AF / (bD - ue) * (1 + VSF)"),
|
||||
f("NFS", "Nut und Feder: Bretter", "m", "AF / bD * (1 + VSF)"), f("EK", "Eckausbildung", "m", "NEK * HF"),
|
||||
f("INS", "Insektenschutzgitter", "m", "2 * UF"), f("SCHR", "Schrauben Schalung", "St", "aufrunden(NFS / aT * 2)"),
|
||||
], "AF"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-carport", art: "mengen", gruppe: "Weitere", name: "Carport mit Pultdach", beschreibung: "Pfosten, Pfetten, Sparren, Kopfbänder; Menge = 1 St", einheit: "St",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("CL", "Länge (Pfostenachse)", "m", "6"), e("CB", "Breite (Pfostenachse)", "m", "3,5"), e("CDN", "Dachneigung", "°", "3"), e("CH", "lichte Höhe Pfosten", "m", "2,3"),
|
||||
e("pA", "max. Pfostenabstand längs", "m", "3"), e("CUO", "Überstand vorn und hinten", "m", "0,3"), e("CUS", "Überstand seitlich", "m", "0,3"),
|
||||
e("ca", "Sparrenabstand", "m", "0,7"), e("kb", "Kopfband Schenkellänge", "m", "0,6"), e("pq", "Pfostenquerschnitt", "m", "0,12"),
|
||||
e("fq", "Pfette b", "m", "0,12"), e("fh", "Pfette h", "m", "0,2"), e("cs", "Sparren b", "m", "0,06"), e("csh", "Sparren h", "m", "0,16"),
|
||||
f("CNP", "Pfosten", "St", "(aufrunden(CL/pA) + 1) * 2"), f("CPL", "Pfosten gesamt", "m", "CNP * CH"), f("CPF", "Pfetten gesamt", "m", "2 * (CL + 2*CUO)"),
|
||||
f("CSA", "Sparren", "St", "aufrunden((CL + 2*CUO)/ca) + 1"), f("CSL", "Sparrenlänge", "m", "(CB + 2*CUS) / cos(CDN)"), f("CSLM", "Sparren gesamt", "m", "CSA * CSL"),
|
||||
f("CKB", "Kopfbänder", "St", "2 * CNP"), f("CKBL", "Kopfbänder gesamt", "m", "CKB * kb * wurzel(2)"), f("CAD", "Dachfläche", "m²", "(CL + 2*CUO) * CSL"),
|
||||
f("CBL", "Blende ringsum", "m", "2*(CL + 2*CUO) + 2*CSL"), f("CRI", "Dachrinne", "m", "CL + 2*CUO"), f("CFR", "Fallrohr", "m", "CH + 0,3"),
|
||||
f("CFU", "Fundamente / Pfostenträger", "St", "CNP"), f("CHV", "Holzvolumen", "m³", "CPL*pq*pq + CPF*fq*fh + CSLM*cs*csh + CKBL*pq*pq"),
|
||||
], "1"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-balkendecke", art: "mengen", gruppe: "Weitere", name: "Holzbalkendecke", beschreibung: "Balkenanzahl und -volumen; Menge = Deckenfläche", einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("DLS", "Länge quer zu den Balken", "m", "8"), e("DSW", "Spannweite (lichte Weite)", "m", "4,5"), e("DAU", "Auflagertiefe je Seite", "m", "0,15"),
|
||||
e("da", "Balkenabstand", "m", "0,625"), e("db", "Balkenbreite", "m", "0,08"), e("dh", "Balkenhöhe", "m", "0,22"),
|
||||
f("DBA", "Balken", "St", "aufrunden(DLS/da) + 1"), f("DBL", "Balken gesamt", "m", "DBA * (DSW + 2*DAU)"), f("DBV", "Holzvolumen", "m³", "DBL * db * dh"),
|
||||
f("DFL", "Deckenfläche", "m²", "DLS * DSW"),
|
||||
], "DFL"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-terrasse", art: "mengen", gruppe: "Weitere", name: "Terrasse / Dielen", beschreibung: "Dielen, Unterkonstruktion, Schrauben; Menge = Fläche", einheit: "m²",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("TA", "Terrassenfläche", "m²", "20"), e("tb", "Dielenbreite", "m", "0,145"), e("tf", "Fugenbreite", "m", "0,007"),
|
||||
e("tu", "Abstand Unterkonstruktion", "m", "0,5"), e("VST", "Verschnitt Dielen", "", "0,08"),
|
||||
f("TDI", "Dielen gesamt", "m", "TA / (tb + tf) * (1 + VST)"), f("TUK", "Unterkonstruktion", "m", "TA / tu"), f("TSC", "Schrauben", "St", "aufrunden(TA / (tb + tf) / tu * 2)"),
|
||||
], "TA"), ansaetze: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "std-abdeckblech", art: "muster", gruppe: "Klempner / Blech", name: "Abdeckblech abgekantet",
|
||||
beschreibung: "Beispiel aus Bild 6: Zeitansätze bitte prüfen", einheit: "m",
|
||||
kurztext: "Abdeckblech Titanzink, abgekantet, Z = {Z} m",
|
||||
langtext: "Abdeckblech aus Titanzink 0,7 mm liefern, nach Aufmaß abkanten ({K} Kantungen, Zuschnitt {Z} m) und mit Haften befestigen, Stöße überlappt.",
|
||||
inhalt: {
|
||||
...blatt([
|
||||
e("L", "Länge der Abdeckung", "m", "12,00"), e("Z", "Zuschnitt (abgewickelt)", "m", "0,30"), e("K", "Anzahl Kantungen", "St", "3"),
|
||||
e("TL", "Tafellänge", "m", "2,00"), e("ÜL", "Überlappung je Stoß", "m", "0,05"),
|
||||
f("STO", "Stöße", "St", "aufrunden(L / TL) - 1"), f("LG", "Länge mit Überlappung", "m", "L + STO * ÜL"), f("FL", "Blechfläche", "m²", "LG * Z"),
|
||||
f("KM", "Kantmeter", "m", "L * K"), f("HA", "Haften", "St", "aufrunden(LG / 0,5)"),
|
||||
], "LG"),
|
||||
ansaetze: [
|
||||
lohn("Abkanten", "KM", 0.02, 1), lohn("Montage", "LG", 0.15, 2),
|
||||
{ ...material("Titanzinkblech 0,7 mm", "FL", "m²"), faktor: 1.1 }, material("Haften verzinkt", "HA", "St"),
|
||||
],
|
||||
},
|
||||
},
|
||||
].map((v, i) => ({ ...v, fest: true, reihenfolge: i })) as Mengenvorlage[];
|
||||
Reference in New Issue
Block a user