diff --git a/CHANGELOG.md b/CHANGELOG.md index 94c7cd8..e22ddaf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,16 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.17.0 + +- Neue Angebotsmaske nach den Entwürfen vom 21.10.2026: Positionen eingeklappt mit Menge, Einheit, Kurztext, EP und Gesamt; ein Klick klappt eine Position auf. Darin Schalter für Langtext, Aufmaß, Kalkulation und Markieren und die Abschnitte Langtext, „Aufmaß und Mengenermittlung“, „Kalkulation (Kosten)“ und „Verkauf und Zuschläge“ mit „Preis anpassen auf“. +- Mengenblatt je Position (A22): Eingaben (gelb) und Formeln mit Kürzeln (HL, LP …), Listen wie Bauteilliste oder Wandliste W/F/G mit berechneten Spalten, freie Aufmaßzeilen wie in Plancraft (Beschreibung, Formel, Ergebnis). Formeln können + − * / ^, Klammern, Prozent, aufrunden, runden, min, max, wurzel, sin/cos/tan in Grad, wenn, summe, summewenn, anzahlwenn; Komma als Dezimalzeichen, Semikolon trennt. Die Menge der Position ist eine Formel oder die Summe der Aufmaßzeilen. „Mengenblatt groß öffnen“ zeigt alles auf einer Seite. +- Kostenzeilen rechnen mit dem Mengenblatt: Menge = Bezug × Ansatz × Personen wie in deiner Urkalk (z. B. Abbund = HL × 0,03 Std × 2). Zeilen lassen sich abwählen, ohne sie zu löschen. Neue Kostenart Subunternehmer (Zuschlag 10 %); beim Annehmen werden ihre Kosten Fremdleistung am Projekt. +- Katalog rechts (A23): Bausteine Titel, Position, Text und die Musterpositionen, dazu der Reiter Mengenvorlagen; „+“ oder Ziehen fügt unter der markierten Zeile ein. Eingaben einer Vorlage fragt das Programm beim Einfügen ab. Mitgeliefert: Pfettendach mit deinen Zeitansätzen, Satteldach, Dachlattung, Pultdach, Walmdach, Holzrahmenwand mit Wandliste, Fassade, Carport, Balkendecke, Terrasse und Abdeckblech als Beispiel für eine eigene Formel. Materialzeilen sind in den Vorlagen, aber noch ohne Preis. +- Eigene Vorlagen: „Als Musterposition speichern“ an jeder Position, Daten → Vorlagen mit Editor (Eingaben, Formeln, Menge, Zeitansätze und Material, {Z}/{K} im Text) und „Kopieren und ändern“ für die mitgelieferten. Eine geänderte Kopie ersetzt die mitgelieferte im Katalog. +- Verschnitt (10 %) und „Öffnungen abziehen ab“ (2,5 m²) stehen als Vorgaben je Angebot und im Mengenblatt als VERSCHNITT und ÖFFNUNG_AB. Die Prüfung meldet auch Fehler im Mengenblatt, fehlende {Kürzel} im Text und Material ohne Preis. +- Noch nicht dabei: Übernahme deiner Musterpositionen aus der Excel, Artikelstamm mit DATANORM, Plancraft-Stammdaten, Angebot als PDF. + ## 0.16.1 - Neues Projekt: Die Nummer ist schon mit der nächsten freien Nummer des Jahres ausgefüllt (höchste A- oder P-Nummer plus 1, Angebote mitgezählt). Bei Status Anfrage oder Angebot beginnt sie mit A, ab Auftrag mit P. Eine selbst eingetragene Nummer bleibt. diff --git a/demo/kern.ts b/demo/kern.ts index de7480a..525afbe 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -16,6 +16,7 @@ import m011 from "../src/server/migrations/011_ansichten.sql"; import m012 from "../src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql"; import m013 from "../src/server/migrations/013_kolonnen_subunternehmer.sql"; import m014 from "../src/server/migrations/014_angebote.sql"; +import m015 from "../src/server/migrations/015_mengenblatt.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -27,6 +28,7 @@ const MIGRATIONEN: [string, string][] = [ ["012_zahlungen_aufgaben_im_terminplan.sql", m012], ["013_kolonnen_subunternehmer.sql", m013], ["014_angebote.sql", m014], + ["015_mengenblatt.sql", m015], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index 0ff3048..0135488 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.16.1", + "version": "0.17.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/formel.ts b/src/domain/formel.ts new file mode 100644 index 0000000..bb6a809 --- /dev/null +++ b/src/domain/formel.ts @@ -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 = { "×": "*", "·": "*", "≠": "<>", "≤": "<=", "≥": ">=", "−": "-", ",": ";" }; + 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(); +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 = { + 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(`(? = { - 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): Record { + 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; - 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; + +/** 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 = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record; + 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 = {}; const titelSumme: Record = 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; + 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); @@ -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 }); } } diff --git a/src/domain/mengenblatt.ts b/src/domain/mengenblatt.ts new file mode 100644 index 0000000..a8bbb57 --- /dev/null +++ b/src/domain/mengenblatt.ts @@ -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[]; +} + +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; + 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; + /** Ergebnis je Eintrag: w:i, z:i, l:i:zeile:spalte; null bei Fehler */ + ergebnis: Record; + /** Fehler je Eintrag (gleiche Schlüssel, dazu „menge“) */ + fehler: Record; + 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 = {}): Auswertung { + const b = alsBlatt(blatt); + const ergebnis: Record = {}; + const fehler: Record = {}; + const werte: Record = {}; + const wertIndex = new Map(); + 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(); + const kaputt = new Map(); + const inArbeit = new Set(); + 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 | null, einheiten: Record = {}): 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 | 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"); +} diff --git a/src/domain/mengenvorlagen.ts b/src/domain/mengenvorlagen.ts new file mode 100644 index 0000000..ca7fdfa --- /dev/null +++ b/src/domain/mengenvorlagen.ts @@ -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[]; diff --git a/src/server/angebote.ts b/src/server/angebote.ts index 25d7440..487d4e2 100644 --- a/src/server/angebote.ts +++ b/src/server/angebote.ts @@ -7,7 +7,9 @@ import { type Client, type Pool, transaktion } from "./db.js"; import type { Einstellungen } from "./einstellungen.js"; import { mitNeuplanung } from "./terminplan.js"; import { werName } from "./anmeldung.js"; -import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot } from "../domain/kalkulation.js"; +import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot, umgebungVon } from "../domain/kalkulation.js"; +import { type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js"; +import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js"; import { plusTage } from "../domain/datum.js"; import { naechsterArbeitstag } from "../domain/kalender.js"; @@ -16,17 +18,23 @@ const heute = () => new Date().toISOString().slice(0, 10); export const ANGEBOT_TEILE = new Set(["angebot", "angebot_titel", "angebot_position", "angebot_kosten"]); +const POSITION_SPALTEN = ["titel_id", "oz", "kurztext", "langtext", "menge", "einheit", "art", "ep_fest", "mit_kalkulation", "mit_aufmass", "aufmass", "textzeile", "markiert", "reihenfolge"]; +const KOSTEN_SPALTEN = ["kostenart", "lohnart", "beschreibung", "menge", "einheit", "ek", "faktor", "faktor_grund", "zuschlag_prozent", "bezug", "personen", "aktiv", "aus_vorlage", "reihenfolge"]; +const einfuegen = (tabelle: string, spalten: string[]) => + `insert into ${tabelle} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`; + export class AngebotFehler extends Error { statusCode = 409; } /** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */ export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze { - const s = (a.saetze ?? {}) as Partial>; + const s = (a.saetze ?? {}) as Partial>; return { stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) }, zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) }, wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent), + mengen: { verschnitt: e.kalkulation.verschnitt, oeffnung_ab: e.kalkulation.oeffnungAb, ...(s.mengen ?? {}) }, }; } @@ -110,22 +118,62 @@ async function kopiereInhalt(c: Client, von: string, nach: string): Promise(); const positionen = (await c.query("select * from angebot_position where angebot_id = $1 order by reihenfolge", [von])).rows; for (const p of positionen) { - const n = (await c.query(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, reihenfolge) - values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) returning id`, - [nach, p.titel_id ? titelNeu.get(p.titel_id) : null, p.oz, p.kurztext, p.langtext, p.menge, p.einheit, p.art, p.ep_fest, p.reihenfolge])).rows[0]; + const n = (await c.query(einfuegen("angebot_position", ["angebot_id", ...POSITION_SPALTEN]), + [nach, ...POSITION_SPALTEN.map((x) => (x === "titel_id" ? (p.titel_id ? titelNeu.get(p.titel_id) : null) : p[x]))])).rows[0]; posNeu.set(p.id, n.id); } for (const p of positionen) { if (p.grundposition_id && posNeu.has(p.grundposition_id)) await c.query("update angebot_position set grundposition_id = $2 where id = $1", [posNeu.get(p.id), posNeu.get(p.grundposition_id)]); } const kosten = (await c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1", [von])).rows; - for (const k of kosten) { - await c.query(`insert into angebot_kosten (position_id, kostenart, lohnart, beschreibung, menge, einheit, ek, faktor, faktor_grund, zuschlag_prozent, reihenfolge) - values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, - [posNeu.get(k.position_id), k.kostenart, k.lohnart, k.beschreibung, k.menge, k.einheit, k.ek, k.faktor, k.faktor_grund, k.zuschlag_prozent, k.reihenfolge]); + for (const k of kosten) await c.query(einfuegen("angebot_kosten", ["position_id", ...KOSTEN_SPALTEN]), [posNeu.get(k.position_id), ...KOSTEN_SPALTEN.map((x) => k[x])]); +} + +/** Alle Vorlagen: mitgelieferte und eigene */ +async function vorlagen(c: Pick): Promise { + const eigene = (await c.query("select * from mengenvorlage order by gruppe, reihenfolge, name")).rows as Mengenvorlage[]; + return [...STANDARD_VORLAGEN, ...eigene.map((v) => ({ ...v, fest: false }))]; +} + +/** + * Platz für eine neue Zeile unter der markierten (A: „Ziehen oder + fügt unter der markierten Zeile ein“): + * hinter einer Position, am Anfang eines Titels oder am Ende. Die Zeilen darunter rücken eins weiter. + */ +async function platzUnter(c: Client, angebotId: string, nachId: string | null | undefined, titelId: string | null | undefined) { + const pos = nachId ? (await c.query("select titel_id, reihenfolge from angebot_position where id = $1 and angebot_id = $2", [nachId, angebotId])).rows[0] : undefined; + const titel = !pos && nachId ? (await c.query("select id from angebot_titel where id = $1 and angebot_id = $2", [nachId, angebotId])).rows[0] : undefined; + let tid: string | null, r: number; + if (pos) { tid = pos.titel_id; r = pos.reihenfolge + 1; } + else if (titel) { tid = titel.id; r = 0; } + else { + tid = titelId ?? (await c.query("select id from angebot_titel where angebot_id = $1 order by reihenfolge desc, angelegt_am desc limit 1", [angebotId])).rows[0]?.id ?? null; + r = (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_position where angebot_id = $1 and titel_id is not distinct from $2", [angebotId, tid])).rows[0].r; + } + await c.query("update angebot_position set reihenfolge = reihenfolge + 1 where angebot_id = $1 and titel_id is not distinct from $2 and reihenfolge >= $3", [angebotId, tid, r]); + return { titel_id: tid, reihenfolge: r }; +} + +/** Kostenzeilen aus den Zeitansätzen einer Vorlage */ +async function ansaetzeEinfuegen(c: Client, positionId: string, ansaetze: Mengenvorlage["inhalt"]["ansaetze"], ab: number) { + for (const [i, z] of ansaetze.entries()) { + await c.query(einfuegen("angebot_kosten", ["position_id", "kostenart", "lohnart", "beschreibung", "bezug", "menge", "personen", "einheit", "ek", "faktor", "aktiv", "aus_vorlage", "reihenfolge"]), + [positionId, z.kostenart, z.kostenart === "lohn" ? z.lohnart ?? "geselle" : null, z.beschreibung ?? null, z.bezug ?? null, z.menge, z.personen ?? 1, + z.kostenart === "lohn" ? "h" : z.einheit ?? null, z.ek ?? null, z.faktor ?? 1, z.aktiv ?? true, true, ab + i]); } } +const EinfuegenSchema = z.object({ + was: z.enum(["position", "text", "titel", "vorlage"]), + /** markierte Zeile (Position oder Titel), darunter kommt die neue */ + nach_id: z.uuid().nullable().optional(), + titel_id: z.uuid().nullable().optional(), + vorlage_id: z.string().max(80).optional(), + /** Vorlage in diese Position einfügen statt eine neue anzulegen (Mengenblatt „Vorlage einfügen“) */ + position_id: z.uuid().optional(), + /** Eingaben der Vorlage, beim Einfügen abgefragt */ + eingaben: z.record(z.string().max(40), z.string().max(500)).default({}), +}); + export function registriereAngebote( app: FastifyInstance, pool: Pool, einstellungen: () => Promise, nachProjekt: (p: Record, wer: string) => Promise>, @@ -165,7 +213,7 @@ export function registriereAngebote( vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext, vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall, // A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen - { stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, stand: datum }])).rows[0]; + { stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, stand: datum }])).rows[0]; if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id); if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]); return neu; @@ -217,6 +265,85 @@ export function registriereAngebote( return r ?? reply.status(409).send({ fehler: "Dieses Angebot lässt sich nicht als abgelehnt markieren." }); }); + app.get("/api/mengenvorlagen-alle", async () => vorlagen(pool)); + + // Bausteine, Musterpositionen und Mengenvorlagen ins Angebot (neue Maske 21.10.2026) + app.post("/api/angebote/:id/einfuegen", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const q = EinfuegenSchema.parse(req.body ?? {}); + const e = await einstellungen(); + const r = await transaktion(pool, wer(req), async (c) => { + const a = (await c.query("select * from angebot where id = $1", [id])).rows[0]; + if (!a) return null; + if (a.status !== "entwurf") throw new AngebotFehler(`Angebot ${a.nummer} ist nicht mehr im Entwurf. Zum Ändern zuerst „Wieder bearbeiten“ wählen.`); + if (q.was === "titel") { + const nach = q.nach_id ? (await c.query(`select coalesce((select t.reihenfolge from angebot_titel t join angebot_position p on p.titel_id = t.id where p.id = $1), + (select reihenfolge from angebot_titel where id = $1)) as r`, [q.nach_id])).rows[0]?.r : null; + const rf = nach === null || nach === undefined ? (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_titel where angebot_id = $1", [id])).rows[0].r : nach + 1; + await c.query("update angebot_titel set reihenfolge = reihenfolge + 1 where angebot_id = $1 and reihenfolge >= $2", [id, rf]); + return (await c.query("insert into angebot_titel (angebot_id, bezeichnung, reihenfolge) values ($1, 'Neuer Titel', $2) returning id", [id, rf])).rows[0]; + } + if (q.was !== "vorlage") { + const ort = await platzUnter(c, id, q.nach_id, q.titel_id); + return (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, menge, einheit, mit_kalkulation, textzeile) + values ($1, $2, $3, $4, $5, $6, false, $7) returning id`, + [id, ort.titel_id, ort.reihenfolge, q.was === "text" ? "Text" : "Neue Position", q.was === "text" ? 0 : 1, q.was === "text" ? "psch" : "St", q.was === "text"])).rows[0]; + } + const v = (await vorlagen(c)).find((x) => String(x.id) === q.vorlage_id); + if (!v) throw new AngebotFehler("Diese Vorlage gibt es nicht mehr."); + const { ansaetze = [], ...inhalt } = v.inhalt; + const vorlageBlatt = alsBlatt(inhalt); + vorlageBlatt.werte = vorlageBlatt.werte.map((w) => (w.eingabe && q.eingaben[w.kz] !== undefined ? { ...w, formel: q.eingaben[w.kz]! } : w)); + vorlageBlatt.vorlage = { id: String(v.id), name: v.name }; + const umg = umgebungVon(saetzeVon(a, e)); + if (q.position_id) { + const p = (await c.query("select * from angebot_position where id = $1 and angebot_id = $2", [q.position_id, id])).rows[0]; + if (!p) return null; + const alt = alsBlatt(p.aufmass); + const blatt: Blatt = { ...vorlageBlatt, zeilen: alt.zeilen }; + const menge = werteBlatt(blatt, umg).menge; + await c.query("delete from angebot_kosten where position_id = $1 and aus_vorlage", [p.id]); + const ab = (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_kosten where position_id = $1", [p.id])).rows[0].r; + await ansaetzeEinfuegen(c, p.id, ansaetze, ab); + await c.query(`update angebot_position set aufmass = $2, mit_aufmass = true, menge = coalesce($3, menge), einheit = coalesce($4, einheit), + mit_kalkulation = mit_kalkulation or $5 where id = $1`, [p.id, blatt, menge, v.einheit || null, ansaetze.length > 0]); + return { id: p.id }; + } + const ort = await platzUnter(c, id, q.nach_id, q.titel_id); + const menge = werteBlatt(vorlageBlatt, umg).menge ?? 1; + const p = (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, langtext, menge, einheit, mit_kalkulation, mit_aufmass, aufmass) + values ($1, $2, $3, $4, $5, $6, $7, $8, true, $9) returning id`, + [id, ort.titel_id, ort.reihenfolge, v.kurztext || v.name, v.langtext || null, menge, v.einheit || "St", ansaetze.length > 0, vorlageBlatt])).rows[0]; + await ansaetzeEinfuegen(c, p.id, ansaetze, 0); + return p; + }); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return reply.status(201).send(r); + }); + + // „Als Musterposition speichern“ / „Als Vorlage speichern“: Mengenblatt und Kostenzeilen einer Position in den Katalog + app.post("/api/angebot-positionen/:id/als-vorlage", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const q = z.object({ name: z.string().trim().min(1).max(200), gruppe: z.string().trim().min(1).max(100), art: z.enum(["mengen", "muster"]) }).parse(req.body ?? {}); + const r = await transaktion(pool, wer(req), async (c) => { + const p = (await c.query("select * from angebot_position where id = $1", [id])).rows[0]; + if (!p) return null; + const kosten = (await c.query("select * from angebot_kosten where position_id = $1 order by reihenfolge, angelegt_am", [id])).rows; + const blatt = alsBlatt(p.mit_aufmass ? p.aufmass : null); + const inhalt = { + werte: blatt.werte, listen: blatt.listen, zeilen: blatt.zeilen, menge: blatt.menge ?? null, + ansaetze: p.mit_kalkulation ? kosten.map((k) => ({ + kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, bezug: k.bezug, menge: Number(k.menge), personen: Number(k.personen), + einheit: k.einheit, ek: k.ek === null ? null : Number(k.ek), faktor: Number(k.faktor), aktiv: k.aktiv, + })) : [], + }; + return (await c.query(`insert into mengenvorlage (art, gruppe, name, kurztext, langtext, einheit, inhalt) values ($1, $2, $3, $4, $5, $6, $7) returning *`, + [q.art, q.gruppe, q.name, q.art === "muster" ? p.kurztext : null, q.art === "muster" ? p.langtext : null, p.einheit, inhalt])).rows[0]; + }); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return reply.status(201).send(r); + }); + // A4: Angebot annehmen → Auftrag. Titel werden Abschnitte mit je einem Vorgang (Stunden aus der Kalkulation), // der Auftragswert ist die Summe der angenommenen Angebote, der Zahlungsplan entsteht nach P9 von selbst. app.post("/api/angebote/:id/annehmen", async (req, reply) => { @@ -245,8 +372,9 @@ export function registriereAngebote( const ka = x.ergebnis.kostenarten; await c.query(`update projekt set umsatz_netto = $2, status = $3, nummer = $4, material_kosten = case when $5 then $6 else material_kosten end, sonstige_kosten = case when $5 then $7 else sonstige_kosten end, + fremd_kosten = case when $5 then $9 else fremd_kosten end, soll_stunden = coalesce(soll_stunden, 0) + $8 where id = $1`, - [pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.kosten, x.ergebnis.stunden]); + [pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.kosten, x.ergebnis.stunden, ka.subunternehmer.kosten]); // Abschnitte nur, wenn das Projekt noch keinen Terminplan hat const abschnitte = (await c.query("select count(*)::int as n from abschnitt where projekt_id = $1", [pid])).rows[0].n; let neu = 0; diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 2e9a481..fcbba20 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -57,11 +57,14 @@ export const EinstellungenSchema = z.object({ .object({ planer: z.number().int().min(0).default(8000), geselle: z.number().int().min(0).default(5831), helfer: z.number().int().min(0).default(5000) }) .prefault({}), zuschlaege: z - .object({ lohn: z.number().min(0).max(500).default(20), material: z.number().min(0).max(500).default(5), geraet: z.number().min(0).max(500).default(10), sonstiges: z.number().min(0).max(500).default(10) }) + .object({ lohn: z.number().min(0).max(500).default(20), material: z.number().min(0).max(500).default(5), geraet: z.number().min(0).max(500).default(10), subunternehmer: z.number().min(0).max(500).default(10), sonstiges: z.number().min(0).max(500).default(10) }) .prefault({}), wagnis: z.number().min(0).max(50).default(5), gewinn: z.number().min(0).max(50).default(5), ausfall: z.number().min(0).max(50).default(5), + // Vorgaben der Mengenblätter (A22): Verschnitt in %, Öffnungen ab dieser Fläche abziehen (E28) + verschnitt: z.number().min(0).max(100).default(10), + oeffnungAb: z.number().min(0).max(100).default(2.5), bindefristWochen: z.number().int().min(0).max(52).default(4), // A35: so viele Tage vor Ablauf der Bindefrist erscheint die Erinnerung auf der Startseite erinnerungTage: z.number().int().min(0).max(60).default(5), diff --git a/src/server/migrations/015_mengenblatt.sql b/src/server/migrations/015_mengenblatt.sql new file mode 100644 index 0000000..c34fa87 --- /dev/null +++ b/src/server/migrations/015_mengenblatt.sql @@ -0,0 +1,44 @@ +-- Neue Angebotsmaske (Henning, 21.10.2026): Schalter Aufmaß und Kalkulation je Position, Mengenblatt mit Kürzeln, +-- Kostenzeilen mit Bezug auf das Mengenblatt (Bezug × Ansatz × Personen), Subunternehmer als eigene Kostenart, +-- Textzeilen im Leistungsverzeichnis und eigene Mengenvorlagen und Musterpositionen. + +alter table angebot_position + add column mit_kalkulation boolean not null default true, + add column mit_aufmass boolean not null default false, + add column aufmass jsonb, + add column textzeile boolean not null default false, + add column markiert boolean not null default false; +-- bisher: ohne Kostenzeilen galt der feste Preis +update angebot_position p set mit_kalkulation = exists (select 1 from angebot_kosten k where k.position_id = p.id); + +alter table angebot_kosten drop constraint angebot_kosten_kostenart_check; +alter table angebot_kosten add constraint angebot_kosten_kostenart_check + check (kostenart in ('lohn', 'material', 'geraet', 'subunternehmer', 'sonstiges')); +alter table angebot_kosten + -- Kürzel oder Formel aus dem Mengenblatt; leer = Menge der Position (menge ist dann je Einheit) + add column bezug text, + add column personen numeric(8, 2) not null default 1 check (personen > 0), + -- „notwendig“ wie in der Urkalk: abgewählte Zeilen bleiben sichtbar und zählen nicht + add column aktiv boolean not null default true, + -- beim Wechsel der Vorlage werden diese Zeilen ersetzt + add column aus_vorlage boolean not null default false; + +create table mengenvorlage ( + id uuid primary key default gen_random_uuid(), + -- mengen: nur Mengenblatt; muster: Musterposition mit Texten und Kalkulation + art text not null default 'mengen' check (art in ('mengen', 'muster')), + gruppe text not null, + name text not null, + beschreibung text, + kurztext text, + langtext text, + einheit text, + -- Mengenblatt (Werte, Listen, Aufmaßzeilen, Menge) und Zeitansätze/Material + inhalt jsonb not null default '{"werte": [], "listen": [], "zeilen": [], "ansaetze": []}', + reihenfolge integer not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create trigger mengenvorlage_protokoll before insert or update or delete on mengenvorlage + for each row execute function stempel_und_protokoll(); diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 60c44d8..0e34c29 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -7,6 +7,35 @@ const id = z.uuid(); const text = z.string().trim().min(1, "darf nicht leer sein"); const optText = z.string().trim().nullable().optional(); +// Mengenblatt (A22) als JSON: Werte, Listen, freie Aufmaßzeilen; Formeln bleiben Text, gerechnet wird beim Lesen +const formel = z.string().max(500); +const kurzeFormel = z.string().trim().max(500); +const kuerzel = z.string().trim().max(40); +const blatt = z.object({ + vorlage: z.object({ id: z.string().max(80), name: z.string().max(200) }).nullable().optional(), + werte: z.array(z.object({ kz: kuerzel, bez: z.string().max(200).nullable().optional(), einheit: z.string().max(20).nullable().optional(), formel, eingabe: z.boolean().optional() })).max(300), + listen: z.array(z.object({ + kz: kuerzel, name: z.string().max(200).nullable().optional(), + spalten: z.array(z.object({ kz: kuerzel, bez: z.string().max(200).nullable().optional(), einheit: z.string().max(20).nullable().optional(), art: z.enum(["text", "zahl"]).optional(), formel: formel.nullable().optional() })).max(20), + zeilen: z.array(z.record(z.string().max(40), z.string().max(500))).max(500), + })).max(20), + zeilen: z.array(z.object({ text: z.string().max(300).nullable().optional(), formel })).max(500), + menge: kurzeFormel.nullable().optional(), +}); +// Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position +const ansatz = z.object({ + kostenart: z.enum(["lohn", "material", "geraet", "subunternehmer", "sonstiges"]), + lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), + beschreibung: z.string().max(300).nullable().optional(), + bezug: kurzeFormel.nullable().optional(), + menge: z.number().min(0).max(1e9), + personen: z.number().positive().max(50).optional(), + einheit: z.string().max(20).nullable().optional(), + ek: z.number().int().min(0).nullable().optional(), + faktor: z.number().positive().max(100).optional(), + aktiv: z.boolean().optional(), +}); + export interface Tabelle { name: string; pfad: string; @@ -117,7 +146,8 @@ export const TABELLEN: Tabelle[] = [ ausfall_prozent: z.number().min(0).max(50).optional(), saetze: z.object({ stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(), - zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(), + zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), subunternehmer: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(), + mengen: z.object({ verschnitt: z.number().min(0).max(100), oeffnung_ab: z.number().min(0).max(100) }).partial().optional(), stand: datum.optional(), }).optional(), notiz: optText, @@ -150,6 +180,11 @@ export const TABELLEN: Tabelle[] = [ art: z.enum(["normal", "alternativ", "eventual", "eventual_summe"]).optional(), grundposition_id: id.nullable().optional(), ep_fest: cent.min(0).nullable().optional(), + mit_kalkulation: z.boolean().optional(), + mit_aufmass: z.boolean().optional(), + aufmass: blatt.nullable().optional(), + textzeile: z.boolean().optional(), + markiert: z.boolean().optional(), reihenfolge: z.number().int().optional(), }), }, @@ -159,7 +194,7 @@ export const TABELLEN: Tabelle[] = [ sortierung: "position_id, reihenfolge", schema: z.object({ position_id: id, - kostenart: z.enum(["lohn", "material", "geraet", "sonstiges"]), + kostenart: z.enum(["lohn", "material", "geraet", "subunternehmer", "sonstiges"]), lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), beschreibung: optText, menge: z.number().min(0).max(1e9).optional(), @@ -168,6 +203,27 @@ export const TABELLEN: Tabelle[] = [ faktor: z.number().positive().max(100).optional(), faktor_grund: optText, zuschlag_prozent: z.number().min(0).max(500).nullable().optional(), + bezug: kurzeFormel.nullable().optional(), + personen: z.number().positive().max(50).optional(), + aktiv: z.boolean().optional(), + aus_vorlage: z.boolean().optional(), + reihenfolge: z.number().int().optional(), + }), + }, + // Mengenvorlagen und Musterpositionen (A23): eigene; die mitgelieferten stehen im Programm (domain/mengenvorlagen.ts) + { + name: "mengenvorlage", + pfad: "mengenvorlagen", + sortierung: "gruppe, reihenfolge, name", + schema: z.object({ + art: z.enum(["mengen", "muster"]), + gruppe: text, + name: text, + beschreibung: optText, + kurztext: optText, + langtext: optText, + einheit: optText, + inhalt: blatt.extend({ ansaetze: z.array(ansatz).max(100).default([]) }), reihenfolge: z.number().int().optional(), }), }, diff --git a/src/web/angebote.ts b/src/web/angebote.ts index d6a041d..3a0285c 100644 --- a/src/web/angebote.ts +++ b/src/web/angebote.ts @@ -1,9 +1,14 @@ -// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026). Das Leistungsverzeichnis wird direkt in der Tabelle -// bearbeitet: Titel, Positionen, darunter je Position die Kostenzeilen (Lohn, Material, Gerät, Sonstiges). +// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026), neue Maske nach den Bildern vom 21.10.2026: das +// Leistungsverzeichnis als Liste, die markierte Position zeigt Schalter (Langtext, Aufmaß, Kalkulation) und darunter +// ihre Abschnitte. Rechts Summen, Bausteine, Musterpositionen und Mengenvorlagen, Vorgaben und Prüfung. // Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19). import { formatEuro, parseEuro } from "../domain/geld.js"; -import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME } from "../domain/kalkulation.js"; +import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME, umgebungVon } from "../domain/kalkulation.js"; +import { benenneUm, zahlDeutsch } from "../domain/formel.js"; +import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js"; +import type { Mengenvorlage } from "../domain/mengenvorlagen.js"; +import { alleVorlagen, blattAktion, blattHtml, eingabenAbfragen, kuerzelListe, setze, vorlagenListeHtml, zahlAus, zahlText } from "./mengenblatt.js"; import { plusTage } from "../domain/datum.js"; import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, optionenHtml, seite } from "./ui.js"; import { liste } from "./liste.js"; @@ -12,12 +17,12 @@ export const ANGEBOT_STATUS: Record = { entwurf: "Entwurf", vers const BELEGART: Record = { angebot: "Angebot", kostenvoranschlag: "Kostenvoranschlag" }; const MARKE: Record = { entwurf: "grau", versendet: "offen", angenommen: "gut", abgelehnt: "schlecht" }; -const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ",")); -const zahlAus = (t: string) => { const n = Number(t.trim().replace(/\./g, "").replace(",", ".")); if (!Number.isFinite(n)) throw new Error(`„${t}“ ist keine Zahl`); return n; }; const prozentText = (n: number | null | undefined) => (n == null ? "–" : `${String(n).replace(".", ",")} %`); const stdText = (h: number) => `${String(Math.round(h * 100) / 100).replace(".", ",")} Std.`; /** Cent mit Nachkommastellen (je Einheit), auf den Cent gerundet angezeigt */ const euroGenau = (c: number) => formatEuro(Math.round(c)); +/** Betrag ohne €-Zeichen für enge Tabellenspalten, deren Kopf schon „€“ oder „EK“ sagt */ +const betrag = (c: number) => euroGenau(c).replace(/\s*€$/u, ""); export function angebotMarke(a: Zeile): string { const abgelaufen = a.status === "versendet" && a.bindefrist && a.bindefrist < heute(); @@ -73,14 +78,63 @@ export async function angeboteSeite(): Promise { })); } -// ---------- Angebot bearbeiten ---------- -const offen = new Set(); +// ---------- Angebot bearbeiten (neue Maske, Bilder 1 bis 5 vom 21.10.2026) ---------- -export async function angebotSeite(id: string): Promise { - let d = await api(`angebote/${id}/voll`); - let meldung = ""; - // eigener Rahmen, damit die Ereignisse mit der Seite verschwinden +interface Zustand { + angebot: string; + /** markierte Zeile (Position, Textzeile oder Titel): darunter wird eingefügt, ihre Abschnitte sind offen */ + aktiv: string | null; + /** zugeklappte Abschnitte „:“ */ + zu: Set; + /** Langtext ohne Text sichtbar gemacht, oder mit Text ausgeblendet */ + langtextAn: Set; + langtextAus: Set; + reiter: "bausteine" | "vorlagen" | "kalkulation"; + suche: string; + kopf: boolean; +} +let zustand: Zustand | null = null; +const zustandFuer = (id: string): Zustand => { + if (zustand?.angebot !== id) zustand = { angebot: id, aktiv: null, zu: new Set(), langtextAn: new Set(), langtextAus: new Set(), reiter: "bausteine", suche: "", kopf: false }; + return zustand; +}; + +export const angebotSeite = (id: string) => editor(id, null); + +/** Großes Mengenblatt einer Position (Bilder 3 und 4) */ +export async function mengenblattSeite(positionId: string): Promise { + const p = await api(`angebot-positionen/${positionId}`); + zustandFuer(p.angebot_id).aktiv = positionId; + return editor(p.angebot_id, positionId); +} + +/** OZ aus der Reihenfolge: Titel 01, Positionen 01.0001 (eigene OZ aus einem Import geht vor); Textzeilen ohne OZ */ +function ordnung(d: Zeile) { + const oz: Record = {}; + const gruppen: { titel: Zeile | null; positionen: Zeile[] }[] = []; + const ohne = d.positionen.filter((p: Zeile) => !p.titel_id); + if (ohne.length || !d.titel.length) gruppen.push({ titel: null, positionen: ohne }); + d.titel.forEach((t: Zeile, i: number) => { + oz[t.id] = t.oz || String(i + 1).padStart(2, "0"); + gruppen.push({ titel: t, positionen: d.positionen.filter((p: Zeile) => p.titel_id === t.id) }); + }); + for (const g of gruppen) { + let n = 0; + for (const p of g.positionen) { + if (p.textzeile) { oz[p.id] = ""; continue; } + n++; + oz[p.id] = p.oz || (g.titel ? `${oz[g.titel.id]}.${String(n).padStart(4, "0")}` : String(n).padStart(2, "0")); + } + } + return { oz, gruppen }; +} + +async function editor(id: string, gross: string | null): Promise { + const z = zustandFuer(id); + let [d, vorlagen] = await Promise.all([api(`angebote/${id}/voll`), alleVorlagen()]); + let meldung = hinweis.text ? `${hinweis.gut ? "" : "! "}${hinweis.text}` : ""; + hinweis.text = ""; hinweis.gut = false; const wurzel = document.createElement("div"); inhalt.replaceChildren(wurzel); @@ -90,7 +144,7 @@ export async function angebotSeite(id: string): Promise { const k = fokus?.dataset?.k; const getippt = k && "defaultValue" in fokus! && fokus.value !== fokus.defaultValue ? fokus.value : null; const auswahl = k && typeof fokus!.selectionStart === "number" ? [fokus!.selectionStart, fokus!.selectionEnd] : null; - wurzel.innerHTML = html(d, meldung); + wurzel.innerHTML = gross ? mengenblattHtml(d, z, vorlagen, meldung, gross) : html(d, z, vorlagen, meldung); if (k) { const neu = wurzel.querySelector(`[data-k="${CSS.escape(k)}"]`); if (neu) { @@ -105,27 +159,52 @@ export async function angebotSeite(id: string): Promise { meldung = m; zeichne(); }; - - const entwurf = () => d.angebot.status === "entwurf"; + const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); }; + const pos = (pid: string) => d.positionen.find((x: Zeile) => x.id === pid) as Zeile | undefined; const reihe = (titelId: string | null) => d.positionen.filter((p: Zeile) => (p.titel_id ?? null) === titelId); - const naechste = (liste: Zeile[]) => liste.reduce((m: number, x: Zeile) => Math.max(m, Number(x.reihenfolge) + 1), 0); + const kostenVon = (pid: string) => d.kosten.filter((x: Zeile) => x.position_id === pid) as Zeile[]; + + /** Mengenblatt einer Position ändern: Blatt und neue Menge zusammen speichern */ + const blattSpeichern = async (pid: string, aendern: (b: Blatt) => string[] | boolean) => { + const p = pos(pid)!; + const b = alsBlatt(structuredClone(p.aufmass ?? leeresBlatt())); + const umbenannt = aendern(b); + if (umbenannt === false) return; + const menge = werteBlatt(b, umgebungVon(d.saetze)).menge; + await api(`angebot-positionen/${pid}`, "PATCH", { aufmass: b, ...(menge !== null ? { menge } : {}) }); + // ein umbenanntes Kürzel auch im Bezug der Kostenzeilen + if (Array.isArray(umbenannt) && umbenannt.length === 2) { + for (const k of kostenVon(pid)) { + const neu = k.bezug ? benenneUm(k.bezug, umbenannt[0]!, umbenannt[1]!) : k.bezug; + if (neu !== k.bezug) await api(`angebot-kosten/${k.id}`, "PATCH", { bezug: neu }); + } + } + }; const speichern = async (el: HTMLInputElement) => { - const [pfad, zid, feld] = el.dataset.k!.split(":") as [string, string, string]; + const [pfad, zid, ...rest] = el.dataset.k!.split(":") as [string, string, ...string[]]; + const feld = rest.join(":"); + if (pfad === "blatt") return blattSpeichern(zid, (b) => setze(b, feld, el.value)); const typ = el.dataset.typ ?? "text"; const roh = el.value.trim(); let wert: unknown; - if (typ === "euro") wert = roh ? parseEuro(roh) : null; + if (typ === "bool") wert = el.checked; + else if (typ === "euro") wert = roh ? parseEuro(roh) : null; else if (typ === "zahl") wert = roh ? zahlAus(roh) : el.dataset.leer === "null" ? null : 0; else wert = roh || (el.dataset.leer === "pflicht" ? undefined : null); if (wert === undefined) { el.value = el.defaultValue; throw new Error("Das Feld darf nicht leer sein."); } - let body: Zeile = { [feld]: wert }; + if (pfad === "verkauf") { + // Zuschlag je Kostenart der Position (Bild 2, „Verkauf und Zuschläge“): gilt für alle Zeilen dieser Art + for (const k of kostenVon(zid).filter((x) => x.kostenart === feld)) await api(`angebot-kosten/${k.id}`, "PATCH", { zuschlag_prozent: wert }); + return; + } if (pfad === "saetze") { // Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben - const s = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, stand: d.angebot.saetze?.stand ?? heute() }; + const s = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, stand: d.angebot.saetze?.stand ?? heute() }; (s as Zeile)[zid][feld] = wert ?? 0; return api(`angebote/${id}`, "PATCH", { saetze: s }); } + let body: Zeile = { [feld]: wert }; if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null }; if (pfad === "angebot-kosten" && feld === "kostenart") { const kz = d.kosten.find((x: Zeile) => x.id === zid); @@ -142,15 +221,104 @@ export async function angebotSeite(id: string): Promise { for (const [n, x] of neu.entries()) if (Number(x.reihenfolge) !== n) await api(`${pfad}/${x.id}`, "PATCH", { reihenfolge: n }); }; - zeichne(); + /** Baustein, Musterposition oder Mengenvorlage unter der markierten Zeile einfügen */ + const einfuegen = async (was: string, nachId: string | null, vorlageId?: string, inPosition?: string) => { + if (was === "vorlage") { + const v = vorlagen.find((x) => String(x.id) === vorlageId); + if (!v) return; + if (inPosition) { + const b = alsBlatt(pos(inPosition)?.aufmass); + if ((b.werte.length || b.listen.length) && !(await bestaetigen(`Das Mengenblatt hat schon ${b.vorlage ? `die Vorlage „${b.vorlage.name}“` : "Eingaben"}. Durch „${v.name}“ ersetzen? Die Aufmaßzeilen bleiben.`))) return; + } + const eingaben = await eingabenAbfragen(v); + if (!eingaben) return; + const r = await api(`angebote/${id}/einfuegen`, "POST", { was, vorlage_id: v.id, nach_id: nachId, ...(inPosition ? { position_id: inPosition } : {}), eingaben }); + z.aktiv = r.id; + z.zu.delete(`${r.id}:aufmass`); + return neuLaden(inPosition ? `Vorlage „${v.name}“ ist im Mengenblatt.` : `${v.art === "muster" ? "Musterposition" : "Mengenvorlage"} „${v.name}“ eingefügt.`); + } + const r = await api(`angebote/${id}/einfuegen`, "POST", { was, nach_id: nachId }); + z.aktiv = r.id; + await neuLaden(); + const ziel = was === "titel" ? `angebot-titel:${r.id}:bezeichnung` : `angebot-positionen:${r.id}:kurztext`; + wurzel.querySelector(`[data-k="${ziel}"]`)?.select(); + }; - const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); }; + const alsVorlage = async (pid: string) => { + const p = pos(pid)!; + const r = await dialog("Als Vorlage speichern", [ + { name: "art", titel: "Speichern als", art: "auswahl", optionen: [["muster", "Musterposition mit Texten und Kalkulation"], ["mengen", "nur Mengenvorlage"]] }, + { name: "name", titel: "Name", pflicht: true }, + { name: "gruppe", titel: "Gruppe", pflicht: true, hilfe: `Vorhanden: ${[...new Set(vorlagen.map((v) => v.gruppe))].join(", ")}` }, + ], { art: p.mit_kalkulation ? "muster" : "mengen", name: p.kurztext, gruppe: "Eigene" }, false); + if (r?.aktion !== "speichern") return; + const v = await api(`angebot-positionen/${pid}/als-vorlage`, "POST", r.daten); + vorlagen = await alleVorlagen(true); + meldung = `„${v.name}“ steht jetzt im Katalog unter ${v.gruppe}. Unter Daten → Vorlagen kannst du Eingaben, Formeln und Texte nachschärfen.`; + zeichne(); + }; + + const kopieren = async (pid: string) => { + const p = pos(pid)!; + const n = await api(`angebote/${id}/einfuegen`, "POST", { was: p.textzeile ? "text" : "position", nach_id: pid }); + await api(`angebot-positionen/${n.id}`, "PATCH", { kurztext: p.kurztext, langtext: p.langtext, menge: Number(p.menge), einheit: p.einheit, art: p.art, + ep_fest: p.ep_fest == null ? null : Number(p.ep_fest), mit_kalkulation: p.mit_kalkulation, mit_aufmass: p.mit_aufmass, aufmass: p.aufmass, markiert: p.markiert }); + for (const k of kostenVon(pid)) { + await api("angebot-kosten", "POST", { position_id: n.id, kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, menge: Number(k.menge), einheit: k.einheit, + ek: k.ek == null ? null : Number(k.ek), faktor: Number(k.faktor), faktor_grund: k.faktor_grund, zuschlag_prozent: k.zuschlag_prozent == null ? null : Number(k.zuschlag_prozent), + bezug: k.bezug, personen: Number(k.personen), aktiv: k.aktiv, aus_vorlage: k.aus_vorlage, reihenfolge: k.reihenfolge }); + } + z.aktiv = n.id; + return neuLaden(); + }; + + /** Schalter unter der markierten Position (Bild 1): Langtext, Aufmaß, Kalkulation, Markieren */ + const schalter = async (pid: string, was: string) => { + const p = pos(pid)!, r = d.ergebnis.positionen[pid]; + if (was === "langtext") { + const sichtbar = p.langtext ? !z.langtextAus.has(pid) : z.langtextAn.has(pid); + if (sichtbar) { z.langtextAus.add(pid); z.langtextAn.delete(pid); } else { z.langtextAus.delete(pid); z.langtextAn.add(pid); } + zeichne(); + if (!sichtbar) wurzel.querySelector(`[data-k="angebot-positionen:${pid}:langtext"]`)?.focus(); + return; + } + if (was === "aufmass") { + if (p.mit_aufmass) await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: false, menge: r.menge }); + else { + // ohne Mengenblatt: erste Aufmaßzeile mit der bisherigen Menge, damit nichts verloren geht + const b = alsBlatt(p.aufmass); + if (!b.werte.length && !b.listen.length && !b.zeilen.length) b.zeilen.push({ text: "", formel: zahlText(p.menge) }); + await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: true, aufmass: b }); + z.zu.delete(`${pid}:aufmass`); + } + return neuLaden(); + } + if (was === "kalkulation") { + // aus: der Preis bleibt als fester Preis stehen; an: der Preis kommt wieder aus den Kostenzeilen + if (p.mit_kalkulation) await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: false, ep_fest: r.ep }); + else { + await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: true, ep_fest: null }); + z.zu.delete(`${pid}:kalk`); z.zu.delete(`${pid}:verkauf`); + } + return neuLaden(); + } + if (was === "markiert") { await api(`angebot-positionen/${pid}`, "PATCH", { markiert: !p.markiert }); return neuLaden(); } + }; + + zeichne(); wurzel.addEventListener("change", async (ev) => { const el = ev.target as HTMLInputElement; if (!el.dataset?.k) return; try { await speichern(el); await neuLaden(); } catch (e) { fehler(e); } }); + wurzel.addEventListener("input", (ev) => { + const el = ev.target as HTMLInputElement; + if (el.dataset?.suche === undefined) return; + z.suche = el.value; + const ziel = wurzel.querySelector(".am-katalog-liste"); + if (ziel) ziel.innerHTML = katalogListe(d, z, vorlagen, !!gross); + }); wurzel.addEventListener("keydown", (ev) => { const el = ev.target as HTMLInputElement; // Enter speichert ein Eingabefeld und springt in die Zeile darunter (wie in Excel) @@ -160,81 +328,110 @@ export async function angebotSeite(id: string): Promise { const weiter = felder[felder.indexOf(el) + 1]; if (weiter && el.dataset.spalte) weiter.focus(); else el.blur(); }); + // Bausteine und Vorlagen aus der Seitenleiste in die Liste ziehen + wurzel.addEventListener("dragstart", (ev) => { + const q = (ev.target as HTMLElement).closest("[data-zieh]"); + if (q) ev.dataTransfer?.setData("text/plain", q.dataset.zieh!); + }); + wurzel.addEventListener("dragover", (ev) => { + const ziel = (ev.target as HTMLElement).closest("[data-zeile], .am-lv"); + if (!ziel || !ev.dataTransfer?.types.includes("text/plain")) return; + ev.preventDefault(); + wurzel.querySelectorAll(".am-ziel").forEach((x) => x.classList.remove("am-ziel")); + ziel.classList.add("am-ziel"); + }); + wurzel.addEventListener("dragleave", (ev) => (ev.target as HTMLElement).closest?.(".am-ziel")?.classList.remove("am-ziel")); + wurzel.addEventListener("drop", async (ev) => { + const was = ev.dataTransfer?.getData("text/plain"); + wurzel.querySelectorAll(".am-ziel").forEach((x) => x.classList.remove("am-ziel")); + if (!was) return; + ev.preventDefault(); + const zeile = (ev.target as HTMLElement).closest("[data-zeile]")?.dataset.zeile ?? null; + try { + if (was.startsWith("vorlage:")) await einfuegen("vorlage", zeile, was.slice(8)); + else await einfuegen(was, zeile); + } catch (e) { fehler(e); } + }); wurzel.addEventListener("click", async (ev) => { const b = (ev.target as HTMLElement).closest("[data-a]"); if (!b) return; const a = b.dataset.a!, zid = b.dataset.id ?? ""; + // Menü der Zeile nach der Wahl schließen + b.closest("details.am-menue")?.removeAttribute("open"); try { - if (a === "auf") { offen.has(zid) ? offen.delete(zid) : offen.add(zid); return zeichne(); } - if (a === "titel-neu") { - await api("angebot-titel", "POST", { angebot_id: id, bezeichnung: "Neuer Titel", reihenfolge: naechste(d.titel) }); - await neuLaden(); - const t = d.titel.at(-1); - if (t) wurzel.querySelector(`[data-k="angebot-titel:${t.id}:bezeichnung"]`)?.select(); - return; - } - if (a === "position-neu") { - const titelId = zid || null; - const p = await api("angebot-positionen", "POST", { angebot_id: id, titel_id: titelId, kurztext: "Neue Position", menge: 1, einheit: "St", reihenfolge: naechste(reihe(titelId)) }); - offen.add(p.id); - await neuLaden(); - wurzel.querySelector(`[data-k="angebot-positionen:${p.id}:kurztext"]`)?.select(); + if (a === "aktiv") { + if (z.aktiv === zid) return; + z.aktiv = zid; + return zeichne(); + } + if (a.startsWith("b-")) { + const pid = b.dataset.b!.split(":")[1]!; + return await blattSpeichern(pid, (x) => blattAktion(x, a, b.dataset)).then(() => neuLaden()); + } + if (a === "chip") return await schalter(zid, b.dataset.was!); + if (a === "abschnitt") { const k = `${zid}:${b.dataset.was}`; z.zu.has(k) ? z.zu.delete(k) : z.zu.add(k); return zeichne(); } + if (a === "fertig") { z.aktiv = null; return zeichne(); } + if (a === "reiter") { + z.reiter = b.dataset.was as Zustand["reiter"]; + zeichne(); + wurzel.querySelector(".am-reiter-karte")?.scrollIntoView({ block: "nearest" }); return; } + if (a === "kopf") { z.kopf = !z.kopf; return zeichne(); } + if (a === "neu") return await einfuegen(b.dataset.was!, z.aktiv); + if (a === "vorlage") return await einfuegen("vorlage", z.aktiv, zid, b.dataset.in); + if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; } + if (a === "als-vorlage") return await alsVorlage(zid); if (a === "kosten-neu") { const art = b.dataset.art!; - const pos = d.positionen.find((x: Zeile) => x.id === zid); - const k = await api("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: 1, - einheit: art === "lohn" ? "h" : pos?.einheit ?? null, reihenfolge: naechste(d.kosten.filter((x: Zeile) => x.position_id === zid)) }); + const p = pos(zid)!; + const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null; + const k = await api("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1, + bezug: blatt?.menge?.trim() || null, einheit: art === "lohn" ? "h" : p.einheit ?? null, reihenfolge: kostenVon(zid).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) }); await neuLaden(); - wurzel.querySelector(`[data-k="angebot-kosten:${k.id}:${art === "lohn" ? "menge" : "beschreibung"}"]`)?.focus(); + wurzel.querySelector(`[data-k="angebot-kosten:${k.id}:beschreibung"]`)?.focus(); return; } if (a === "kosten-weg") { await api(`angebot-kosten/${zid}`, "DELETE"); return neuLaden(); } if (a === "position-weg") { - if (!(await bestaetigen("Position mit ihren Kostenzeilen löschen?"))) return; + const p = pos(zid)!; + if (!(await bestaetigen(p.textzeile ? "Textzeile löschen?" : "Position mit Mengenblatt und Kostenzeilen löschen?"))) return; await api(`angebot-positionen/${zid}`, "DELETE"); + if (z.aktiv === zid) z.aktiv = null; return neuLaden(); } if (a === "titel-weg") { const n = reihe(zid).length; - if (!(await bestaetigen(n ? `Titel mit ${n} ${n === 1 ? "Position" : "Positionen"} löschen?` : "Titel löschen?"))) return; + if (!(await bestaetigen(n ? `Titel mit ${n} ${n === 1 ? "Zeile" : "Zeilen"} löschen?` : "Titel löschen?"))) return; await api(`angebot-titel/${zid}`, "DELETE"); return neuLaden(); } - if (a === "position-kopie") { - const p = d.positionen.find((x: Zeile) => x.id === zid)!; - const n = await api("angebot-positionen", "POST", { angebot_id: id, titel_id: p.titel_id, kurztext: p.kurztext, langtext: p.langtext, menge: Number(p.menge), - einheit: p.einheit, art: p.art, ep_fest: p.ep_fest == null ? null : Number(p.ep_fest), reihenfolge: naechste(reihe(p.titel_id ?? null)) }); - for (const k of d.kosten.filter((x: Zeile) => x.position_id === zid)) { - await api("angebot-kosten", "POST", { position_id: n.id, kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, menge: Number(k.menge), einheit: k.einheit, - ek: k.ek == null ? null : Number(k.ek), faktor: Number(k.faktor), faktor_grund: k.faktor_grund, zuschlag_prozent: k.zuschlag_prozent == null ? null : Number(k.zuschlag_prozent), reihenfolge: k.reihenfolge }); - } - offen.add(n.id); - return neuLaden(); - } + if (a === "position-kopie") return await kopieren(zid); if (a === "position-hoch" || a === "position-runter") { - const p = d.positionen.find((x: Zeile) => x.id === zid)!; + const p = pos(zid)!; await verschieben("angebot-positionen", reihe(p.titel_id ?? null), zid, a === "position-hoch" ? -1 : 1); return neuLaden(); } if (a === "titel-hoch" || a === "titel-runter") { await verschieben("angebot-titel", d.titel, zid, a === "titel-hoch" ? -1 : 1); return neuLaden(); } if (a === "pruefung") { const pid = b.dataset.pos; - if (pid) { offen.add(pid); zeichne(); wurzel.querySelector(`[data-zeile="${pid}"]`)?.scrollIntoView({ block: "center" }); } + if (pid) { + if (gross) { location.hash = `angebot-${id}`; z.aktiv = pid; return; } + z.aktiv = pid; zeichne(); wurzel.querySelector(`[data-zeile="${pid}"]`)?.scrollIntoView({ block: "center" }); + } return; } - if (a === "versenden") return versenden(false); + if (a === "versenden") return await versenden(false); if (a === "bearbeiten") { await api(`angebote/${id}/bearbeiten`, "POST", {}); return neuLaden("Das Angebot ist wieder im Entwurf. Der versendete Stand bleibt gespeichert."); } if (a === "ablehnen") { if (!(await bestaetigen("Angebot als abgelehnt markieren?"))) return; await api(`angebote/${id}/ablehnen`, "POST", {}); return neuLaden(); } - if (a === "annehmen") return annehmen(); + if (a === "annehmen") return await annehmen(); if (a === "version") { if (!(await bestaetigen("Neue Version als Kopie dieses Angebots anlegen?"))) return; - return neuesAngebot(d.angebot.projekt_id, id); + return await neuesAngebot(d.angebot.projekt_id, id); } if (a === "loeschen") { if (!(await bestaetigen(`${BELEGART[d.angebot.belegart]} ${d.angebot.nummer} löschen?`))) return; @@ -281,141 +478,294 @@ export async function angebotSeite(id: string): Promise { // ---------- Darstellung ---------- -function html(d: Zeile, meldung: string): string { +type Feldoptionen = { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string; nurLesen?: boolean }; +const feldBau = (frei: boolean) => (k: string, wert: unknown, o: Feldoptionen = {}) => + ``; +const auswahlBau = (frei: boolean) => (k: string, optionen: [string, string][], wert: string, titel: string) => + ``; +const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false)); +const chip = (text: string, an: boolean, was: string, pid: string, frei: boolean) => + ``; +const wgp = (s: Zeile) => s.wagnis + s.gewinn + s.ausfall; + +/** Kostenzeilen einer Position (Bild 2, „Kalkulation (Kosten)“): Bezug × Ansatz × Personen = Menge der ganzen Position */ +function kostenTabelle(d: Zeile, p: Zeile, frei: boolean): string { + const feld = feldBau(frei), auswahl = auswahlBau(frei); + const s = d.saetze, r = d.ergebnis.positionen[p.id]; + const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id); + const menge = r.menge; + let lohnStd = 0, summe = 0; + const rumpf = zeilen.map((k: Zeile, i: number) => { + const z = r.kostenzeilen[i] ?? { kosten: 0, menge_gesamt: 0, aktiv: true, fehler: null }; + const lohn = k.kostenart === "lohn"; + if (lohn && z.aktiv) lohnStd += z.menge_gesamt; + if (z.aktiv) summe += z.kosten * menge; + return `${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")} + ${feld(`angebot-kosten:${k.id}:beschreibung`, k.beschreibung ?? "", { klasse: "w-bez", titel: "Bezeichnung", platz: lohn ? "Tätigkeit" : "z. B. KVH 6/12" })} + ${feld(`angebot-kosten:${k.id}:bezug`, k.bezug ?? "", { klasse: `am-formel w-bezug${z.fehler ? " mit-fehler" : ""}`, titel: "Bezug (Kürzel aus dem Mengenblatt, leer = je Einheit)", platz: `je ${p.einheit}`, liste: "am-kuerzel" })}${z.fehler ? `${esc(z.fehler)}` : ""} + ${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-ansatz am-eingabe", titel: lohn ? "Std je Einheit" : "Menge je Einheit", spalte: `km-${p.id}` })} + ${lohn ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: "Personen" }) : ""} + ${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}${lohn ? " h" : ""} + ${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })} + ${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-ek", leer: "null", titel: "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : "0,00", spalte: `ke-${p.id}` })} + ${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })} + ${betrag(z.kosten * menge)} + ${frei ? `` : ""}`; + }).join(""); + if (!frei && !zeilen.length) return '

