Neue Angebotsmaske: Mengenblatt mit Formeln, Musterpositionen und Mengenvorlagen im Katalog, Kostenzeilen mit Bezug, Subunternehmer (0.17.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
451
src/web/mengenblatt.ts
Normal file
451
src/web/mengenblatt.ts
Normal file
@@ -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:<id>: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(`(?<![\\p{L}\\p{N}_.])${alt}\\.`, "gu"), `${wert}.`));
|
||||
}
|
||||
const skz = /^listen\.(\d+)\.spalten\.(\d+)\.kz$/.exec(pfad);
|
||||
if (skz) {
|
||||
const l = blatt.listen[Number(skz[1])]!, alt = l.spalten[Number(skz[2])]?.kz ?? "";
|
||||
if (alt && wert && alt !== wert) {
|
||||
for (const s of l.spalten) if (s.formel) s.formel = benenneUm(s.formel, alt, wert);
|
||||
for (const z of l.zeilen) {
|
||||
if (alt in z) { z[wert] = z[alt]!; delete z[alt]; }
|
||||
for (const k of Object.keys(z)) z[k] = benenneUm(z[k]!, alt, wert);
|
||||
}
|
||||
benenneImBlatt(blatt, (f) => 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:<id>:“ */
|
||||
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 }) =>
|
||||
`<input data-k="${esc(k)}" data-typ="roh" value="${esc(wert ?? "")}" class="${o.klasse ?? ""}${o.fehler ? " mit-fehler" : ""}"${o.titel ? ` aria-label="${esc(o.titel)}"` : ""}${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.liste ? ` list="${o.liste}"` : ""}${o.fehler ? ` title="${esc(o.fehler)}"` : ""}${o.frei ? "" : " disabled"}>`;
|
||||
const weg = (a: string, k: string, extra: string, frei: boolean, titel: string) =>
|
||||
frei ? `<button class="weg" data-a="${a}" data-b="${esc(k)}" ${extra} title="${titel}" aria-label="${titel}">×</button>` : "";
|
||||
const fehlerZelle = (f: string | undefined) => (f ? `<span class="am-fehler">${esc(f)}</span>` : "");
|
||||
|
||||
/** 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 `<datalist id="${id}">${kz.filter(([k]) => k).map(([k, t]) => `<option value="${esc(k)}">${esc(t)}</option>`).join("")}</datalist>`;
|
||||
}
|
||||
|
||||
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" ? "<th>Kürzel</th><th>Bezeichnung</th><th>Einheit</th><th>Beispiel</th><th></th>"
|
||||
: `<th>Kürzel</th><th>Bezeichnung</th><th>${nur === "formel" ? "Formel" : "Wert / Formel"}</th><th class="zahl">${vorlage ? "Probe" : "Ergebnis"}</th>${vorlage ? "" : "<th>Einheit</th>"}<th></th>`;
|
||||
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 `<tr><td>${kzFeld}</td><td>${bezFeld}</td><td>${einheitFeld}</td><td>${wertFeld}${fehlerZelle(f)}</td><td>${loeschen}</td></tr>`;
|
||||
return `<tr><td>${kzFeld}</td><td>${bezFeld}</td><td>${wertFeld}${fehlerZelle(f)}</td><td class="zahl"><b>${f ? "–" : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}</b></td>${vorlage ? "" : `<td>${einheitFeld}</td>`}<td>${loeschen}</td></tr>`;
|
||||
}).join("");
|
||||
return `<div class="tabelle-rolle"><table class="am-t"><thead><tr>${kopf}</tr></thead><tbody>${rumpf || `<tr><td colspan="6" class="hinweis">${nur === "formel" ? "Noch keine Formel." : "Noch keine Eingabe."}</td></tr>`}</tbody></table></div>`;
|
||||
}
|
||||
|
||||
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) => `<th class="${s.art === "text" ? "" : "zahl"}">${esc(s.bez || s.kz)}${s.einheit ? ` <small>[${esc(s.einheit)}]</small>` : ""}</th>`).join("");
|
||||
const zeilen = l.zeilen.map((z, zi) => `<tr>${l.spalten.map((s) => {
|
||||
const sch = `l:${li}:${zi}:${s.kz}`, f = a.fehler[sch];
|
||||
if (s.formel || lesen) return `<td class="${s.art === "text" ? "" : "zahl"}">${f ? `<span class="am-fehler" title="${esc(f)}">Fehler</span>` : s.formel ? `<b>${ergebnisText(a.ergebnis[sch], s.einheit)}</b>` : ergebnisText(a.ergebnis[sch], s.einheit)}</td>`;
|
||||
return `<td>${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" })}</td>`;
|
||||
}).join("")}${lesen ? "" : `<td>${weg("b-lzeile-weg", o.k, `data-l="${li}" data-i="${zi}"`, o.frei, "Zeile löschen")}</td>`}</tr>`).join("");
|
||||
const summen = l.spalten.map((s) => {
|
||||
if (s.art === "text" || !s.formel) return "<td></td>";
|
||||
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 `<td class="zahl">${zahlDeutsch(v, s.einheit)}</td>`;
|
||||
});
|
||||
summen[0] = "<td>Summe</td>";
|
||||
const spalten = o.modus === "vorlage" ? `<details class="am-spalten"${l.spalten.length ? "" : " open"}><summary>Spalten der Liste festlegen</summary>
|
||||
<div class="tabelle-rolle"><table class="am-t"><thead><tr><th>Kürzel</th><th>Bezeichnung</th><th>Einheit</th><th>Art</th><th>Formel (berechnet)</th><th></th></tr></thead><tbody>
|
||||
${l.spalten.map((s, si) => `<tr><td>${feld(`${o.k}listen.${li}.spalten.${si}.kz`, s.kz, { klasse: "am-kz", titel: "Kürzel der Spalte", frei: o.frei })}</td>
|
||||
<td>${feld(`${o.k}listen.${li}.spalten.${si}.bez`, s.bez, { titel: "Bezeichnung", frei: o.frei })}</td>
|
||||
<td>${feld(`${o.k}listen.${li}.spalten.${si}.einheit`, s.einheit, { klasse: "w-kurz", titel: "Einheit", frei: o.frei, liste: "einheiten" })}</td>
|
||||
<td><select data-k="${esc(`${o.k}listen.${li}.spalten.${si}.typ`)}" data-typ="roh" aria-label="Art der Spalte"${o.frei ? "" : " disabled"}>${optionenHtml([["text", "Eingabe Text"], ["zahl", "Eingabe Zahl"], ["formel", "berechnet"]], s.formel !== null && s.formel !== undefined ? "formel" : s.art === "text" ? "text" : "zahl")}</select></td>
|
||||
<td>${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" }) : ""}</td>
|
||||
<td>${weg("b-spalte-weg", o.k, `data-l="${li}" data-i="${si}"`, o.frei, "Spalte löschen")}</td></tr>`).join("")}</tbody></table></div>
|
||||
${o.frei ? `<button class="neben klein" data-a="b-spalte-neu" data-b="${esc(o.k)}" data-l="${li}">+ Spalte</button>` : ""}
|
||||
<p class="hinweis-k">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").</p></details>` : "";
|
||||
return `<div class="am-liste"><h4 class="am-zwischen">${o.modus === "vorlage" ? `${feld(`${o.k}listen.${li}.name`, l.name, { titel: "Name der Liste", frei: o.frei, klasse: "am-listenname" })} <span class="hinweis">Kürzel</span> ${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)} <span class="hinweis">(${esc(l.kz)})</span>`}</h4>
|
||||
${spalten}
|
||||
<div class="tabelle-rolle"><table class="am-t"><thead><tr>${kopf}${lesen ? "" : "<th></th>"}</tr></thead><tbody>${zeilen}<tr class="summe">${summen.join("")}${lesen ? "" : "<td></td>"}</tr></tbody></table></div>
|
||||
${!lesen && o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-lzeile-neu" data-b="${esc(o.k)}" data-l="${li}">+ Zeile</button></div>` : ""}</div>`;
|
||||
}
|
||||
|
||||
/** 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 `<tr><td>${feld(`${o.k}zeilen.${i}.text`, z.text, { titel: `Beschreibung Zeile ${i + 1}`, frei: o.frei, platz: i === 0 ? "z. B. Wand links" : "" })}</td>
|
||||
<td>${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)}</td>
|
||||
<td class="zahl"><b>${f ? "–" : ergebnisText(a.ergebnis[`z:${i}`], o.einheit)}</b></td><td>${weg("b-zeile-weg", o.k, `data-i="${i}"`, o.frei, "Zeile löschen")}</td></tr>`;
|
||||
}).join("");
|
||||
const summeMenge = !b.menge?.trim();
|
||||
return `<div class="tabelle-rolle"><table class="am-t am-aufmass"><thead><tr><th>Beschreibung</th><th>Formel</th><th class="zahl">Ergebnis</th><th></th></tr></thead><tbody>${zeilen}
|
||||
<tr class="summe"><td colspan="2">${summeMenge ? "Summe → Menge der Position" : "Summe der Aufmaßzeilen"}</td><td class="zahl">${zahlDeutsch(a.summeZeilen, o.einheit)}</td><td></td></tr></tbody></table></div>`;
|
||||
}
|
||||
|
||||
function mengeWahl(b: Blatt, a: Auswertung, o: BlattOptionen): string {
|
||||
return `<div class="menge-wahl"><span>Menge der Position</span>${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 })}
|
||||
<span>= <b>${a.menge === null ? "–" : `${zahlDeutsch(a.menge, o.einheit)} ${esc(o.einheit ?? "")}`}</b></span>${fehlerZelle(a.fehler.menge)}</div>`;
|
||||
}
|
||||
|
||||
const legende = `<div class="legende"><span><i class="am-l-eingabe"></i>Eingabe</span><span><i class="am-l-formel"></i>Formel mit Kürzeln, z. B. (B/2+UET)/cos(DN)</span>
|
||||
<span>Erlaubt: + − * / ^ ( ), ${FUNKTIONEN.slice(0, 12).join(", ")} …; Argumente mit Semikolon trennen, Winkel in Grad.</span></div>`;
|
||||
|
||||
/** 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 ? `<div class="am-vorlage-info">${b.vorlage ? `Vorlage <b>${esc(b.vorlage.name)}</b>` : "Mengenblatt"}
|
||||
${formeln.map(([w, i]) => `<span class="am-erg"><span class="am-kz-t">${esc(w.kz)}</span> ${zahlDeutsch(a.ergebnis[`w:${i}`] as number, w.einheit)} ${esc(w.einheit ?? "")}</span>`).join("")}
|
||||
${fehler ? `<span class="am-fehler">${fehler} Fehler im Mengenblatt</span>` : ""}</div>
|
||||
${b.werte.some((w) => w.eingabe) ? `<div class="am-eingaben-kurz">${b.werte.map((w, i) => [w, i] as const).filter(([w]) => w.eingabe).map(([w, i]) => `<label><span><span class="am-kz-t">${esc(w.kz)}</span> ${esc(w.bez ?? "")}</span>${feld(`${o.k}werte.${i}.formel`, w.formel, { klasse: "am-eingabe zahl", titel: `${w.kz} ${w.bez ?? ""}`, frei: o.frei, fehler: a.fehler[`w:${i}`], liste: "am-kuerzel" })}</label>`).join("")}</div>` : ""}
|
||||
${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 `<div class="zwei"><div><h3 class="am-h">Grunddaten und Formeln</h3>${werteTabelle(b, a, o)}
|
||||
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="eingabe">+ Eingabe</button><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="formel">+ Formel</button></div>` : ""}</div>
|
||||
<div><h3 class="am-h">Ergebnisse</h3><div class="erg">${formeln.map(([w, i]) => `<span class="am-kz-t">${esc(w.kz)}</span><span>${esc(w.bez ?? "")}</span><span class="w">${a.fehler[`w:${i}`] ? '<span class="am-fehler">Fehler</span>' : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}</span><span>${esc(w.einheit ?? "")}</span>`).join("") || '<span class="hinweis">Noch keine Formel.</span>'}</div>
|
||||
${mengeWahl(b, a, o)}</div></div>
|
||||
${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}
|
||||
<h3 class="am-h">Aufmaßzeilen</h3>${aufmassZeilenHtml(b, a, o)}
|
||||
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-zeile-neu" data-b="${esc(o.k)}">+ Aufmaßzeile</button></div>` : ""}${legende}`;
|
||||
}
|
||||
return `<div class="zwei am-zwei-v"><div><h3 class="am-h">1 Eingaben <span class="hinweis-k">fragt das Programm beim Einfügen ab</span></h3>${werteTabelle(b, a, o, "eingabe")}
|
||||
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="eingabe">+ Eingabe</button><button class="neben klein" data-a="b-liste-neu" data-b="${esc(o.k)}">+ Liste (wie W/F/G)</button></div>` : ""}</div>
|
||||
<div><h3 class="am-h">2 Formeln <span class="hinweis-k">rechnen mit den Kürzeln</span></h3>${werteTabelle(b, a, o, "formel")}
|
||||
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="formel">+ Formel</button></div>` : ""}</div></div>
|
||||
${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}
|
||||
${legende}
|
||||
<div class="am-schritt3"><b>3</b> ${mengeWahl(b, a, o)}</div>`;
|
||||
}
|
||||
|
||||
// ---------- Vorlagen auswählen und einfügen ----------
|
||||
|
||||
let vorlagenSpeicher: Mengenvorlage[] | null = null;
|
||||
export async function alleVorlagen(neu = false): Promise<Mengenvorlage[]> {
|
||||
if (!vorlagenSpeicher || neu) vorlagenSpeicher = await api<Mengenvorlage[]>("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 `<p class="hinweis-k">${s ? "Nichts gefunden." : "Noch keine Vorlage."}</p>`;
|
||||
return gruppen.map((g) => `<div class="gr">${esc(g)}</div>${passend.filter((v) => v.gruppe === g).map((v) => `<div class="baustein"${o.frei ? ` draggable="true" data-zieh="vorlage:${esc(v.id)}"` : ""}>
|
||||
<span class="g" aria-hidden="true">⋮⋮</span><span class="am-b-text">${esc(v.name)}${v.beschreibung ? `<small>${esc(v.beschreibung)}</small>` : ""}</span>
|
||||
${o.frei ? `<button class="plus" data-a="vorlage" data-id="${esc(v.id)}"${o.ziel ? ` data-in="${esc(o.ziel)}"` : ""} title="${o.ziel ? "In das Mengenblatt einfügen" : "Unter der markierten Zeile einfügen"}" aria-label="${esc(v.name)} einfügen">+</button>` : ""}
|
||||
<a class="am-b-bearb" href="#vorlage-${esc(v.id)}" title="${v.fest ? "Ansehen und kopieren" : "Bearbeiten"}" aria-label="${esc(v.name)} ${v.fest ? "ansehen" : "bearbeiten"}">✎</a></div>`).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<Record<string, string> | 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 `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}"><td><select data-k="${k("kostenart")}" data-typ="roh" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ANSATZ_ARTEN, z.kostenart)}</select></td>
|
||||
<td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td>
|
||||
<td>${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })}</td>
|
||||
<td>${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 })}</td>
|
||||
<td>${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 })}</td>
|
||||
<td>${lohn ? '<span class="hinweis">h</span>' : feld(k("einheit"), z.einheit, { klasse: "w-kurz", titel: "Einheit", frei, liste: "einheiten" })}</td>
|
||||
<td>${feld(k("ek"), z.ek == null ? "" : formatEuro(z.ek, false), { klasse: "zahl w-euro", titel: "EK", frei, platz: lohn ? "Satz" : "0,00" })}</td>
|
||||
<td class="zahl"><b>${probe}</b></td>
|
||||
<td><input type="checkbox" data-k="${k("aktiv")}" data-typ="bool" ${z.aktiv === false ? "" : "checked"} aria-label="notwendig"${frei ? "" : " disabled"}></td>
|
||||
<td>${frei ? `<button class="weg" data-a="v-ansatz-weg" data-i="${i}" title="Zeile löschen" aria-label="Zeile löschen">×</button>` : ""}</td></tr>`;
|
||||
}).join("");
|
||||
return `<div class="tabelle-rolle"><table class="am-t kosten-tabelle"><thead><tr><th>Art</th><th>Tätigkeit / Material</th><th>Bezug</th><th class="zahl">Ansatz</th><th class="zahl">Pers. / Faktor</th><th>Einheit</th><th class="zahl">EK</th><th class="zahl">Probe</th><th title="notwendig">✓</th><th></th></tr></thead>
|
||||
<tbody>${rumpf || '<tr><td colspan="10" class="hinweis">Noch keine Zeitansätze. Ohne sie bleibt es eine reine Mengenvorlage.</td></tr>'}</tbody></table></div>
|
||||
${frei ? `<div class="knopfreihe">${ANSATZ_ARTEN.map(([x, t]) => `<button class="neben klein" data-a="v-ansatz-neu" data-art="${x}">+ ${t}</button>`).join("")}</div>` : ""}
|
||||
<p class="hinweis-k">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.</p>`;
|
||||
}
|
||||
|
||||
export async function vorlageSeite(id: string): Promise<void> {
|
||||
const liste = await alleVorlagen(true);
|
||||
let v = structuredClone(liste.find((x) => String(x.id) === id));
|
||||
if (!v) { inhalt.innerHTML = '<p class="fehler">Diese Vorlage gibt es nicht (mehr).</p><p><a href="#vorlagen">Zu den Vorlagen</a></p>'; 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)}<datalist id="am-gruppen">${gruppen.map((g) => `<option value="${esc(g)}">`).join("")}</datalist>
|
||||
<datalist id="einheiten">${["m", "m²", "m³", "St", "kg", "t", "h", "psch"].map((x) => `<option value="${x}">`).join("")}</datalist>
|
||||
<div class="kopf am-kopf"><a class="neben zurueck" href="#vorlagen" aria-label="Zu den Vorlagen">←</a><h1>${v!.fest ? "Mitgelieferte Vorlage" : "Eigene Vorlage"} <span class="nummer">${esc(v!.name)}</span></h1>
|
||||
<span class="kopf-knoepfe"><button class="neben" data-a="v-kopie">${v!.fest ? "Kopieren und ändern" : "Kopieren"}</button>${frei ? '<button class="neben gefahr" data-a="v-weg">Löschen</button>' : ""}</span></div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
|
||||
${v!.fest ? '<p class="hinweis">Diese Vorlage ist mitgeliefert und lässt sich nicht ändern. Mit „Kopieren und ändern“ wird sie deine eigene.</p>' : ""}
|
||||
<div class="angebot-raster am-raster"><div class="am-haupt">
|
||||
<section class="karte">${blattHtml(v!.inhalt, a, { k: "vb:", frei, modus: "vorlage", einheit: v!.einheit })}</section>
|
||||
<section class="karte"><h3 class="am-h">4 Zeitansätze und Material <span class="hinweis-k">werden beim Einfügen zu Kostenzeilen der Position</span></h3>${ansaetzeHtml(v!, a, frei)}</section>
|
||||
</div>
|
||||
<aside class="angebot-seite">
|
||||
<section class="karte am-speichern"><h3>Speichern als</h3>
|
||||
<label class="am-radio"><input type="radio" name="v-art" data-k="v:art" data-typ="roh" value="mengen"${v!.art === "mengen" ? " checked" : ""}${frei ? "" : " disabled"}> nur Mengenvorlage</label>
|
||||
<label class="am-radio"><input type="radio" name="v-art" data-k="v:art" data-typ="roh" value="muster"${v!.art === "muster" ? " checked" : ""}${frei ? "" : " disabled"}> Musterposition mit Texten und Kalkulation</label>
|
||||
<label>Name${feld("v:name", v!.name, { titel: "Name", frei })}</label>
|
||||
<label>Gruppe${feld("v:gruppe", v!.gruppe, { titel: "Gruppe", frei, liste: "am-gruppen", platz: "z. B. Klempner / Blech" })}</label>
|
||||
<label>Kurze Beschreibung${feld("v:beschreibung", v!.beschreibung, { titel: "Beschreibung", frei, platz: "steht unter dem Namen im Katalog" })}</label>
|
||||
<label>Einheit der Position${feld("v:einheit", v!.einheit, { klasse: "w-kurz", titel: "Einheit", frei, liste: "einheiten" })}</label>
|
||||
${v!.art === "muster" ? `<label>Kurztext${feld("v:kurztext", v!.kurztext, { titel: "Kurztext", frei })}</label>
|
||||
<label>Langtext<textarea data-k="v:langtext" data-typ="roh" rows="5"${frei ? "" : " disabled"}>${esc(v!.langtext ?? "")}</textarea></label>
|
||||
<p class="hinweis-k">{Z} oder {K} im Text setzt das Programm im Angebot mit den Werten des Mengenblatts ein.</p>` : ""}</section>
|
||||
<section class="karte"><h3>So entsteht eine Vorlage</h3><ul class="am-liste-punkte">
|
||||
<li>Im Angebot ein Mengenblatt bauen und „Als Vorlage speichern“, oder</li><li>Daten → Vorlagen → „Neue Vorlage“, oder</li><li>eine vorhandene Vorlage kopieren und ändern.</li></ul>
|
||||
<p class="hinweis-k">Danach steht sie im Angebot rechts unter Bausteine (Musterpositionen) und Mengenvorlagen, für jedes neue Angebot.</p></section>
|
||||
</aside></div>`;
|
||||
if (k) wurzel.querySelector<HTMLInputElement>(`[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<string, unknown>;
|
||||
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<HTMLElement>("[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<Zeile>("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<void> {
|
||||
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 = `<div class="kopf"><a class="neben zurueck" href="#daten" aria-label="Zu den Daten">←</a><h1>Vorlagen</h1><button class="haupt" data-a="neu">Neue Vorlage</button></div>
|
||||
<p class="hinweis">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.</p>
|
||||
<input class="am-suche-seite" type="search" placeholder="Vorlage suchen …" value="${esc(suche)}" aria-label="Vorlage suchen">
|
||||
${gruppen.map((g) => `<h2 class="am-gruppe">${esc(g)}</h2><ul class="dokumente">${passend.filter((v) => v.gruppe === g).map((v) => `<li><a class="dokument" href="#vorlage-${esc(v.id)}"><span><b>${esc(v.name)}</b>
|
||||
<span class="unter">${v.art === "muster" ? "Musterposition" : "Mengenvorlage"}${v.einheit ? `, Menge in ${esc(v.einheit)}` : ""}${v.beschreibung ? ` · ${esc(v.beschreibung)}` : ""}</span></span>
|
||||
<span class="marken"><span class="marke ${v.fest ? "grau" : "gut"}">${v.fest ? "mitgeliefert" : "eigene"}</span></span></a></li>`).join("")}</ul>`).join("") || '<p class="hinweis leer">Nichts gefunden.</p>'}`;
|
||||
};
|
||||
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<HTMLInputElement>(".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<Zeile>("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}`;
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user