// 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 Mengenvorlagen

'; 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 = "stammdaten-mengen"; } } catch (e) { fehler(e); } }); if (hinweis.text) { meldung = hinweis.text; hinweis.text = ""; hinweis.gut = false; zeichne(); } }