Keine Kostenzeilen.

'; + return `
+ ${rumpf}
ArtBezeichnungBezugAnsatzPers.MengeLohnart / Einh.EKFaktorEK gesamt✓
Kosten gesamt${menge > 0 ? ` (${euro(r.kosten_je_einheit)} je ${esc(p.einheit)})` : ""}${lohnStd ? `${zahlDeutsch(lohnStd, "h")} h` : ""}${betrag(summe)}
+ ${frei ? `
${KOSTENARTEN.map((x) => ``).join("")}
` : ""} +

Menge = Bezug × Ansatz × Personen, wie in deiner Urkalk. Der Bezug ist ein Kürzel aus dem Mengenblatt (z. B. HL); leer heißt je ${esc(p.einheit)} der Position. Abgewählte Zeilen (✓) bleiben stehen und zählen nicht.

`; +} + +/** „Verkauf und Zuschläge“ je Kostenart der Position, mit „Preis anpassen“ (A21) */ +function verkaufTabelle(d: Zeile, p: Zeile, frei: boolean): string { + const feld = feldBau(frei); + const s = d.saetze, r = d.ergebnis.positionen[p.id]; + const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id) as Zeile[]; + const arten = KOSTENARTEN.filter((x) => zeilen.some((k) => k.kostenart === x)); + let ekS = 0, zuS = 0, wgS = 0, vkS = 0; + const rumpf = arten.map((x) => { + let ek = 0, zu = 0; + zeilen.forEach((k, i) => { if (k.kostenart === x) { const z = r.kostenzeilen[i]!; ek += z.kosten * r.menge; zu += z.kosten * r.menge * z.zuschlag / 100; } }); + const wg = (ek + zu) * wgp(s) / 100, vk = ek + zu + wg; + ekS += ek; zuS += zu; wgS += wg; vkS += vk; + const eigene = [...new Set(zeilen.filter((k) => k.kostenart === x).map((k) => (k.zuschlag_prozent == null ? "" : String(Number(k.zuschlag_prozent)))))]; + const wert = eigene.length === 1 ? zahlText(eigene[0]) : ""; + return `${KOSTENART_NAME[x]}${euroGenau(ek)} + ${feld(`verkauf:${p.id}:${x}`, wert, { typ: "zahl", klasse: "zahl w-kurz", leer: "null", titel: `Zuschlag ${KOSTENART_NAME[x]} in Prozent`, platz: eigene.length > 1 ? "gemischt" : zahlText(s.zuschlaege[x]) })} % + ${euroGenau(zu)}${prozentText(wgp(s))}${euroGenau(vk)}`; + }).join(""); + const fest = p.ep_fest != null; + return `
+ ${rumpf || ''}
KostenartEK gesamtZuschlagZuschlag €Wagnis + Gewinn + AusfallVK gesamt
Noch keine Kostenzeile.
Summe${euroGenau(ekS)}${euroGenau(zuS)}${euroGenau(wgS)}${euroGenau(vkS)}
+
Einheitspreis kalkuliert ${euro(r.ep_kalkuliert)} je ${esc(p.einheit)}${fest ? `, angepasst auf ${euro(r.ep)}` : ""}; Gesamt ${zahlDeutsch(r.menge, p.einheit)} × ${euro(r.ep)} = ${euro(r.gb)} +
+

Leeres Zuschlagsfeld: Vorgabe des Angebots. Wagnis, Gewinn und Ausfall stellst du rechts unter „Vorgaben dieses Angebots“ ein.

`; +} + +/** Aufmaß-Abschnitt in der Position (Bild 2 und 5) */ +function aufmassAbschnitt(d: Zeile, p: Zeile, frei: boolean): string { + const b = alsBlatt(p.aufmass); + const a = werteBlatt(b, umgebungVon(d.saetze)); + return `${blattHtml(b, a, { k: `blatt:${p.id}:`, frei, modus: "inline", einheit: p.einheit })} +
${frei ? ` + ` : ""} + + Jede Zeile darf rechnen (+ − * / Klammern, cos, wurzel …). Mit einer Vorlage kommen Kürzel und Bauteillisten dazu.
`; +} + +function abschnitt(z: Zustand, pid: string, was: string, titel: string, info: string, rumpf: string): string { + const zu = z.zu.has(`${pid}:${was}`); + return `

${info}

+ ${zu ? "" : `
${rumpf}
`}
`; +} + +function offenePosition(d: Zeile, z: Zustand, p: Zeile, frei: boolean): string { + const r = d.ergebnis.positionen[p.id]; + const teile: string[] = []; + const langtext = p.langtext ? !z.langtextAus.has(p.id) : z.langtextAn.has(p.id); + if (langtext) teile.push(abschnitt(z, p.id, "langtext", "Langtext", p.langtext && /\{[\p{L}_]/u.test(p.langtext) ? "{Kürzel} wird mit dem Mengenblatt ersetzt" : "", + ``)); + if (p.mit_aufmass) { + const b = alsBlatt(p.aufmass); + teile.push(abschnitt(z, p.id, "aufmass", "Aufmaß und Mengenermittlung", + `${b.vorlage ? `Vorlage ${esc(b.vorlage.name)} · ` : b.werte.length ? "" : "frei, ohne Vorlage · "}Menge = ${b.menge?.trim() ? `${esc(b.menge)} ` : "Summe "}${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}${r.aufmass_fehler ? ` ${esc(r.aufmass_fehler)}` : ""}`, + aufmassAbschnitt(d, p, frei))); + } + if (p.mit_kalkulation) { + teile.push(abschnitt(z, p.id, "kalk", "Kalkulation (Kosten)", `Kosten ${euro(r.kosten_gesamt)}${r.stunden ? ` · ${stdText(r.stunden)}` : ""}`, kostenTabelle(d, p, frei))); + const ueber = r.kosten_je_einheit > 0 ? Math.round(((r.ep - r.kosten_je_einheit) / r.kosten_je_einheit) * 1000) / 10 : null; + teile.push(abschnitt(z, p.id, "verkauf", "Verkauf und Zuschläge", `EP ${euro(r.ep)}${ueber !== null ? ` · Überschuss ${prozentText(ueber)}` : ""}`, verkaufTabelle(d, p, frei))); + } + if (!teile.length) return ""; + return `
${teile.join("")} +
Alles wird sofort gespeichert.${p.art && p.art !== "normal" ? ` Positionsart: ${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}.` : ""} +
`; +} + +const menue = (eintraege: [string, string, string, boolean?][]) => `
⋮ +
${eintraege.map(([a, idw, text, aus]) => ``).join("")}
`; + +function zeilenHtml(d: Zeile, z: Zustand, oz: Record, p: Zeile, liste: Zeile[], j: number, frei: boolean): string { + const feld = feldBau(frei), auswahl = auswahlBau(frei); + const r = d.ergebnis.positionen[p.id]; + const aktiv = z.aktiv === p.id; + const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler"); + const knoepfe = frei ? menue([["position-hoch", p.id, "Nach oben", j === 0], ["position-runter", p.id, "Nach unten", j === liste.length - 1], ["position-kopie", p.id, "Kopieren"], + ...(p.textzeile ? [] : [["als-vorlage", p.id, "Als Musterposition speichern"] as [string, string, string]]), ["position-weg", p.id, "Löschen"]]) : ""; + if (p.textzeile) { + return `
+
${knoepfe}
`; + } + const blatt = p.mit_aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(d.saetze)) : null; + const ersetzt = blatt ? textMitWerten(p.kurztext, blatt) : p.kurztext; + const unter = [ + ersetzt !== p.kurztext ? `= ${esc(ersetzt)}` : "", + p.art === "alternativ" ? `Alternativ${p.grundposition_id && oz[p.grundposition_id] ? ` zu ${esc(oz[p.grundposition_id])}` : ""}, zählt nicht zur Summe` : "", + p.art === "eventual" ? "Eventualposition, zählt nicht zur Summe" : p.art === "eventual_summe" ? "Eventualposition, einkalkuliert" : "", + ].filter(Boolean); + const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ" && !x.textzeile); + const chips = aktiv ? `
${chip("Langtext", p.langtext ? !z.langtextAus.has(p.id) : z.langtextAn.has(p.id), "langtext", p.id, frei)}${chip("Aufmaß", !!p.mit_aufmass, "aufmass", p.id, frei)} + ${chip("Kalkulation", !!p.mit_kalkulation, "kalkulation", p.id, frei)}${chip("Markieren", !!p.markiert, "markiert", p.id, frei)} + ${auswahl(`angebot-positionen:${p.id}:art`, POSITIONSARTEN.map((x) => [x, POSITIONSART_NAME[x]]), p.art ?? "normal", "Positionsart")} + ${p.art === "alternativ" ? `${auswahl(`angebot-positionen:${p.id}:grundposition_id`, [["", "Alternativ zu …"], ...grund.map((x: Zeile): [string, string] => [x.id, `${oz[x.id]} ${x.kurztext}`])], p.grundposition_id ?? "", "Grundposition")}` : ""}
` : ""; + const menge = p.mit_aufmass + ? `Aufmaß` + : feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" }); + const ep = p.mit_kalkulation + ? `${p.ep_fest != null ? "angepasst" : "Kalkulation"}` + : `${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl", leer: "null", titel: "Einheitspreis", platz: "0,00", spalte: "ep" })}ohne Kalk.`; + return `
+
${esc(oz[p.id])}
+
${menge}
+
${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", titel: "Einheit", liste: "einheiten", spalte: "einheit" })}
+
${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${p.langtext && !aktiv ? '¶ Langtext' : ""} + ${unter.length ? `
${unter.join(" · ")}
` : ""}${chips}
+
${ep}
+
${r.zaehlt ? euro(r.gb) : `(${euro(r.gb)})`}
+
${knoepfe}
+ ${aktiv ? offenePosition(d, z, p, frei) : ""}`; +} + +/** Musterpositionen oder Mengenvorlagen für die Seitenleiste */ +function katalogListe(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: boolean): string { + const frei = d.angebot.status === "entwurf"; + const aktivePos = z.aktiv && d.positionen.some((p: Zeile) => p.id === z.aktiv && !p.textzeile) ? z.aktiv : null; + return vorlagenListeHtml(vorlagen, { art: z.reiter === "vorlagen" || gross ? "mengen" : "muster", suche: z.suche, ziel: z.reiter === "vorlagen" || gross ? aktivePos : null, frei }); +} + +function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: string | null): string { const a = d.angebot, e = d.ergebnis, s = d.saetze; const frei = a.status === "entwurf"; - const aus = frei ? "" : " disabled"; - const feld = (k: string, wert: unknown, o: { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string } = {}) => - ``; - const auswahl = (k: string, optionen: [string, string][], wert: string, titel: string) => ``; - const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false)); - - // OZ aus der Reihenfolge: Titel 01, Positionen 01.0001 (eigene OZ aus einem Import geht vor) - const oz: Record = {}; - const gruppen: { titel: Zeile | null; positionen: Zeile[] }[] = []; - const ohne = d.positionen.filter((p: Zeile) => !p.titel_id); - if (ohne.length || !d.titel.length) gruppen.push({ titel: null, positionen: ohne }); - d.titel.forEach((t: Zeile, i: number) => { - oz[t.id] = t.oz || String(i + 1).padStart(2, "0"); - gruppen.push({ titel: t, positionen: d.positionen.filter((p: Zeile) => p.titel_id === t.id) }); - }); - for (const g of gruppen) g.positionen.forEach((p, j) => (oz[p.id] = p.oz || (g.titel ? `${oz[g.titel.id]}.${String(j + 1).padStart(4, "0")}` : String(j + 1).padStart(2, "0")))); - - const kostenZeilen = (p: Zeile) => { - const r = e.positionen[p.id]; - const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id); - if (!frei && !zeilen.length) return '

Ohne Kalkulation, fester Preis.

'; - return `
- ${zeilen.map((k: Zeile, i: number) => { - const z = r.kostenzeilen[i] ?? { kosten: 0, verkauf: 0 }; - const lohn = k.kostenart === "lohn"; - return ` - - - - - - - - `; - }).join("")} - -
ArtBezeichnungMenge je ${esc(p.einheit)}EinheitEKFaktorZuschlagKostenVerkauf
${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")}${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : ""}${feld(`angebot-kosten:${k.id}:beschreibung`, k.beschreibung ?? "", { titel: "Bezeichnung", platz: lohn ? "Tätigkeit" : "z. B. KVH 6/12" })}${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-menge", titel: "Menge", spalte: `km-${p.id}` })}${lohn ? 'h' : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-kurz", titel: "Einheit", liste: "einheiten" })}${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : "0,00", spalte: `ke-${p.id}` })}${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-kurz", titel: "Faktor" })}${feld(`angebot-kosten:${k.id}:zuschlag_prozent`, zahlText(k.zuschlag_prozent), { typ: "zahl", klasse: "zahl w-kurz", leer: "null", titel: "Zuschlag in Prozent", platz: zahlText(s.zuschlaege[k.kostenart]) })} %${euroGenau(z.kosten)}${euroGenau(z.verkauf)}${frei ? `` : ""}
${frei ? KOSTENARTEN.map((x) => ``).join(" ") : ""}${euro(r.kosten_je_einheit)}${euro(r.ep_kalkuliert)}
-

Je ${esc(p.einheit)}: Kosten ${euro(r.kosten_je_einheit)}, Einheitspreis kalkuliert ${euro(r.ep_kalkuliert)}${r.std_je_einheit ? `, ${String(r.std_je_einheit).replace(".", ",")} Std` : ""}. Verkauf = Kosten × Zuschlag × (Wagnis + Gewinn + Ausfall ${prozentText(s.wagnis + s.gewinn + s.ausfall)}).

`; - }; - - const positionZeilen = (p: Zeile, liste: Zeile[], j: number) => { - const r = e.positionen[p.id]; - const auf = offen.has(p.id); - const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler"); - const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ"); - return ` - ${esc(oz[p.id])} - ${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${p.art && p.art !== "normal" ? `${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}` : ""} - ${feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" })} - ${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", klasse: "kurz", titel: "Einheit", liste: "einheiten", spalte: "einheit" })} - ${euro(r.ep)}${p.ep_fest != null ? 'fest' : ""} - ${r.zaehlt ? euro(r.gb) : `(${euro(r.gb)})`} - ${r.stunden ? String(r.stunden).replace(".", ",") : ""} - ${auf ? `
- ${frei || p.langtext ? `` : ""} -
- - ${p.art === "alternativ" ? `` : ""} - - ${frei ? ` - ` : ""} -
${kostenZeilen(p)}
` : ""}`; - }; - - const lv = gruppen.map((g, gi) => `${g.titel ? `${esc(oz[g.titel.id])} - ${feld(`angebot-titel:${g.titel.id}:bezeichnung`, g.titel.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" })}${frei ? `` : ""} - ${euro(e.titel[g.titel.id])}` : ""} - ${g.positionen.map((p, j) => positionZeilen(p, g.positionen, j)).join("")} - ${frei && (g.titel || !d.titel.length) ? `` : ""}`).join(""); - + const feld = feldBau(frei); + const ka = e.kostenarten; + const staende = (a.staende ?? []) as Zeile[]; const fehlerZahl = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length; + const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv && !p.textzeile) : null; + const { oz } = ordnung(d); + const reiter = gross ? "vorlagen" : z.reiter; + const reiterKnopf = (r: Zustand["reiter"], text: string) => ``; + const baustein = (was: string, text: string) => `
${text}${frei ? `` : ""}
`; + const katalog = reiter === "kalkulation" ? ` + ${([...KOSTENARTEN, "ohne"] as const).filter((x) => x === "lohn" || x === "material" || ka[x].kosten || ka[x].verkauf).map((x) => ` + `).join("")} +
KostenZuschlagVerkauf
${KOSTENART_NAME[x]}${euro(ka[x].kosten)}${euro(ka[x].zuschlag)}${prozentText(ka[x].prozent)}${euro(ka[x].verkauf)}
Summe${euro(e.kosten)}${euro(e.netto - e.kosten)}${euro(e.netto)}
` + : `${reiter === "bausteine" && frei ? `${baustein("titel", "Titel")}${baustein("position", "Position")}${baustein("text", "Text")}` : ""} + +
${katalogListe(d, z, vorlagen, !!gross)}
+

${reiter === "bausteine" ? "Ziehen oder + fügt unter der markierten Zeile ein." : aktivePos ? `+ fügt die Vorlage ins Mengenblatt von ${esc(oz[aktivePos.id])} ein.` : "Markiere eine Position, dann kommt die Vorlage in ihr Mengenblatt. Ohne Markierung entsteht eine neue Position."} + Alle Vorlagen und eigene anlegen

`; + return ``; +} + +function kopfHtml(d: Zeile, z: Zustand, meldung: string): string { + const a = d.angebot; + const frei = a.status === "entwurf"; + const feld = feldBau(frei), auswahl = auswahlBau(frei); const knoepfe = { entwurf: ``, versendet: ``, abgelehnt: ``, angenommen: "", }[a.status as string] ?? ""; - const ka = e.kostenarten; - const staende = (a.staende ?? []) as Zeile[]; - - return `${EINHEITEN.map((x) => ` -
← + return `
←

${esc(BELEGART[a.belegart])} ${esc(a.nummer)}

${angebotMarke(a)} - ${knoepfe}${a.status !== "angenommen" ? '' : ""}
+ ${knoepfe}${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}
${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""} -

${esc(a.projekt_nummer)} ${esc(a.projekt_name)}${a.bauherr_name ? ` · ${esc(a.bauherr_name)}${a.bauherr_firma ? `, ${esc(a.bauherr_firma)}` : ""}` : ' · kein Bauherr eingetragen'} - ${frei ? "" : ` · festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}`}

-
-
-
- - - - - -
-
- - - ${lv} -
OZLeistungMengeEinheitEPGBStd.
${frei ? '' : ""}${euro(e.netto)}
- ${d.positionen.length ? "" : '

Lege Titel (z. B. „Dachstuhl“, „Dämmung“) und darin Positionen an. Mit ▸ öffnest du je Position die Kalkulation.

'}
-
-

{bindefrist} wird im Angebot durch das Datum ersetzt.

-
- +
+ Empfänger${a.bauherr_name ? `${esc(a.bauherr_name)}${a.bauherr_firma ? `, ${esc(a.bauherr_firma)}` : ""}` : 'kein Bauherr eingetragen'} + Projekt${esc(a.projekt_nummer)} ${esc(a.projekt_name)} + Betreff${esc(a.betreff || "–")} + Datum${dat(a.datum)}Bindefrist${dat(a.bindefrist) || "–"} +
+ ${frei ? "" : `

Festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}.

`} + ${z.kopf ? `
+ + + + + + +

{bindefrist} wird im Angebot durch das Datum ersetzt.

` : ""}
`; +} + +const datenlisten = (b: Blatt | null) => `${EINHEITEN.map((x) => `${kuerzelListe("am-kuerzel", b ?? leeresBlatt())}`; + +function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string): string { + const a = d.angebot, e = d.ergebnis; + const frei = a.status === "entwurf"; + const feld = feldBau(frei); + const { oz, gruppen } = ordnung(d); + const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv) : null; + const lv = gruppen.map((g, gi) => `${g.titel ? `
+
${esc(oz[g.titel.id])}
${feld(`angebot-titel:${g.titel.id}:bezeichnung`, g.titel.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" })}
+
${euro(e.titel[g.titel.id])}
+
${frei ? menue([["titel-hoch", g.titel.id, "Nach oben", gi === (gruppen[0]!.titel ? 0 : 1)], ["titel-runter", g.titel.id, "Nach unten", gi === gruppen.length - 1], ["titel-weg", g.titel.id, "Löschen"]]) : ""}
` : ""} + ${g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("")}`).join(""); + return `${datenlisten(aktivePos?.mit_aufmass ? alsBlatt(aktivePos.aufmass) : null)}${kopfHtml(d, z, meldung)} +
+
+
Pos.
Menge
Einheit
Beschreibung
EP
Gesamt
+ ${lv} + ${d.positionen.length ? "" : '

Lege Titel (z. B. „Dachstuhl“) und Positionen an, oder ziehe rechts eine Musterposition hinein.

'} + ${frei ? `
+ + ${aktivePos || z.aktiv ? 'kommt unter die markierte Zeile' : ""}
` : ""} +
Netto ${euro(e.netto)}Brutto ${euro(e.brutto)}
+
+ ${seitenleiste(d, z, vorlagen, null)}
`; } + +/** Großes Mengenblatt (Bilder 3 und 4): alle Eingaben, Formeln und Listen, darunter die Zeitansätze */ +function mengenblattHtml(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string, pid: string): string { + const p = d.positionen.find((x: Zeile) => x.id === pid); + if (!p) return `

Diese Position gibt es nicht mehr.

Zum Angebot

`; + const frei = d.angebot.status === "entwurf"; + const { oz } = ordnung(d); + const r = d.ergebnis.positionen[pid]; + const b = alsBlatt(p.aufmass); + const a = werteBlatt(b, umgebungVon(d.saetze)); + return `${datenlisten(b)} +
← +

Mengenermittlung ${esc(oz[pid])} ${esc(p.kurztext)}

+ ${frei ? `` : ""}Fertig
+ ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""} + ${p.mit_aufmass ? "" : `
Bei dieser Position ist „Aufmaß“ aus; die Menge wird von Hand eingetragen. ${frei ? '' : ""}
`} +
+
${frei ? `${b.vorlage ? `Eingefügt: ${esc(b.vorlage.name)}. Rechts eine andere Vorlage wählen, um sie zu ersetzen.` : "Rechts eine Vorlage wählen, oder Eingaben und Formeln selbst anlegen."}` : ""}
+ ${blattHtml(b, a, { k: `blatt:${pid}:`, frei, modus: "gross", einheit: p.einheit })}
+

Zeitansätze und Material verknüpft mit dem Mengenblatt

+ ${p.mit_kalkulation ? kostenTabelle(d, p, frei) : `

Bei dieser Position ist „Kalkulation“ aus. ${frei ? `` : ""}

`}
+
+
+
Menge der Position
${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}
+
Einheitspreis
${euro(r.ep)}
Gesamt
${euro(r.gb)}
${r.stunden ? `
Stunden
${stdText(r.stunden)}
` : ""}
+ ${seitenleiste(d, z, vorlagen, pid).replace(/^
`; +} diff --git a/src/web/app.ts b/src/web/app.ts index 9b27870..b582db2 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -11,7 +11,8 @@ import { gesamtFortschritt } from "../domain/fortschritt.js"; import { naechsteNummer } from "../domain/kalkulation.js"; import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js"; import { meineStunden, stundenSeite } from "./stunden.js"; -import { angebotSeite, angeboteHtml, angeboteSeite, neuesAngebot } from "./angebote.js"; +import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngebot } from "./angebote.js"; +import { vorlageSeite, vorlagenSeite } from "./mengenblatt.js"; // ---------- Reiter ---------- @@ -887,8 +888,11 @@ async function daten(): Promise { { name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" }, { name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Gilt für neue Angebote. Die genauen Sätze kommen aus deiner Stundensatz-Tabelle." }, { name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" }, - { name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" }, + { name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_subunternehmer", titel: "Zuschlag Subunternehmer (%)", art: "zahl" }, + { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" }, { name: "wagnis", titel: "Wagnis (%)", art: "zahl" }, { name: "gewinn", titel: "Gewinn (%)", art: "zahl" }, { name: "ausfall", titel: "Zahlungsausfall (%)", art: "zahl" }, + { name: "verschnitt", titel: "Verschnitt in Mengenblättern (%)", art: "zahl" }, + { name: "oeffnungAb", titel: "Öffnungen abziehen ab (m²)", art: "zahl", hilfe: "E28: kleinere Öffnungen werden übermessen." }, { name: "bindefristWochen", titel: "Bindefrist (Wochen)", art: "zahl" }, { name: "erinnerungTage", titel: "Erinnerung vor Ablauf der Bindefrist (Tage)", art: "zahl" }, { name: "kopftext", titel: "Einleitung", art: "langtext" }, @@ -903,14 +907,19 @@ async function daten(): Promise { const d = r.daten, z = (n: string, alt: number) => (d[n] ?? alt) as number; await api("einstellungen", "PUT", { ...e, kalkulation: { stundensaetze: { planer: z("planer", 0), geselle: z("geselle", 0), helfer: z("helfer", 0) }, - zuschlaege: { lohn: z("z_lohn", 0), material: z("z_material", 0), geraet: z("z_geraet", 0), sonstiges: z("z_sonstiges", 0) }, + zuschlaege: { lohn: z("z_lohn", 0), material: z("z_material", 0), geraet: z("z_geraet", 0), subunternehmer: z("z_subunternehmer", 0), sonstiges: z("z_sonstiges", 0) }, wagnis: z("wagnis", 0), gewinn: z("gewinn", 0), ausfall: z("ausfall", 0), + verschnitt: z("verschnitt", k.verschnitt), oeffnungAb: z("oeffnungAb", k.oeffnungAb), bindefristWochen: Math.round(z("bindefristWochen", k.bindefristWochen)), erinnerungTage: Math.round(z("erinnerungTage", k.erinnerungTage)), kopftext: d.kopftext ?? "", schlusstext: d.schlusstext ?? "", } }); daten(); }; - inhalt.append(" ", kalkKnopf); + const vorlagenLink = document.createElement("a"); + vorlagenLink.className = "neben"; + vorlagenLink.href = "#vorlagen"; + vorlagenLink.textContent = "Vorlagen: Mengen und Musterpositionen"; + inhalt.append(" ", kalkKnopf, " ", vorlagenLink); await vorlageEditor(e); } @@ -1026,10 +1035,14 @@ async function zeige(): Promise { const zuPersonal = mitarbeiter || personalTeil || kolonne || sub; // Angebote (Stufe 3a) gehören zum Reiter Projekte const angebot = /^angebot-([0-9a-f-]{36})$/.exec(id)?.[1]; - const zuProjekte = treffer || angebot || id === "angebote"; + const mengenblatt = /^mengenblatt-([0-9a-f-]{36})$/.exec(id)?.[1]; + const zuProjekte = treffer || angebot || mengenblatt || id === "angebote"; + // Mengenvorlagen und Musterpositionen gehören zu den Daten + const vorlage = /^vorlage-([\w-]{1,80})$/.exec(id)?.[1]; + const zuDaten = vorlage || id === "vorlagen"; const projekt = treffer?.[1]; if (treffer?.[2]) projektTeil = treffer[2]; - const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!; + const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuDaten ? "daten" : id)) ?? REITER[0]!; nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0])); try { await (ablage ? ablageSeite(ablage) @@ -1039,6 +1052,9 @@ async function zeige(): Promise { : personalTeil && reiter[0] === "personal" ? personalSeite(personalTeil) : projekt && reiter[0] === "projekte" ? projektSeite(projekt) : angebot && reiter[0] === "projekte" ? angebotSeite(angebot) + : mengenblatt && reiter[0] === "projekte" ? mengenblattSeite(mengenblatt) + : vorlage && reiter[0] === "daten" ? vorlageSeite(vorlage) + : id === "vorlagen" && reiter[0] === "daten" ? vorlagenSeite() : id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]()); } catch (e) { inhalt.insertAdjacentHTML("beforeend", `

${esc((e as Error).message)}

`); diff --git a/src/web/mengenblatt.ts b/src/web/mengenblatt.ts new file mode 100644 index 0000000..b78fa00 --- /dev/null +++ b/src/web/mengenblatt.ts @@ -0,0 +1,451 @@ +// Mengenblatt und Vorlagen (neue Angebotsmaske, Henning 21.10.2026, Bilder 3 bis 6): dieselbe Darstellung für das +// Aufmaß in der Position, das große Mengenblatt und den Vorlagen-Editor. Eingaben sind gelb, Formeln blau. +// Felder tragen data-k = Präfix + Pfad im Blatt (z. B. „blatt::werte.2.formel“); die Seite speichert. + +import { benenneUm, FUNKTIONEN, zahlDeutsch } from "../domain/formel.js"; +import { type Auswertung, type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js"; +import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js"; +import { formatEuro, parseEuro } from "../domain/geld.js"; +import { KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js"; +import { type Zeile, api, bestaetigen, dialog, esc, hinweis, inhalt, optionenHtml } from "./ui.js"; + +export const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ",")); +export const zahlAus = (t: string) => { + const n = Number(t.trim().replace(/\./g, "").replace(",", ".")); + if (!Number.isFinite(n)) throw new Error(`„${t}“ ist keine Zahl`); + return n; +}; + +const ergebnisText = (v: unknown, einheit?: string | null) => (typeof v === "number" ? zahlDeutsch(v, einheit) : v === null || v === undefined ? "" : esc(v)); + +// ---------- Ändern ---------- + +/** Wert an einen Pfad wie „listen.0.zeilen.3.Breite“ schreiben; ein neues Kürzel wird in allen Formeln nachgezogen */ +export function setze(blatt: Blatt & { ansaetze?: Ansatz[] }, pfad: string, wert: string): string[] { + const teile = pfad.split("."); + const umbenannt: string[] = []; + const kz = /^werte\.(\d+)\.kz$/.exec(pfad); + if (kz) { + const alt = blatt.werte[Number(kz[1])]?.kz ?? ""; + if (alt && wert && alt !== wert) { benenneImBlatt(blatt, (f) => benenneUm(f, alt, wert)); umbenannt.push(alt, wert); } + } + const lkz = /^listen\.(\d+)\.kz$/.exec(pfad); + if (lkz) { + const alt = blatt.listen[Number(lkz[1])]?.kz ?? ""; + if (alt && wert && alt !== wert) benenneImBlatt(blatt, (f) => f.replace(new RegExp(`(? f.replaceAll(`${l.kz}.${alt}`, `${l.kz}.${wert}`)); + } + } + const typ = /^listen\.(\d+)\.spalten\.(\d+)\.typ$/.exec(pfad); + if (typ) { + const s = blatt.listen[Number(typ[1])]!.spalten[Number(typ[2])]!; + s.art = wert === "text" ? "text" : "zahl"; + s.formel = wert === "formel" ? s.formel ?? "" : null; + return umbenannt; + } + let o: any = blatt; + for (const t of teile.slice(0, -1)) o = o[t] ??= {}; + const letzter = teile.at(-1)!; + if (wert === "" && /^listen\.\d+\.zeilen\.\d+\./.test(pfad)) delete o[letzter]; + else o[letzter] = wert; + return umbenannt; +} + +function benenneImBlatt(b: Blatt & { ansaetze?: Ansatz[] }, f: (formel: string) => string): void { + for (const w of b.werte) w.formel = f(w.formel); + for (const l of b.listen) { + for (const s of l.spalten) if (s.formel) s.formel = f(s.formel); + for (const z of l.zeilen) for (const k of Object.keys(z)) z[k] = f(z[k]!); + } + for (const z of b.zeilen) z.formel = f(z.formel); + if (b.menge) b.menge = f(b.menge); + for (const a of b.ansaetze ?? []) if (a.bezug) a.bezug = f(a.bezug); +} + +const freiesKuerzel = (b: Blatt, basis: string) => { + const da = new Set(b.werte.map((w) => w.kz)); + for (let i = 1; ; i++) if (!da.has(`${basis}${i}`)) return `${basis}${i}`; +}; + +/** Zeilen anlegen und löschen (data-a beginnt mit „b-“); true, wenn sich etwas geändert hat */ +export function blattAktion(b: Blatt & { ansaetze?: Ansatz[] }, a: string, d: DOMStringMap): boolean { + const i = Number(d.i), l = Number(d.l); + switch (a) { + case "b-wert-neu": b.werte.push(d.was === "formel" ? { kz: freiesKuerzel(b, "F"), bez: "", einheit: "", formel: "" } : { kz: freiesKuerzel(b, "E"), bez: "", einheit: "m", formel: "0", eingabe: true }); return true; + case "b-wert-weg": b.werte.splice(i, 1); return true; + case "b-zeile-neu": b.zeilen.push({ text: "", formel: "" }); return true; + case "b-zeile-weg": b.zeilen.splice(i, 1); return true; + case "b-lzeile-neu": b.listen[l]!.zeilen.push({}); return true; + case "b-lzeile-weg": b.listen[l]!.zeilen.splice(i, 1); return true; + case "b-liste-neu": { + const da = new Set(b.listen.map((x) => x.kz)); + let n = 1; + while (da.has(`L${n}`)) n++; + b.listen.push({ kz: `L${n}`, name: "Liste", spalten: [{ kz: "Bezeichnung", bez: "Bezeichnung", art: "text" }, { kz: "Länge", bez: "Länge", einheit: "m" }, + { kz: "Anzahl", bez: "Anzahl", einheit: "St" }, { kz: "Summe", bez: "Summe", einheit: "m", formel: "Länge * Anzahl" }], zeilen: [{}] }); + return true; + } + case "b-liste-weg": b.listen.splice(l, 1); return true; + case "b-spalte-neu": { + const da = new Set(b.listen[l]!.spalten.map((x) => x.kz)); + let n = 1; + while (da.has(`S${n}`)) n++; + b.listen[l]!.spalten.push({ kz: `S${n}`, bez: "", einheit: "" }); + return true; + } + case "b-spalte-weg": b.listen[l]!.spalten.splice(i, 1); return true; + } + return false; +} + +// ---------- Darstellung ---------- + +export interface BlattOptionen { + /** Präfix der data-k-Schlüssel, z. B. „blatt::“ */ + k: string; + frei: boolean; + /** inline: in der Position (Listen nur lesen); gross: Mengenblatt; vorlage: Vorlagen-Editor mit Spalten */ + modus: "inline" | "gross" | "vorlage"; + einheit?: string | null; +} + +const feld = (k: string, wert: unknown, o: { klasse?: string; titel?: string; platz?: string; frei: boolean; liste?: string; fehler?: string | null }) => + ``; +const weg = (a: string, k: string, extra: string, frei: boolean, titel: string) => + frei ? `` : ""; +const fehlerZelle = (f: string | undefined) => (f ? `${esc(f)}` : ""); + +/** Kürzel des Blatts als Vorschlagsliste für Formeln */ +export function kuerzelListe(id: string, b: Blatt): string { + const kz = [...b.werte.map((w) => [w.kz, w.bez ?? ""]), ...b.listen.flatMap((l) => l.spalten.map((s) => [`${l.kz}.${s.kz}`, `${l.name ?? l.kz}: ${s.bez ?? s.kz}`]))]; + return `${kz.filter(([k]) => k).map(([k, t]) => ``).join("")}`; +} + +function werteTabelle(b: Blatt, a: Auswertung, o: BlattOptionen, nur?: "eingabe" | "formel"): string { + const zeilen = b.werte.map((w, i) => [w, i] as const).filter(([w]) => !nur || (nur === "eingabe") === !!w.eingabe); + const vorlage = o.modus === "vorlage"; + const kopf = vorlage && nur === "eingabe" ? "KürzelBezeichnungEinheitBeispiel" + : `KürzelBezeichnung${nur === "formel" ? "Formel" : "Wert / Formel"}${vorlage ? "Probe" : "Ergebnis"}${vorlage ? "" : "Einheit"}`; + const rumpf = zeilen.map(([w, i]) => { + const f = a.fehler[`w:${i}`]; + const wertFeld = feld(`${o.k}werte.${i}.formel`, w.formel, { klasse: w.eingabe ? "am-eingabe zahl" : "am-formel", titel: `${w.kz} Wert`, frei: o.frei, fehler: f, liste: "am-kuerzel" }); + const kzFeld = feld(`${o.k}werte.${i}.kz`, w.kz, { klasse: "am-kz", titel: "Kürzel", frei: o.frei }); + const bezFeld = feld(`${o.k}werte.${i}.bez`, w.bez, { titel: "Bezeichnung", frei: o.frei, platz: "Bezeichnung" }); + const einheitFeld = feld(`${o.k}werte.${i}.einheit`, w.einheit, { klasse: "w-kurz", titel: "Einheit", frei: o.frei, liste: "einheiten" }); + const loeschen = weg("b-wert-weg", o.k, `data-i="${i}"`, o.frei, "Zeile löschen"); + if (vorlage && nur === "eingabe") return `${kzFeld}${bezFeld}${einheitFeld}${wertFeld}${fehlerZelle(f)}${loeschen}`; + return `${kzFeld}${bezFeld}${wertFeld}${fehlerZelle(f)}${f ? "–" : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}${vorlage ? "" : `${einheitFeld}`}${loeschen}`; + }).join(""); + return `
${kopf}${rumpf || ``}
${nur === "formel" ? "Noch keine Formel." : "Noch keine Eingabe."}
`; +} + +function listeHtml(b: Blatt, a: Auswertung, o: BlattOptionen, li: number): string { + const l = b.listen[li]!; + const lesen = o.modus === "inline"; + const kopf = l.spalten.map((s) => `${esc(s.bez || s.kz)}${s.einheit ? ` [${esc(s.einheit)}]` : ""}`).join(""); + const zeilen = l.zeilen.map((z, zi) => `${l.spalten.map((s) => { + const sch = `l:${li}:${zi}:${s.kz}`, f = a.fehler[sch]; + if (s.formel || lesen) return `${f ? `Fehler` : s.formel ? `${ergebnisText(a.ergebnis[sch], s.einheit)}` : ergebnisText(a.ergebnis[sch], s.einheit)}`; + return `${feld(`${o.k}listen.${li}.zeilen.${zi}.${s.kz}`, z[s.kz] ?? "", { klasse: s.art === "text" ? "am-eingabe" : "am-eingabe zahl", titel: `${s.bez || s.kz}, Zeile ${zi + 1}`, frei: o.frei, fehler: f, liste: s.art === "text" ? undefined : "am-kuerzel" })}`; + }).join("")}${lesen ? "" : `${weg("b-lzeile-weg", o.k, `data-l="${li}" data-i="${zi}"`, o.frei, "Zeile löschen")}`}`).join(""); + const summen = l.spalten.map((s) => { + if (s.art === "text" || !s.formel) return ""; + const v = l.zeilen.reduce((t, _, zi) => t + (typeof a.ergebnis[`l:${li}:${zi}:${s.kz}`] === "number" ? (a.ergebnis[`l:${li}:${zi}:${s.kz}`] as number) : 0), 0); + return `${zahlDeutsch(v, s.einheit)}`; + }); + summen[0] = "Summe"; + const spalten = o.modus === "vorlage" ? `
Spalten der Liste festlegen +
+ ${l.spalten.map((s, si) => ` + + + + + `).join("")}
KürzelBezeichnungEinheitArtFormel (berechnet)
${feld(`${o.k}listen.${li}.spalten.${si}.kz`, s.kz, { klasse: "am-kz", titel: "Kürzel der Spalte", frei: o.frei })}${feld(`${o.k}listen.${li}.spalten.${si}.bez`, s.bez, { titel: "Bezeichnung", frei: o.frei })}${feld(`${o.k}listen.${li}.spalten.${si}.einheit`, s.einheit, { klasse: "w-kurz", titel: "Einheit", frei: o.frei, liste: "einheiten" })}${s.formel !== null && s.formel !== undefined ? feld(`${o.k}listen.${li}.spalten.${si}.formel`, s.formel, { klasse: "am-formel", titel: "Formel", frei: o.frei, platz: "z. B. Länge * Anzahl" }) : ""}${weg("b-spalte-weg", o.k, `data-l="${li}" data-i="${si}"`, o.frei, "Spalte löschen")}
+ ${o.frei ? `` : ""} +

Berechnete Spalten rechnen mit den Kürzeln der Spalten dieser Zeile. Summen bildest du mit summe(${esc(l.kz)}.Spalte) oder summewenn(${esc(l.kz)}.Spalte; ${esc(l.kz)}.Kennung; "W").

` : ""; + return `

${o.modus === "vorlage" ? `${feld(`${o.k}listen.${li}.name`, l.name, { titel: "Name der Liste", frei: o.frei, klasse: "am-listenname" })} Kürzel ${feld(`${o.k}listen.${li}.kz`, l.kz, { klasse: "am-kz", titel: "Kürzel der Liste", frei: o.frei })}${weg("b-liste-weg", o.k, `data-l="${li}"`, o.frei, "Liste löschen")}` : `${esc(l.name || l.kz)} (${esc(l.kz)})`}

+ ${spalten} +
${kopf}${lesen ? "" : ""}${zeilen}${summen.join("")}${lesen ? "" : ""}
+ ${!lesen && o.frei ? `
` : ""}
`; +} + +/** freie Aufmaßzeilen wie in Plancraft: Beschreibung, Formel, Ergebnis (Bild 5) */ +export function aufmassZeilenHtml(b: Blatt, a: Auswertung, o: BlattOptionen): string { + const zeilen = b.zeilen.map((z, i) => { + const f = a.fehler[`z:${i}`]; + return `${feld(`${o.k}zeilen.${i}.text`, z.text, { titel: `Beschreibung Zeile ${i + 1}`, frei: o.frei, platz: i === 0 ? "z. B. Wand links" : "" })} + ${feld(`${o.k}zeilen.${i}.formel`, z.formel, { klasse: "am-formel", titel: `Formel Zeile ${i + 1}`, frei: o.frei, fehler: f, platz: i === 0 ? "z. B. 100+(5,1*4)/2" : "", liste: "am-kuerzel" })}${fehlerZelle(f)} + ${f ? "–" : ergebnisText(a.ergebnis[`z:${i}`], o.einheit)}${weg("b-zeile-weg", o.k, `data-i="${i}"`, o.frei, "Zeile löschen")}`; + }).join(""); + const summeMenge = !b.menge?.trim(); + return `
${zeilen} +
BeschreibungFormelErgebnis
${summeMenge ? "Summe → Menge der Position" : "Summe der Aufmaßzeilen"}${zahlDeutsch(a.summeZeilen, o.einheit)}
`; +} + +function mengeWahl(b: Blatt, a: Auswertung, o: BlattOptionen): string { + return `
Menge der Position${feld(`${o.k}menge`, b.menge, { klasse: "am-formel am-menge", titel: "Menge der Position (Kürzel oder Formel)", frei: o.frei, platz: "Summe der Aufmaßzeilen", liste: "am-kuerzel", fehler: a.fehler.menge })} + = ${a.menge === null ? "–" : `${zahlDeutsch(a.menge, o.einheit)} ${esc(o.einheit ?? "")}`}${fehlerZelle(a.fehler.menge)}
`; +} + +const legende = `
EingabeFormel mit Kürzeln, z. B. (B/2+UET)/cos(DN) + Erlaubt: + − * / ^ ( ), ${FUNKTIONEN.slice(0, 12).join(", ")} …; Argumente mit Semikolon trennen, Winkel in Grad.
`; + +/** Inhalt des Mengenblatts für die drei Ansichten */ +export function blattHtml(b: Blatt, a: Auswertung, o: BlattOptionen): string { + const mitVorlage = b.werte.length > 0 || b.listen.length > 0; + if (o.modus === "inline") { + const formeln = b.werte.map((w, i) => [w, i] as const).filter(([w, i]) => !w.eingabe && typeof a.ergebnis[`w:${i}`] === "number").slice(0, 8); + const fehler = Object.keys(a.fehler).filter((k) => k !== "menge" && !k.startsWith("z:")).length; + return `${mitVorlage ? `
${b.vorlage ? `Vorlage ${esc(b.vorlage.name)}` : "Mengenblatt"} + ${formeln.map(([w, i]) => `${esc(w.kz)} ${zahlDeutsch(a.ergebnis[`w:${i}`] as number, w.einheit)} ${esc(w.einheit ?? "")}`).join("")} + ${fehler ? `${fehler} Fehler im Mengenblatt` : ""}
+ ${b.werte.some((w) => w.eingabe) ? `
${b.werte.map((w, i) => [w, i] as const).filter(([w]) => w.eingabe).map(([w, i]) => ``).join("")}
` : ""} + ${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}` : ""} + ${b.zeilen.length || !mitVorlage ? aufmassZeilenHtml(b, a, o) : ""} + ${mitVorlage ? mengeWahl(b, a, o) : ""}`; + } + if (o.modus === "gross") { + const formeln = b.werte.map((w, i) => [w, i] as const).filter(([w]) => !w.eingabe); + return `

Grunddaten und Formeln

${werteTabelle(b, a, o)} + ${o.frei ? `
` : ""}
+

Ergebnisse

${formeln.map(([w, i]) => `${esc(w.kz)}${esc(w.bez ?? "")}${a.fehler[`w:${i}`] ? 'Fehler' : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}${esc(w.einheit ?? "")}`).join("") || 'Noch keine Formel.'}
+ ${mengeWahl(b, a, o)}
+ ${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")} +

Aufmaßzeilen

${aufmassZeilenHtml(b, a, o)} + ${o.frei ? `
` : ""}${legende}`; + } + return `

1 Eingaben fragt das Programm beim Einfügen ab

${werteTabelle(b, a, o, "eingabe")} + ${o.frei ? `
` : ""}
+

2 Formeln rechnen mit den Kürzeln

${werteTabelle(b, a, o, "formel")} + ${o.frei ? `
` : ""}
+ ${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")} + ${legende} +
3 ${mengeWahl(b, a, o)}
`; +} + +// ---------- Vorlagen auswählen und einfügen ---------- + +let vorlagenSpeicher: Mengenvorlage[] | null = null; +export async function alleVorlagen(neu = false): Promise { + if (!vorlagenSpeicher || neu) vorlagenSpeicher = await api("mengenvorlagen-alle"); + return vorlagenSpeicher; +} + +/** Liste in der Seitenleiste: Musterpositionen (art muster) oder Mengenvorlagen, nach Gruppen, mit Suche */ +export function vorlagenListeHtml(liste: Mengenvorlage[], o: { art: "muster" | "mengen" | "alle"; suche: string; ziel?: string | null; frei: boolean }): string { + const s = o.suche.trim().toLowerCase(); + // eine kopierte und geänderte Vorlage mit gleichem Namen ersetzt die mitgelieferte im Katalog + const eigeneNamen = new Set(liste.filter((v) => !v.fest).map((v) => `${v.gruppe}|${v.name}`)); + const passend = liste.filter((v) => !(v.fest && o.art !== "alle" && eigeneNamen.has(`${v.gruppe}|${v.name}`))) + .filter((v) => (o.art === "alle" || v.art === o.art || (o.art === "mengen" && v.art === "muster" && (v.inhalt.werte.length || v.inhalt.listen.length))) + && (!s || `${v.name} ${v.gruppe} ${v.beschreibung ?? ""} ${v.kurztext ?? ""}`.toLowerCase().includes(s))); + const gruppen = [...new Set(passend.map((v) => v.gruppe))]; + if (!passend.length) return `

${s ? "Nichts gefunden." : "Noch keine Vorlage."}

`; + return gruppen.map((g) => `
${esc(g)}
${passend.filter((v) => v.gruppe === g).map((v) => `
+ ${esc(v.name)}${v.beschreibung ? `${esc(v.beschreibung)}` : ""} + ${o.frei ? `` : ""} + ✎
`).join("")}`).join(""); +} + +/** Eingaben einer Vorlage beim Einfügen abfragen (Bild 6: „fragt das Programm beim Einfügen ab“) */ +export async function eingabenAbfragen(v: Mengenvorlage): Promise | null> { + const eingaben = v.inhalt.werte.filter((w) => w.eingabe); + if (!eingaben.length) return {}; + const r = await dialog(`${v.name} einfügen`, eingaben.map((w, i) => ({ + name: `e${i}`, titel: `${w.kz}: ${w.bez || w.kz}${w.einheit ? ` [${w.einheit}]` : ""}`, art: "text" as const, + ...(i === eingaben.length - 1 ? { hilfe: "Vorbelegt mit den Beispielwerten der Vorlage. Alles lässt sich später im Mengenblatt ändern." } : {}), + })), Object.fromEntries(eingaben.map((w, i) => [`e${i}`, w.formel])), false); + if (r?.aktion !== "speichern") return null; + return Object.fromEntries(eingaben.map((w, i) => [w.kz, String(r.daten[`e${i}`] ?? w.formel)])); +} + +// ---------- Vorlagen-Editor (Bild 6) ---------- + +const ANSATZ_ARTEN = KOSTENARTEN.map((x): [string, string] => [x, KOSTENART_NAME[x]]); + +function ansaetzeHtml(v: Mengenvorlage, a: Auswertung, frei: boolean): string { + const rumpf = v.inhalt.ansaetze.map((z, i) => { + const lohn = z.kostenart === "lohn"; + let probe = "–", fehler: string | null = null; + try { + const bezug = z.bezug?.trim() ? a.rechne(z.bezug) : a.menge ?? 0; + probe = `${zahlDeutsch(bezug * Number(z.menge) * Number(z.personen ?? 1) * (lohn ? 1 : Number(z.faktor ?? 1)), lohn ? "h" : z.einheit)} ${lohn ? "h" : esc(z.einheit ?? "")}`; + } catch (e) { fehler = (e as Error).message; } + const k = (f: string) => `vb:ansaetze.${i}.${f}`; + return ` + ${lohn ? `` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })} + ${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })} + ${feld(k("menge"), zahlText(z.menge), { klasse: "am-eingabe zahl w-menge", titel: lohn ? "Std je Einheit des Bezugs" : "Menge je Einheit des Bezugs", frei })} + ${lohn ? feld(k("personen"), zahlText(z.personen ?? 1), { klasse: "am-eingabe zahl w-kurz", titel: "Personen", frei }) : feld(k("faktor"), zahlText(z.faktor ?? 1), { klasse: "zahl w-kurz", titel: "Faktor", frei })} + ${lohn ? 'h' : feld(k("einheit"), z.einheit, { klasse: "w-kurz", titel: "Einheit", frei, liste: "einheiten" })} + ${feld(k("ek"), z.ek == null ? "" : formatEuro(z.ek, false), { klasse: "zahl w-euro", titel: "EK", frei, platz: lohn ? "Satz" : "0,00" })} + ${probe} + + ${frei ? `` : ""}`; + }).join(""); + return `
+ ${rumpf || ''}
ArtTätigkeit / MaterialBezugAnsatzPers. / FaktorEinheitEKProbe✓
Noch keine Zeitansätze. Ohne sie bleibt es eine reine Mengenvorlage.
+ ${frei ? `
${ANSATZ_ARTEN.map(([x, t]) => ``).join("")}
` : ""} +

Menge = Bezug × Ansatz × Personen; ohne Bezug je Einheit der Position. Beim Einfügen wird jede Zeile eine Kostenzeile der Position. Ein leerer EK beim Lohn nimmt den Stundensatz des Angebots.

`; +} + +export async function vorlageSeite(id: string): Promise { + const liste = await alleVorlagen(true); + let v = structuredClone(liste.find((x) => String(x.id) === id)); + if (!v) { inhalt.innerHTML = '

Diese Vorlage gibt es nicht (mehr).

Zu den Vorlagen

'; return; } + v.inhalt = { ...alsBlatt(v.inhalt), ansaetze: v.inhalt.ansaetze ?? [] }; + let meldung = ""; + const wurzel = document.createElement("div"); + inhalt.replaceChildren(wurzel); + const frei = !v.fest; + const zeichne = () => { + const fokus = document.activeElement as HTMLInputElement | null; + const k = fokus?.dataset?.k; + const a = werteBlatt(v!.inhalt, umgebungVon({})); + const gruppen = [...new Set(liste.map((x) => x.gruppe))]; + wurzel.innerHTML = `${kuerzelListe("am-kuerzel", v!.inhalt)}${gruppen.map((g) => ` + ${["m", "m²", "m³", "St", "kg", "t", "h", "psch"].map((x) => ` +
←

${v!.fest ? "Mitgelieferte Vorlage" : "Eigene Vorlage"} ${esc(v!.name)}

+ ${frei ? '' : ""}
+ ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""} + ${v!.fest ? '

Diese Vorlage ist mitgeliefert und lässt sich nicht ändern. Mit „Kopieren und ändern“ wird sie deine eigene.

' : ""} +
+
${blattHtml(v!.inhalt, a, { k: "vb:", frei, modus: "vorlage", einheit: v!.einheit })}
+

4 Zeitansätze und Material werden beim Einfügen zu Kostenzeilen der Position

${ansaetzeHtml(v!, a, frei)}
+
+
`; + if (k) wurzel.querySelector(`[data-k="${CSS.escape(k)}"]`)?.focus(); + }; + const speichern = async () => { + if (!frei) return; + const { id: _i, fest: _f, ...rest } = v as Mengenvorlage & Zeile; + const daten: Zeile = { art: rest.art, gruppe: rest.gruppe, name: rest.name, beschreibung: rest.beschreibung || null, kurztext: rest.kurztext || null, + langtext: rest.langtext || null, einheit: rest.einheit || null, inhalt: rest.inhalt }; + await api(`mengenvorlagen/${id}`, "PATCH", daten); + vorlagenSpeicher = null; + }; + const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); }; + zeichne(); + wurzel.addEventListener("change", async (ev) => { + const el = ev.target as HTMLInputElement; + const k = el.dataset?.k; + if (!k) return; + meldung = ""; + try { + if (k.startsWith("v:")) { + const f = k.slice(2); + if ((f === "name" || f === "gruppe") && !el.value.trim()) throw new Error("Name und Gruppe dürfen nicht leer sein."); + (v as Zeile)[f] = el.value.trim(); + } else if (k.startsWith("vb:ansaetze.")) { + const [, i, f] = k.slice(3).split(".") as [string, string, string]; + const z = v!.inhalt.ansaetze[Number(i)] as Ansatz & Record; + if (el.dataset.typ === "bool") z[f] = el.checked; + else if (["menge", "personen", "faktor"].includes(f)) z[f] = el.value.trim() ? zahlAus(el.value) : f === "menge" ? 0 : 1; + else if (f === "ek") z.ek = el.value.trim() ? parseEuro(el.value) : null; + else z[f] = el.value.trim() || null; + if (f === "kostenart") { z.lohnart = z.kostenart === "lohn" ? "geselle" : null; z.einheit = z.kostenart === "lohn" ? "h" : null; } + } else if (k.startsWith("vb:")) setze(v!.inhalt, k.slice(3), el.value); + await speichern(); + zeichne(); + } catch (e) { fehler(e); } + }); + wurzel.addEventListener("click", async (ev) => { + const b = (ev.target as HTMLElement).closest("[data-a]"); + if (!b) return; + const a = b.dataset.a!; + try { + if (a.startsWith("b-")) { if (blattAktion(v!.inhalt, a, b.dataset)) { await speichern(); zeichne(); } return; } + if (a === "v-ansatz-neu") { + const art = b.dataset.art as Ansatz["kostenart"]; + v!.inhalt.ansaetze.push({ kostenart: art, lohnart: art === "lohn" ? "geselle" : null, beschreibung: "", bezug: v!.inhalt.menge || "", menge: art === "lohn" ? 0.1 : 1, personen: 1, einheit: art === "lohn" ? "h" : v!.einheit ?? null }); + await speichern(); return zeichne(); + } + if (a === "v-ansatz-weg") { v!.inhalt.ansaetze.splice(Number(b.dataset.i), 1); await speichern(); return zeichne(); } + if (a === "v-kopie") { + const { id: _i, fest: _f, reihenfolge: _r, ...rest } = v as Mengenvorlage & Zeile; + const neu = await api("mengenvorlagen", "POST", { ...rest, name: v!.fest ? rest.name : `${rest.name} (Kopie)`, beschreibung: rest.beschreibung || null, + kurztext: rest.kurztext || null, langtext: rest.langtext || null, einheit: rest.einheit || null }); + vorlagenSpeicher = null; + hinweis.gut = true; + hinweis.text = "Kopie angelegt. Sie gehört jetzt dir und lässt sich ändern."; + location.hash = `vorlage-${neu.id}`; + return; + } + if (a === "v-weg") { + if (!(await bestaetigen(`Vorlage „${v!.name}“ löschen? Angebote, in die sie schon eingefügt ist, behalten ihr Mengenblatt.`))) return; + await api(`mengenvorlagen/${id}`, "DELETE"); + vorlagenSpeicher = null; + location.hash = "vorlagen"; + } + } catch (e) { fehler(e); } + }); + if (hinweis.text) { meldung = hinweis.text; hinweis.text = ""; hinweis.gut = false; zeichne(); } +} + +/** Daten → Vorlagen: alle Mengenvorlagen und Musterpositionen */ +export async function vorlagenSeite(): Promise { + const liste = await alleVorlagen(true); + let suche = ""; + const wurzel = document.createElement("div"); + inhalt.replaceChildren(wurzel); + const zeichne = () => { + const s = suche.trim().toLowerCase(); + const passend = liste.filter((v) => !s || `${v.name} ${v.gruppe} ${v.beschreibung ?? ""}`.toLowerCase().includes(s)); + const gruppen = [...new Set(passend.map((v) => v.gruppe))]; + wurzel.innerHTML = `
←

Vorlagen

+

Mengenvorlagen rechnen die Menge einer Position aus Eingaben und Formeln. Musterpositionen bringen dazu Kurztext, Langtext und Zeitansätze mit. Beides fügst du im Angebot rechts unter „Bausteine“ und „Mengenvorlagen“ ein.

+ + ${gruppen.map((g) => `

${esc(g)}

`).join("") || '

Nichts gefunden.

'}`; + }; + zeichne(); + wurzel.addEventListener("input", (ev) => { + const el = ev.target as HTMLInputElement; + if (!el.classList.contains("am-suche-seite")) return; + suche = el.value; + const pos = el.selectionStart; + zeichne(); + const neu = wurzel.querySelector(".am-suche-seite")!; + neu.focus(); + neu.setSelectionRange(pos, pos); + }); + wurzel.addEventListener("click", async (ev) => { + if ((ev.target as HTMLElement).closest("[data-a]")?.getAttribute("data-a") !== "neu") return; + const r = await dialog("Neue Vorlage", [ + { name: "name", titel: "Name", pflicht: true }, { name: "gruppe", titel: "Gruppe", pflicht: true, hilfe: "z. B. Dach, Wand, Klempner / Blech" }, + { name: "art", titel: "Art", art: "auswahl", optionen: [["mengen", "Mengenvorlage"], ["muster", "Musterposition mit Texten und Kalkulation"]] }, + { name: "einheit", titel: "Einheit der Position", hilfe: "m, m², m³, St, psch" }, + ], { art: "mengen", einheit: "m" }, false); + if (r?.aktion !== "speichern") return; + const neu = await api("mengenvorlagen", "POST", { name: r.daten.name, gruppe: r.daten.gruppe, art: r.daten.art ?? "mengen", einheit: r.daten.einheit || null, + inhalt: { werte: [{ kz: "L", bez: "Länge", einheit: "m", formel: "1", eingabe: true }], listen: [], zeilen: [], menge: "L", ansaetze: [] } }); + vorlagenSpeicher = null; + location.hash = `vorlage-${neu.id}`; + }); +} diff --git a/src/web/styles.css b/src/web/styles.css index ba12e2f..61bfd2b 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -9,6 +9,10 @@ --warn: #b42318; --warnung-bg: #fdecea; --warnung-text: #7a1c14; --warnung-linie: #f5c2bd; --g-sammel: #2e6fb0; --g-vorgang: #9cc2e6; --g-vorgang-rand: #6f9fcf; --g-kappe: #8a8f98; --g-nr: #f1f3f6; --g-wahl: #a9d5a0; --g-wahl-text: #1f4d1a; --gut-bg: #daf3e3; --gut-text: #19703f; + /* Angebotsmaske: Eingaben gelb, Formeln blau, Kostenarten farbig (Bilder vom 21.10.2026) */ + --eingabe-bg: #fff6c4; --eingabe-linie: #e8d36a; --eingabe-text: #4d4000; --formel-text: #1d4f8a; --titel-bg: #f6f8fb; --markiert: #fff9db; + --art-lohn-bg: #e4eefa; --art-lohn: #1d5fa8; --art-mat-bg: #f4e9dd; --art-mat: #7a4a1c; --art-ger-bg: #dcf1f4; --art-ger: #0f6674; + --art-sub-bg: #ece6f8; --art-sub: #5b3fa0; --art-son-bg: #eceff3; --art-son: #4a5563; font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px; } /* dunkel nach Systemeinstellung, außer jemand wählt ausdrücklich hell (data-theme) */ @@ -20,6 +24,9 @@ --warnung-bg: #3a1714; --warnung-text: #f9c9c3; --warnung-linie: #6b2620; --g-sammel: #5f9bd8; --g-vorgang: #3f6f9f; --g-vorgang-rand: #79a6d6; --g-kappe: #8792a2; --g-nr: #151d29; --g-wahl: #2f5a2a; --g-wahl-text: #cdeec6; --gut-bg: #173a26; --gut-text: #8fe0b0; color-scheme: dark; + --eingabe-bg: #3a3310; --eingabe-linie: #7a6a1f; --eingabe-text: #f5e7a1; --formel-text: #8fbdf0; --titel-bg: #161f2c; --markiert: #2e2a14; + --art-lohn-bg: #1d3352; --art-lohn: #8fbdf0; --art-mat-bg: #3a2a1a; --art-mat: #e8c39b; --art-ger-bg: #133b40; --art-ger: #8fdbe4; + --art-sub-bg: #2e2548; --art-sub: #c8b6f2; --art-son-bg: #262f3b; --art-son: #b5c0cd; } } :root[data-theme="dark"] { @@ -29,6 +36,9 @@ --warnung-bg: #3a1714; --warnung-text: #f9c9c3; --warnung-linie: #6b2620; --g-sammel: #5f9bd8; --g-vorgang: #3f6f9f; --g-vorgang-rand: #79a6d6; --g-kappe: #8792a2; --g-nr: #151d29; --g-wahl: #2f5a2a; --g-wahl-text: #cdeec6; --gut-bg: #173a26; --gut-text: #8fe0b0; color-scheme: dark; + --eingabe-bg: #3a3310; --eingabe-linie: #7a6a1f; --eingabe-text: #f5e7a1; --formel-text: #8fbdf0; --titel-bg: #161f2c; --markiert: #2e2a14; + --art-lohn-bg: #1d3352; --art-lohn: #8fbdf0; --art-mat-bg: #3a2a1a; --art-mat: #e8c39b; --art-ger-bg: #133b40; --art-ger: #8fdbe4; + --art-sub-bg: #2e2548; --art-sub: #c8b6f2; --art-son-bg: #262f3b; --art-son: #b5c0cd; } * { box-sizing: border-box; } body { margin: 0; background: var(--bg); color: var(--text); display: flex; min-height: 100vh; } @@ -751,9 +761,15 @@ button.weg:hover { background: var(--warnung-bg); color: var(--warn); } .position-details > .hinweis { margin: 0; font-size: 13px; } table.kosten-tabelle { border-radius: 8px; width: auto; } table.kosten-tabelle th, table.kosten-tabelle td { padding: 4px 6px; font-size: 13px; } -table.kosten-tabelle td.kz-text { display: flex; gap: 6px; } -table.kosten-tabelle td.kz-text select { width: 6.8em; flex: none; } -table.kosten-tabelle td.kz-text input { width: 12em; } +table.kosten-tabelle th, table.kosten-tabelle td { padding-left: 3px; padding-right: 3px; } +table.kosten-tabelle input.w-bez { width: 8.8em; } +table.kosten-tabelle input.w-bezug { width: 6.6em; } +table.kosten-tabelle input.w-ansatz { width: 4.2em; } +table.kosten-tabelle input.w-pers { width: 2.8em; } +table.kosten-tabelle input.w-einheit { width: 5.4em; } +table.kosten-tabelle input.w-ek { width: 4.9em; } +table.kosten-tabelle input.w-faktor { width: 3.1em; } +table.kosten-tabelle td:nth-child(7) select { width: 6.3em; } .angebot-raster input.w-menge { width: 5.5em; } .angebot-raster input.w-euro { width: 6.5em; } .angebot-raster input.w-kurz { width: 4.2em; } @@ -762,7 +778,7 @@ table.kosten-tabelle tr.kz-lohn td:first-child { box-shadow: inset 3px 0 0 var(- table.kosten-tabelle tr.kz-material td:first-child { box-shadow: inset 3px 0 0 var(--holz); } table.kosten-tabelle tr.kz-geraet td:first-child { box-shadow: inset 3px 0 0 var(--ein); } table.kosten-tabelle tr.kz-sonstiges td:first-child { box-shadow: inset 3px 0 0 var(--leise); } -table.kosten-tabelle td:first-child select { width: 7.2em; } +table.kosten-tabelle td:first-child select { width: 5.9em; } .summen dl { display: grid; grid-template-columns: 1fr auto; gap: 6px 12px; margin: 0; } .summen dt { color: var(--leise); } .summen dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; } @@ -776,7 +792,9 @@ table.kalk-tabelle tfoot td { font-weight: 600; border-bottom: 0; } .saetze-mehr { margin-top: 10px; font-size: 14px; } .saetze-mehr summary { cursor: pointer; color: var(--akzent); } .saetze-mehr .hinweis { font-size: 13px; margin: 6px 0 0; } -ul.pruefung { margin: 0; padding-left: 18px; font-size: 14px; display: flex; flex-direction: column; gap: 4px; } +ul.pruefung { margin: 0; padding-left: 14px; list-style: none; font-size: 14px; display: flex; flex-direction: column; gap: 4px; } +ul.pruefung li { position: relative; } +ul.pruefung li::before { content: "•"; position: absolute; left: -12px; top: 0; } ul.pruefung li.fehler { color: var(--warn); } ul.pruefung li.hinweis { color: var(--leise); } ul.pruefung .verweis { color: inherit; text-align: left; } @@ -790,3 +808,186 @@ ul.staende { margin: 0; padding-left: 18px; font-size: 14px; } table.lv col.c-std { width: 0; } .kopf-knoepfe { width: 100%; } } + +/* Neue Angebotsmaske (Henning, 21.10.2026): Liste wie Plancraft, markierte Position mit Schaltern und Abschnitten, + Mengenblatt mit gelben Eingaben und blauen Formeln */ +a.haupt { display: inline-block; background: var(--akzent); color: var(--akzent-text); border-radius: 8px; padding: 10px 18px; font-weight: 600; text-decoration: none; } +a.haupt:hover { background: var(--akzent-hover); } +.am-kopf h1 { flex: 1; } +.am-kopf .nummer { color: var(--leise); font-weight: 400; } +.am-kopfdaten { display: flex; flex-direction: column; gap: 10px; margin-bottom: 14px; } +.am-kopfzeile { display: flex; gap: 10px 22px; align-items: center; flex-wrap: wrap; font-size: 14px; } +.am-kopfzeile > span > b { display: block; font-size: 12px; color: var(--leise); font-weight: 600; text-transform: uppercase; letter-spacing: .04em; } +.am-kopfzeile .am-betreff { min-width: 0; max-width: 28em; overflow: hidden; text-overflow: ellipsis; } +.am-rechts { margin-left: auto; } +.am-kopfdaten p.hinweis { margin: 0; font-size: 13px; } +.am-kopf-felder { border-top: 1px solid var(--linie); padding-top: 12px; } +.am-kopfdaten input, .am-kopfdaten select, .am-kopfdaten textarea { width: 100%; min-width: 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; } +.am-raster { grid-template-columns: minmax(0, 1fr) 310px; } +.am-lv { padding: 0; overflow: hidden; } +.am-zeile { display: grid; grid-template-columns: 74px 96px 72px minmax(0, 1fr) 108px 112px 34px; gap: 8px; align-items: start; padding: 8px 12px; border-bottom: 1px solid var(--linie); cursor: default; } +.am-zeile.kopfzeile { background: var(--bg); font-size: 13px; color: var(--leise); font-weight: 600; padding-block: 10px; } +.am-zeile .z { text-align: right; font-variant-numeric: tabular-nums; } +.am-zeile .pos { font-variant-numeric: tabular-nums; color: var(--leise); font-size: 13px; padding-top: 8px; overflow-wrap: anywhere; } +.am-zeile .gb { padding-top: 8px; font-weight: 600; } +.am-zeile.titel { background: var(--titel-bg); grid-template-columns: 74px minmax(0, 1fr) 112px 34px; font-weight: 700; } +.am-zeile.titel .pos { color: var(--text); font-weight: 700; } +.am-zeile.titel input { font-weight: 700; font-size: 15px; } +.am-zeile.am-textzeile { grid-template-columns: 74px minmax(0, 1fr) 34px; } +.am-zeile.am-textzeile textarea { font-style: italic; resize: vertical; } +.am-zeile.aktiv { box-shadow: inset 3px 0 0 var(--akzent); background: color-mix(in srgb, var(--akzent-hell) 35%, var(--fl)); } +.am-zeile.markiert { background: var(--markiert); } +.am-zeile.mit-fehler .pos { color: var(--warn); font-weight: 600; } +.am-zeile.zaehlt-nicht .gb, .am-zeile.zaehlt-nicht .pos { color: var(--leise); } +.am-zeile.am-ziel { box-shadow: inset 0 -3px 0 var(--akzent); } +.am-lv.am-ziel { outline: 2px dashed var(--akzent); } +.am-zeile input.aus { background: var(--bg); color: var(--text); border-color: var(--linie); cursor: default; } +.am-menge, .am-ep { display: flex; flex-direction: column; align-items: stretch; gap: 3px; } +.marke-q { align-self: flex-start; font-size: 11px; font-weight: 600; padding: 1px 7px; border-radius: 5px; background: var(--leiste); color: #fff; } +.am-ep .marke-q { align-self: flex-end; } +.marke-q.kalk { background: var(--akzent); color: var(--akzent-text); } +.marke-q.fehler { background: var(--warn); } +.m-unter { font-size: 12.5px; color: var(--leise); margin-top: 3px; } +.m-unter.am-rechts { text-align: right; margin: 0; } +.m-sym { color: var(--leise); font-size: 12px; margin-top: 3px; display: inline-block; } +.m-chips { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 8px; align-items: center; } +.m-chips .chip { display: inline-flex; align-items: center; gap: 6px; font: inherit; font-size: 13px; padding: 4px 10px; border-radius: 999px; border: 1px solid var(--linie); background: var(--fl); color: var(--text); cursor: pointer; } +.m-chips .chip:disabled { cursor: default; opacity: .6; } +.m-chips .chip.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; } +.m-chips .chip .p { width: 26px; height: 15px; border-radius: 9px; background: var(--linie); position: relative; flex: none; } +.m-chips .chip .p::after { content: ""; position: absolute; top: 2px; left: 2px; width: 11px; height: 11px; border-radius: 50%; background: var(--fl); transition: left .12s; } +.m-chips .chip.an .p { background: var(--akzent); } +.m-chips .chip.an .p::after { left: 13px; } +.m-chips .am-art select { width: auto; padding: 4px 8px; font-size: 13px; border-radius: 999px; } +.punkte-zelle { padding-top: 4px; } +details.am-menue { position: relative; } +details.am-menue > summary { list-style: none; cursor: pointer; color: var(--leise); text-align: center; padding: 4px 8px; border-radius: 6px; font-weight: 700; } +details.am-menue > summary::-webkit-details-marker { display: none; } +details.am-menue > summary:hover, details.am-menue[open] > summary { background: var(--bg); color: var(--text); } +.kopf-knoepfe details.am-menue > summary { border: 1px solid var(--linie); background: var(--fl); padding: 8px 12px; border-radius: 8px; } +.am-menue-liste { position: absolute; right: 0; top: calc(100% + 4px); z-index: 20; min-width: 210px; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; box-shadow: 0 12px 32px rgb(16 32 64 / .18); padding: 6px; display: flex; flex-direction: column; } +.am-menue-liste button { background: none; border: 0; text-align: left; font: inherit; font-size: 14px; font-weight: 400; color: var(--text); padding: 7px 10px; border-radius: 6px; cursor: pointer; } +.am-menue-liste button:hover:not(:disabled) { background: var(--bg); } +.am-menue-liste button:disabled { opacity: .4; cursor: default; } +.am-menue-liste button.gefahr { color: var(--warn); } +.m-neu { padding: 10px 14px 10px 94px; display: flex; gap: 16px; flex-wrap: wrap; font-size: 14px; align-items: center; } +.m-neu .verweis { text-decoration: none; } +.m-summe { display: flex; justify-content: flex-end; gap: 24px; padding: 12px 58px 12px 14px; font-size: 15px; border-top: 1px solid var(--linie); } +.am-leer { padding: 14px 14px 0 94px; } +/* geöffnete Position */ +.m-offen { margin: 0 10px 14px 18px; border: 1px solid var(--linie); border-radius: 10px; background: var(--fl); } +.m-offen .abschnitt { border-bottom: 1px solid var(--linie); } +.m-offen .abschnitt > h4 { margin: 0; padding: 8px 12px; font-size: 14px; display: flex; align-items: center; gap: 10px; flex-wrap: wrap; } +.am-auf { background: none; border: 0; font: inherit; font-weight: 700; color: var(--text); cursor: pointer; display: inline-flex; gap: 8px; align-items: center; padding: 2px 0; } +.am-auf .zu { color: var(--akzent); width: 12px; } +.m-offen .abschnitt .info { margin-left: auto; font-weight: 400; color: var(--leise); font-size: 13px; display: inline-flex; gap: 6px; align-items: center; flex-wrap: wrap; } +.m-offen .abschnitt .info b { color: var(--text); } +.m-offen .rumpf { padding: 0 12px 12px; display: flex; flex-direction: column; gap: 8px; min-width: 0; } +.m-offen textarea { width: 100%; resize: vertical; line-height: 1.45; } +.m-fertig { display: flex; justify-content: space-between; align-items: center; gap: 10px; flex-wrap: wrap; padding: 10px 12px; background: var(--bg); border-radius: 0 0 10px 10px; font-size: 13px; color: var(--leise); } +.knopfreihe { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; } +.knopfreihe .hinweis-k { margin: 0; } +button.neben.am-betont { border-color: var(--akzent); color: var(--akzent); } +.hinweis-k { font-size: 12.5px; color: var(--leise); margin: 6px 0 0; font-weight: 400; } +.am-ep-zeile { justify-content: space-between; font-size: 13.5px; } +.am-anpassen { display: inline-flex; align-items: center; gap: 6px; white-space: nowrap; } +/* Tabellen im Mengenblatt und in der Kalkulation */ +table.am-t { width: 100%; border: 1px solid var(--linie); border-radius: 8px; font-size: 13px; } +table.am-t th, table.am-t td { padding: 4px 6px; vertical-align: top; } +table.am-t th { background: var(--bg); font-size: 12px; } +table.am-t td.zahl, table.am-t th.zahl { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; } +table.am-t td.zahl { padding-top: 9px; } +table.am-t tr.summe td { font-weight: 700; background: var(--titel-bg); padding-top: 6px; } +table.am-t input, table.am-t select { padding: 4px 7px; font-size: 13px; min-height: 30px; } +table.am-t tr.aus td { opacity: .55; } +table.am-t tr.aus td:nth-last-child(2) { opacity: 1; } +table.am-aufmass td:first-child { width: 40%; } +table.kosten-tabelle tr.kz-subunternehmer td:first-child { box-shadow: inset 3px 0 0 var(--art-sub); } +input.am-eingabe { background: var(--eingabe-bg) !important; border-color: var(--eingabe-linie) !important; color: var(--eingabe-text) !important; } +input.am-formel { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 12.5px !important; color: var(--formel-text) !important; } +input.am-kz { font-family: ui-monospace, Menlo, Consolas, monospace; font-weight: 700; color: var(--formel-text) !important; width: 5.2em; } +input.mit-fehler { border-color: var(--warn) !important; outline-color: var(--warnung-linie); } +input.w-bezug { width: 7em; } +.am-fehler { display: block; color: var(--warn); font-size: 12px; margin-top: 2px; } +.am-kz-t { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 12px; font-weight: 700; color: var(--formel-text); } +.am-vorlage-info { display: flex; gap: 6px 12px; flex-wrap: wrap; align-items: center; font-size: 13px; color: var(--leise); } +.am-vorlage-info b { color: var(--text); } +.am-erg { background: var(--bg); border-radius: 6px; padding: 2px 8px; color: var(--text); font-variant-numeric: tabular-nums; } +.am-eingaben-kurz { display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 6px 10px; } +.am-eingaben-kurz label { display: flex; flex-direction: column; gap: 3px; font-size: 12px; color: var(--leise); min-width: 0; } +.am-eingaben-kurz label > span { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } +.am-liste { display: flex; flex-direction: column; gap: 6px; margin-top: 8px; } +h4.am-zwischen { margin: 4px 0 0; font-size: 14px; display: flex; gap: 8px; align-items: center; flex-wrap: wrap; } +h4.am-zwischen input.am-listenname { width: 14em; font-weight: 700; } +h3.am-h { margin: 14px 0 6px; font-size: 15px; display: flex; gap: 8px; align-items: baseline; flex-wrap: wrap; } +.karte > h3.am-h:first-child, .zwei h3.am-h { margin-top: 0; } +.zwei { display: grid; grid-template-columns: minmax(0, 1.3fr) minmax(0, 1fr); gap: 16px; } +.zwei > div { min-width: 0; } +.erg { display: grid; grid-template-columns: auto minmax(0, 1fr) auto auto; gap: 5px 10px; align-items: center; font-size: 13px; } +.erg .w { text-align: right; font-weight: 700; font-variant-numeric: tabular-nums; } +.menge-wahl { margin-top: 10px; padding: 8px 12px; border-radius: 8px; background: var(--akzent-hell); color: var(--text); font-size: 13.5px; display: flex; gap: 8px; align-items: center; flex-wrap: wrap; } +.menge-wahl input.am-menge { width: 10em; } +.am-schritt3 { display: flex; gap: 8px; align-items: flex-start; margin-top: 12px; } +.am-schritt3 > b { margin-top: 18px; } +.am-schritt3 .menge-wahl { flex: 1; } +.legende { display: flex; gap: 6px 14px; font-size: 12.5px; color: var(--leise); margin-top: 10px; flex-wrap: wrap; align-items: center; } +.legende i { display: inline-block; width: 14px; height: 14px; border-radius: 3px; vertical-align: -3px; margin-right: 4px; border: 1px solid var(--linie); } +.legende i.am-l-eingabe { background: var(--eingabe-bg); border-color: var(--eingabe-linie); } +.legende i.am-l-formel { background: var(--fl); border-color: var(--formel-text); } +details.am-spalten { margin: 4px 0; font-size: 13px; } +details.am-spalten > summary { cursor: pointer; color: var(--akzent); } +.art { display: inline-block; font-size: 11px; font-weight: 700; padding: 2px 6px; border-radius: 4px; } +.art.lohn { background: var(--art-lohn-bg); color: var(--art-lohn); } .art.material { background: var(--art-mat-bg); color: var(--art-mat); } +.art.geraet { background: var(--art-ger-bg); color: var(--art-ger); } .art.subunternehmer { background: var(--art-sub-bg); color: var(--art-sub); } +.art.sonstiges { background: var(--art-son-bg); color: var(--art-son); } +/* Seitenleiste */ +.m-seite .reiter-k { display: flex; gap: 2px; border-bottom: 1px solid var(--linie); margin: -4px -4px 10px; } +.m-seite .reiter-k button { background: none; border: 0; padding: 6px 9px; font: inherit; font-size: 13.5px; color: var(--leise); cursor: pointer; } +.m-seite .reiter-k button.an { color: var(--akzent); font-weight: 600; box-shadow: inset 0 -2px 0 var(--akzent); } +.baustein { display: flex; align-items: center; gap: 8px; padding: 6px 8px; border: 1px solid var(--linie); border-radius: 8px; margin-bottom: 6px; font-size: 14px; background: var(--fl); } +.baustein[draggable="true"] { cursor: grab; } +.baustein .g { color: var(--leise); letter-spacing: -2px; } +.baustein .am-b-text { min-width: 0; flex: 1; } +.baustein small { display: block; color: var(--leise); font-size: 12px; } +.baustein .plus { margin-left: auto; background: none; border: 1px solid transparent; color: var(--akzent); font-weight: 700; font-size: 17px; line-height: 1; cursor: pointer; border-radius: 6px; padding: 2px 7px; } +.baustein .plus:hover { border-color: var(--akzent); } +.baustein .am-b-bearb { color: var(--leise); text-decoration: none; font-size: 13px; padding: 2px 4px; } +.m-seite input.suche { margin: 4px 0 8px; } +.m-seite .gr, .am-reiter-karte .gr { font-size: 11.5px; font-weight: 700; color: var(--leise); text-transform: uppercase; letter-spacing: .05em; margin: 10px 2px 4px; } +.am-katalog-liste { max-height: 460px; overflow-y: auto; padding-right: 2px; } +details.am-vorgaben > summary { cursor: pointer; list-style: none; } +details.am-vorgaben > summary::-webkit-details-marker { display: none; } +details.am-vorgaben > summary h3 { margin: 0; } +details.am-vorgaben > summary h3::after { content: "▾"; color: var(--akzent); margin-left: auto; } +details.am-vorgaben:not([open]) > summary h3::after { content: "▸"; } +.vorgabe { display: grid; grid-template-columns: 1fr; gap: 4px; font-size: 13px; margin-top: 8px; } +.vorgabe .t { font-weight: 600; color: var(--leise); font-size: 12px; margin-top: 6px; text-transform: uppercase; letter-spacing: .04em; } +.vorgabe label { display: flex; justify-content: space-between; align-items: center; gap: 8px; } +.vorgabe label input { width: 6.5em !important; } +.vorgabe label .mit-einheit input { width: 4.5em !important; } +.am-haupt { display: flex; flex-direction: column; gap: 16px; min-width: 0; } +.am-seite-gross { display: flex; flex-direction: column; gap: 16px; min-width: 0; } +.am-oben { margin-bottom: 10px; } +.am-speichern label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); margin-top: 8px; } +.am-speichern label.am-radio { flex-direction: row; align-items: center; gap: 8px; color: var(--text); font-size: 14px; margin-top: 4px; } +.am-speichern label.am-radio input { width: auto; } +.am-speichern textarea { resize: vertical; } +ul.am-liste-punkte { margin: 0; padding-left: 18px; font-size: 14px; display: flex; flex-direction: column; gap: 6px; } +.am-suche-seite { width: 100%; max-width: 420px; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; margin: 6px 0 4px; } +h2.am-gruppe { font-size: 15px; margin: 18px 0 6px; color: var(--leise); text-transform: uppercase; letter-spacing: .04em; } +@media (max-width: 1100px) { + .am-raster { grid-template-columns: 1fr; } + .zwei { grid-template-columns: 1fr; } +} +@media (max-width: 800px) { + .am-zeile { grid-template-columns: 56px 80px 60px minmax(0, 1fr) 30px; } + .am-zeile .am-ep, .am-zeile .gb, .am-zeile.kopfzeile > :nth-child(5), .am-zeile.kopfzeile > :nth-child(6) { display: none; } + .am-zeile.titel { grid-template-columns: 56px minmax(0, 1fr) 30px; } + .am-zeile.titel .gb { display: none; } + .m-offen { margin-left: 12px; } + .m-neu, .am-leer { padding-left: 14px; } +} + +table.kosten-tabelle td.kz-aus { white-space: nowrap; padding-top: 9px; } +table.kosten-tabelle td.kz-aus .weg { margin-left: 2px; } +table.kosten-tabelle td.kz-aus input { width: 16px; height: 16px; min-height: 0; padding: 0; vertical-align: middle; } diff --git a/test/api.test.ts b/test/api.test.ts index 3861168..394b287 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -377,8 +377,12 @@ describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...(await app.inject("/api/einstellungen")).json(), startsaldo: 1234500 } }); const kat = (await app.inject({ method: "POST", url: "/api/aufgaben-kategorien", payload: { name: "Büro" } })).json(); await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Angebot nachfassen", kategorie_id: kat.id } }); + const mv = await app.inject({ method: "POST", url: "/api/mengenvorlagen", payload: { art: "muster", gruppe: "Klempner", name: "Ortgangblech", einheit: "m", + inhalt: { werte: [{ kz: "L", formel: "8", eingabe: true }], listen: [], zeilen: [], menge: "L", ansaetze: [{ kostenart: "lohn", lohnart: "geselle", bezug: "L", menge: 0.1, personen: 1 }] } } }); + expect(mv.statusCode, mv.body).toBe(201); const vorher = (await app.inject("/api/export")).json(); expect(vorher.daten["aufgaben-kategorien"]).toHaveLength(1); + expect(vorher.daten.mengenvorlagen).toHaveLength(1); expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(409); expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: { programm: "anders" } })).statusCode).toBe(400); @@ -1088,4 +1092,70 @@ describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => { expect((await post(`angebote/${a.id}/ablehnen`)).statusCode).toBe(200); expect((await hole("uebersicht?heute=2026-12-05")).warnungen.some((w: { art: string }) => w.art === "angebot")).toBe(false); }); + it("Mengenblatt, Musterpositionen und Bausteine: einfügen unter der markierten Zeile, Bezug rechnet mit, eigene Vorlage (A22, A23)", async () => { + const p = await neu("projekte", { nummer: "A-26-150", bezeichnung: "Dachstuhl Petersen" }); + const a = await neu("angebote/neu", { projekt_id: p.id }); + expect(a.saetze.mengen).toEqual({ verschnitt: 10, oeffnung_ab: 2.5 }); + const t = (await post(`angebote/${a.id}/einfuegen`, { was: "titel" })).json(); + const erste = (await post(`angebote/${a.id}/einfuegen`, { was: "position", titel_id: t.id })).json(); + const letzte = (await post(`angebote/${a.id}/einfuegen`, { was: "text", nach_id: erste.id })).json(); + + // Musterposition Pfettendach mit geänderter Pfettenlänge zwischen die beiden Zeilen + const r = await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "std-pfettendach", nach_id: erste.id, eingaben: { LP: "12" } }); + expect(r.statusCode, r.body).toBe(201); + const voll = await hole(`angebote/${a.id}/voll`); + const reihe = voll.positionen.filter((x: { titel_id: string }) => x.titel_id === t.id).sort((x: { reihenfolge: number }, y: { reihenfolge: number }) => x.reihenfolge - y.reihenfolge).map((x: { id: string }) => x.id); + expect(reihe).toEqual([erste.id, r.json().id, letzte.id]); + const pf = voll.positionen.find((x: { id: string }) => x.id === r.json().id); + expect(pf).toMatchObject({ kurztext: expect.stringContaining("Pfettendach"), einheit: "m", mit_aufmass: true, mit_kalkulation: true }); + expect(Number(pf.menge)).toBe(213); + const erg = voll.ergebnis.positionen[pf.id]; + expect(erg.menge).toBe(213); + // Abbund = HL × 0,03 Std × 2 Personen + const abbund = voll.kosten.filter((k: { position_id: string }) => k.position_id === pf.id).findIndex((k: { beschreibung: string }) => k.beschreibung === "Abbund"); + expect(erg.kostenzeilen[abbund].menge_gesamt).toBeCloseTo(213 * 0.03 * 2, 4); + expect(voll.pruefung.some((x: { text: string }) => /Material .* hat keinen Preis/.test(x.text))).toBe(true); + + // Aufmaß ändern: Menge und Stunden folgen + const blatt = { ...pf.aufmass, zeilen: [], werte: pf.aufmass.werte.map((w: { kz: string }) => (w.kz === "LP" ? { ...w, formel: "10" } : w)) }; + expect((await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${pf.id}`, payload: { aufmass: blatt } })).statusCode).toBe(200); + expect((await hole(`angebote/${a.id}/voll`)).ergebnis.positionen[pf.id].menge).toBe(200); + + // freie Position mit Aufmaßzeilen, ohne Kalkulation + const blech = (await post(`angebote/${a.id}/einfuegen`, { was: "position", nach_id: pf.id })).json(); + await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${blech.id}`, payload: { mit_aufmass: true, ep_fest: 4850, einheit: "m²", + aufmass: { werte: [], listen: [], zeilen: [{ text: "Nordseite", formel: "10 * 0,3" }, { text: "Giebel", formel: "4 * (8/2/cos(31)) * 0,3" }] } } }); + const v2 = await hole(`angebote/${a.id}/voll`); + expect(v2.ergebnis.positionen[blech.id].menge).toBeCloseTo(3 + 4 * (4 / Math.cos((31 * Math.PI) / 180)) * 0.3, 3); + + // als eigene Musterposition speichern und in eine neue Zeile einfügen; die Kostenzeilen kommen mit + const mv = await post(`angebot-positionen/${pf.id}/als-vorlage`, { name: "Mein Pfettendach", gruppe: "Dach", art: "muster" }); + expect(mv.statusCode, mv.body).toBe(201); + expect(mv.json().inhalt.ansaetze.length).toBe(v2.kosten.filter((k: { position_id: string }) => k.position_id === pf.id).length); + expect((await hole("mengenvorlagen-alle")).some((v: { id: string; fest: boolean }) => v.id === mv.json().id && !v.fest)).toBe(true); + const kopie = (await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: mv.json().id })).json(); + const v3 = await hole(`angebote/${a.id}/voll`); + expect(v3.ergebnis.positionen[kopie.id].ep).toBe(v3.ergebnis.positionen[pf.id].ep); + + // Mengenvorlage in eine bestehende Position: ersetzt die Kostenzeilen aus der alten Vorlage, eigene bleiben + await neu("angebot-kosten", { position_id: kopie.id, kostenart: "sonstiges", menge: 1, ek: 1000, beschreibung: "Eigene Zeile" }); + await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "std-satteldach", position_id: kopie.id }); + const v4 = await hole(`angebote/${a.id}/voll`); + expect(v4.kosten.filter((k: { position_id: string }) => k.position_id === kopie.id).map((k: { beschreibung: string }) => k.beschreibung)).toEqual(["Eigene Zeile"]); + expect(v4.positionen.find((x: { id: string }) => x.id === kopie.id).aufmass.vorlage.id).toBe("std-satteldach"); + + expect((await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "gibt-es-nicht" })).statusCode).toBe(409); + }); + + it("Subunternehmer als Kostenart: beim Annehmen werden seine Kosten Fremdleistung", async () => { + const p = await neu("projekte", { nummer: "A-26-160", bezeichnung: "Gerüst Hansen" }); + const a = await neu("angebote/neu", { projekt_id: p.id }); + const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Gerüst stellen", menge: 100, einheit: "m²" }); + await neu("angebot-kosten", { position_id: pos.id, kostenart: "subunternehmer", menge: 1, ek: 800, beschreibung: "Gerüstbau Petersen" }); + const voll = await hole(`angebote/${a.id}/voll`); + expect(voll.ergebnis.kosten).toBe(80000); + await post(`angebote/${a.id}/versenden`, { trotzdem: true }); + expect((await post(`angebote/${a.id}/annehmen`, { start: "2026-11-02" })).statusCode).toBe(200); + expect((await hole(`projekte/${p.id}`)).fremd_kosten).toBe(80000); + }); }); diff --git a/test/formel.test.ts b/test/formel.test.ts new file mode 100644 index 0000000..d5511f7 --- /dev/null +++ b/test/formel.test.ts @@ -0,0 +1,98 @@ +import { describe, expect, it } from "vitest"; +import { benenneUm, berechne, FormelFehler, kuerzelIn, zahlDeutsch } from "../src/domain/formel.js"; +import { werteBlatt, textMitWerten } from "../src/domain/mengenblatt.js"; +import { STANDARD_VORLAGEN } from "../src/domain/mengenvorlagen.js"; +import { umgebungVon } from "../src/domain/kalkulation.js"; + +const r = (f: string, w: Record = {}) => berechne(f, { wert: (n) => { if (n in w) return w[n]!; throw new FormelFehler(`„${n}“ unbekannt`); } }); + +describe("Formeln", () => { + it("rechnet mit Komma, Punkt-vor-Strich und Klammern wie Plancraft", () => { + expect(r("100+(5,1*4)/2")).toBeCloseTo(110.2); + expect(r("10,00 * 0,30")).toBeCloseTo(3); + expect(r("2 × 8 · 0,3")).toBeCloseTo(4.8); + expect(r("-2^2")).toBe(-4); + expect(r("10 %")).toBeCloseTo(0.1); + }); + it("Winkel in Grad, Funktionen mit Semikolon", () => { + expect(r("cos(60)")).toBeCloseTo(0.5); + expect(r("(B/2+UET)/cos(DN)", { B: 8, UET: 0.5, DN: 35 })).toBeCloseTo(5.4935, 3); + expect(r("aufrunden(10/2,6)")).toBe(4); + expect(r("aufrunden(10/2,5)")).toBe(4); + expect(r("runden(2,675; 2)")).toBe(2.68); + expect(r("wenn(3 > 2; 1; 0)")).toBe(1); + expect(r('wenn("G" = "g"; 5)')).toBe(5); + expect(r("max(1; 7; 3)")).toBe(7); + expect(r("ROUNDUP(4,2;0)")).toBe(5); + }); + it("Einheit hinter einer Zahl wird überlesen", () => { + expect(r("2,5 m * 2")).toBe(5); + expect(r("31°")).toBe(31); + }); + it("meldet Fehler verständlich", () => { + expect(() => r("L * FZ", { L: 2 })).toThrow("„FZ“ unbekannt"); + expect(() => r("(1+2")).toThrow("Klammer zu fehlt"); + expect(() => r("1/0")).toThrow("Teilen durch 0"); + expect(() => r("2 2")).toThrow(/Rechenzeichen/); + expect(() => r("30 mm")).toThrow(); + }); + it("Kürzel finden und umbenennen", () => { + expect(kuerzelIn("aufrunden(L / TL) - 1")).toEqual(["L", "TL"]); + expect(benenneUm("L + STO * L2 + summe(BT.L)", "L", "LA")).toBe("LA + STO * L2 + summe(BT.L)"); + }); + it("Zahlen deutsch", () => { + expect(zahlDeutsch(200, "m")).toBe("200,00"); + expect(zahlDeutsch(8, "St")).toBe("8"); + expect(zahlDeutsch(3.1524, "m³")).toBe("3,152"); + }); +}); + +describe("Mengenblatt", () => { + it("freie Aufmaßzeilen ergeben die Menge (Bild 5)", () => { + const a = werteBlatt({ werte: [], listen: [], zeilen: [{ text: "Nord", formel: "10,00 * 0,30" }, { text: "Süd", formel: "10*0,3" }, { formel: "2 * 8,00 * 0,30" }, { formel: "" }] }); + expect(a.menge).toBeCloseTo(10.8); + expect(a.ergebnis["z:3"]).toBeNull(); + }); + it("Kreisbezug und doppelte Kürzel", () => { + const a = werteBlatt({ werte: [{ kz: "A", formel: "B + 1" }, { kz: "B", formel: "A * 2" }, { kz: "C", formel: "1" }, { kz: "C", formel: "2" }], listen: [], zeilen: [], menge: "C" }); + expect(a.fehler["w:0"]).toMatch(/Kreisbezug|Fehler/); + expect(a.fehler["w:3"]).toMatch(/zweimal/); + expect(a.menge).toBe(1); + }); + it("Platzhalter im Text", () => { + const a = werteBlatt({ werte: [{ kz: "Z", formel: "0,3" }], listen: [], zeilen: [] }); + expect(textMitWerten("Z = {Z} m, {X}", a, { Z: "m" })).toBe("Z = 0,30 m, {X}"); + }); +}); + +describe("mitgelieferte Vorlagen", () => { + const umg = umgebungVon({ mengen: { verschnitt: 10, oeffnung_ab: 2.5 } }); + for (const v of STANDARD_VORLAGEN) { + it(`${v.name} rechnet ohne Fehler`, () => { + const a = werteBlatt(v.inhalt, umg); + expect(a.fehler).toEqual({}); + expect(a.menge).toBeGreaterThan(0); + for (const z of v.inhalt.ansaetze) if (z.bezug) expect(a.rechne(z.bezug)).toBeGreaterThan(0); + }); + } + it("Pfettendach: 200 m Holz, 3,152 m³, 8 Stützen (Bild 3)", () => { + const a = werteBlatt(STANDARD_VORLAGEN.find((v) => v.id === "std-pfettendach")!.inhalt, umg); + expect(a.werte.ST).toBe(8); + expect(a.menge).toBe(200); + expect(a.werte.HV).toBeCloseTo(3.152); + expect(a.werte.SPL).toBe(140); + }); + it("Wandliste: Giebel als Dreieck, Öffnungen erst über 2,5 m² abgezogen (Bild 4)", () => { + const a = werteBlatt(STANDARD_VORLAGEN.find((v) => v.id === "std-holzrahmenwand")!.inhalt, umg); + expect(a.werte.AB).toBeCloseTo(118.2); + expect(a.werte.AO).toBeCloseTo(7.3265, 3); + expect(a.werte.GR).toBeCloseTo(18.66, 1); + expect(a.werte.NOE).toBe(3); + }); + it("Abdeckblech: LG 12,25 m (Bild 6)", () => { + const a = werteBlatt(STANDARD_VORLAGEN.find((v) => v.id === "std-abdeckblech")!.inhalt, umg); + expect(a.werte.STO).toBe(5); + expect(a.menge).toBeCloseTo(12.25); + expect(a.werte.HA).toBe(25); + }); +});