Stammdaten: Leistungen mit Ordnern und Vorkalkulation, GAEB- und DATANORM-Import, Material mit Rabatten, Angebot mit Reitern Leistungen/Material und KI-Vorschlag (0.18.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:
191
src/domain/datanorm.ts
Normal file
191
src/domain/datanorm.ts
Normal file
@@ -0,0 +1,191 @@
|
||||
// DATANORM 4 und 5 lesen (Artikel- und Preisdateien der Händler): Satzarten mit Semikolon getrennt.
|
||||
// A = Artikel, B = Zusatzdaten (EAN, Warengruppe), P = Preisänderung, R = Rabattgruppe (.RAB), V = Vorlauf.
|
||||
// Preise stehen ohne Komma mit zwei Nachkommastellen, die Preiseinheit als Schlüssel 0–3 (1, 10, 100, 1000 Stück).
|
||||
// Gegen echte Dateien von Hennings Händlern noch zu prüfen; unbekannte Satzarten werden übersprungen.
|
||||
import { gaebEinheit } from "./gaeb.js";
|
||||
|
||||
export interface DnArtikel {
|
||||
artikelnummer: string;
|
||||
bezeichnung: string;
|
||||
langtext?: string | null;
|
||||
einheit: string | null;
|
||||
preiseinheit: 1 | 10 | 100 | 1000;
|
||||
preisart: "brutto" | "netto";
|
||||
/** Cent je Preiseinheit */
|
||||
listenpreis: number | null;
|
||||
rabattgruppe: string | null;
|
||||
warengruppe: string | null;
|
||||
ean: string | null;
|
||||
/** L im Satz: Artikel entfällt */
|
||||
loeschen?: boolean;
|
||||
}
|
||||
|
||||
export interface DnPreis {
|
||||
artikelnummer: string;
|
||||
preisart: "brutto" | "netto";
|
||||
/** Cent je Preiseinheit */
|
||||
preis: number;
|
||||
/** Rabatt aus dem P-Satz in % (falls angegeben) */
|
||||
rabatt: number | null;
|
||||
}
|
||||
|
||||
export interface DnRabatt {
|
||||
rabattgruppe: string;
|
||||
rabatt: number;
|
||||
bezeichnung: string | null;
|
||||
}
|
||||
|
||||
export interface Datanorm {
|
||||
version: string | null;
|
||||
/** Datum der Preisliste (JJJJ-MM-TT) */
|
||||
stand: string | null;
|
||||
/** Text aus dem Vorlaufsatz, meist der Händlername */
|
||||
absender: string | null;
|
||||
artikel: DnArtikel[];
|
||||
preise: DnPreis[];
|
||||
rabatte: DnRabatt[];
|
||||
/** übersprungene Zeilen (unbekannte Satzart oder unlesbar) */
|
||||
uebersprungen: number;
|
||||
}
|
||||
|
||||
const PREISEINHEIT: Record<string, 1 | 10 | 100 | 1000> = { "0": 1, "1": 10, "2": 100, "3": 1000, "10": 10, "100": 100, "1000": 1000 };
|
||||
|
||||
/** Betrag „12345“ = 123,45 €, „123,45“ oder „123.45“ als Euro; Ergebnis in Cent */
|
||||
export function dnBetrag(t: string | undefined): number | null {
|
||||
const s = (t ?? "").trim();
|
||||
if (!s) return null;
|
||||
if (/[.,]/.test(s)) {
|
||||
const n = Number(s.includes(",") ? s.replace(/\./g, "").replace(",", ".") : s);
|
||||
return Number.isFinite(n) ? Math.round(n * 100) : null;
|
||||
}
|
||||
const n = Number(s);
|
||||
return Number.isFinite(n) ? Math.round(n) : null;
|
||||
}
|
||||
|
||||
/** Rabatt „3500“ = 35 %, „35,00“ = 35 % */
|
||||
export function dnProzent(t: string | undefined): number | null {
|
||||
const s = (t ?? "").trim();
|
||||
if (!s) return null;
|
||||
const n = /[.,]/.test(s) ? Number(s.replace(",", ".")) : Number(s) / 100;
|
||||
return Number.isFinite(n) && n >= 0 && n <= 100 ? Math.round(n * 100) / 100 : null;
|
||||
}
|
||||
|
||||
function datum(t: string | undefined): string | null {
|
||||
const s = (t ?? "").trim();
|
||||
let m = /^(\d{2})(\d{2})(\d{2})$/.exec(s);
|
||||
if (m) return `20${m[3]}-${m[2]}-${m[1]}`;
|
||||
m = /^(\d{2})(\d{2})(\d{4})$/.exec(s);
|
||||
if (m) return `${m[3]}-${m[2]}-${m[1]}`;
|
||||
m = /^(\d{4})(\d{2})(\d{2})$/.exec(s);
|
||||
if (m && Number(m[2]) <= 12) return `${m[1]}-${m[2]}-${m[3]}`;
|
||||
m = /^(\d{2})\.(\d{2})\.(\d{2,4})$/.exec(s);
|
||||
if (m) return `${m[3]!.length === 2 ? `20${m[3]}` : m[3]}-${m[2]}-${m[1]}`;
|
||||
return null;
|
||||
}
|
||||
|
||||
export function dnEinheit(t: string | undefined): string | null {
|
||||
const s = (t ?? "").trim();
|
||||
if (!s) return null;
|
||||
const k = s.toLowerCase();
|
||||
if (["pak", "pck", "pkt", "paket"].includes(k)) return "Pck";
|
||||
if (["krt", "karton"].includes(k)) return "Krt";
|
||||
if (["rol", "rll", "rolle"].includes(k)) return "Rol";
|
||||
if (["sa", "sack"].includes(k)) return "Sack";
|
||||
if (["l", "ltr", "liter"].includes(k)) return "l";
|
||||
return gaebEinheit(s);
|
||||
}
|
||||
|
||||
/** Liest eine oder mehrere DATANORM-Dateien (Text schon dekodiert, siehe kodierung.ts) */
|
||||
export function leseDatanorm(texte: string[]): Datanorm {
|
||||
const aus: Datanorm = { version: null, stand: null, absender: null, artikel: [], preise: [], rabatte: [], uebersprungen: 0 };
|
||||
const nachNummer = new Map<string, DnArtikel>();
|
||||
let zeilenGesamt = 0, mitSemikolon = 0;
|
||||
for (const text of texte) {
|
||||
for (const roh of text.split(/\r?\n/)) {
|
||||
const zeile = roh.replace(/\s+$/, "");
|
||||
if (!zeile) continue;
|
||||
zeilenGesamt++;
|
||||
if (!zeile.includes(";")) { aus.uebersprungen++; continue; }
|
||||
mitSemikolon++;
|
||||
const f = zeile.split(";");
|
||||
const art = f[0]!.trim().toUpperCase();
|
||||
try {
|
||||
if (art === "V") {
|
||||
aus.version ??= (f[1] ?? "").trim() || null;
|
||||
for (const x of f.slice(1)) { const d = datum(x); if (d) { aus.stand ??= d; break; } }
|
||||
aus.absender ??= f.slice(2).map((x) => x.trim()).find((x) => x && !/^\d+$/.test(x) && !datum(x)) ?? null;
|
||||
} else if (art === "A") {
|
||||
const nr = (f[2] ?? "").trim();
|
||||
if (!nr) { aus.uebersprungen++; continue; }
|
||||
const a: DnArtikel = {
|
||||
artikelnummer: nr,
|
||||
bezeichnung: [f[4], f[5]].map((x) => (x ?? "").trim()).filter(Boolean).join(" ") || nr,
|
||||
einheit: dnEinheit(f[8]),
|
||||
preiseinheit: PREISEINHEIT[(f[7] ?? "").trim()] ?? 1,
|
||||
preisart: (f[6] ?? "").trim() === "2" ? "netto" : "brutto",
|
||||
listenpreis: dnBetrag(f[9]),
|
||||
rabattgruppe: (f[10] ?? "").trim() || null,
|
||||
warengruppe: (f[11] ?? "").trim() || null,
|
||||
ean: null,
|
||||
loeschen: (f[1] ?? "").trim().toUpperCase() === "L",
|
||||
};
|
||||
const alt = nachNummer.get(nr);
|
||||
if (alt) Object.assign(alt, { ...a, ean: alt.ean, warengruppe: a.warengruppe ?? alt.warengruppe });
|
||||
else { nachNummer.set(nr, a); aus.artikel.push(a); }
|
||||
} else if (art === "B") {
|
||||
const a = nachNummer.get((f[2] ?? "").trim());
|
||||
if (!a) continue;
|
||||
const ean = f.slice(4, 12).map((x) => x.trim()).find((x) => /^\d{8}$|^\d{12,14}$/.test(x));
|
||||
if (ean) a.ean = ean;
|
||||
const wg = (f[10] ?? "").trim();
|
||||
if (wg && !/^\d{8,}$/.test(wg)) a.warengruppe = wg;
|
||||
} else if (art === "D") {
|
||||
// Langtextzeilen: D;N;Artikelnummer;Zeile;Text;Zeile;Text
|
||||
const a = nachNummer.get((f[2] ?? "").trim());
|
||||
if (!a) continue;
|
||||
const text = [f[4], f[6]].map((x) => (x ?? "").trim()).filter(Boolean).join("\n");
|
||||
if (text) a.langtext = a.langtext ? `${a.langtext}\n${text}` : text;
|
||||
} else if (art === "P") {
|
||||
// bis zu drei Artikel je Satz: Artikelnummer; Preiskennzeichen; Preis; Rabattkennzeichen; Rabatt 1–3
|
||||
for (let i = 2; i + 2 < f.length; i += 7) {
|
||||
const nr = (f[i] ?? "").trim();
|
||||
const preis = dnBetrag(f[i + 2]);
|
||||
if (!nr || preis === null) continue;
|
||||
aus.preise.push({ artikelnummer: nr, preisart: (f[i + 1] ?? "").trim() === "2" ? "netto" : "brutto", preis, rabatt: (f[i + 3] ?? "").trim() === "1" ? dnProzent(f[i + 4]) : null });
|
||||
}
|
||||
} else if (art === "R") {
|
||||
// R;A;Rabattgruppe;Rabattkennzeichen;Rabatt;Bezeichnung
|
||||
const rg = (f[2] ?? "").trim();
|
||||
const kz = (f[3] ?? "").trim();
|
||||
let rabatt = dnProzent(f[4]);
|
||||
// Kennzeichen 2/3: Multiplikator (z. B. 0,65 = 35 % Rabatt)
|
||||
if ((kz === "2" || kz === "3") && rabatt !== null) {
|
||||
const m = /[.,]/.test(f[4]!) ? Number(f[4]!.replace(",", ".")) : Number(f[4]) / 1000;
|
||||
rabatt = Number.isFinite(m) && m > 0 && m <= 1 ? Math.round((1 - m) * 10000) / 100 : rabatt;
|
||||
}
|
||||
if (rg && rabatt !== null) aus.rabatte.push({ rabattgruppe: rg, rabatt, bezeichnung: (f[5] ?? "").trim() || null });
|
||||
} else aus.uebersprungen++;
|
||||
} catch {
|
||||
aus.uebersprungen++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (zeilenGesamt > 0 && mitSemikolon === 0) {
|
||||
throw new Error("Die Datei sieht nach DATANORM 3 (feste Spaltenbreite) aus. Bitte beim Händler DATANORM 4 oder 5 anfordern.");
|
||||
}
|
||||
if (!aus.artikel.length && !aus.preise.length && !aus.rabatte.length) throw new Error("In den Dateien stehen keine DATANORM-Artikel, Preise oder Rabattgruppen.");
|
||||
return aus;
|
||||
}
|
||||
|
||||
/** EK netto in Cent je Preiseinheit */
|
||||
export function ekNetto(listenpreis: number | null, preisart: "brutto" | "netto", rabatt: number | null | undefined): number | null {
|
||||
if (listenpreis === null) return null;
|
||||
if (preisart === "netto") return listenpreis;
|
||||
return Math.round(listenpreis * (1 - (rabatt ?? 0) / 100));
|
||||
}
|
||||
|
||||
/** EK in Cent je Einheit (für die Kalkulation), Preiseinheit umgerechnet */
|
||||
export function ekJeEinheit(a: { ek?: number | string | null; preiseinheit?: number | string | null }): number | null {
|
||||
if (a.ek === null || a.ek === undefined || a.ek === "") return null;
|
||||
return Math.round(Number(a.ek) / Number(a.preiseinheit || 1));
|
||||
}
|
||||
92
src/domain/gaeb.ts
Normal file
92
src/domain/gaeb.ts
Normal file
@@ -0,0 +1,92 @@
|
||||
// GAEB DA XML (3.x) lesen: Leistungsverzeichnis mit Titeln (BoQCtgy) und Positionen (Item), z. B. .x81, .x83,
|
||||
// .x84, .x86. Aus den Titeln werden Ordner der Stammdaten, aus den Positionen Leistungen mit OZ, Kurztext,
|
||||
// Langtext, Einheit und, wenn vorhanden, Einheitspreis. GAEB 90 und GAEB 2000 (.d8x/.p8x) sind keine XML-Dateien.
|
||||
import { type XmlElement, absatzText, elemente, kind, leseXml, pfad, textVon } from "./xml.js";
|
||||
import { einheitRichtig } from "./kalkulation.js";
|
||||
|
||||
export interface GaebPosition {
|
||||
oz: string;
|
||||
/** Titelpfad, z. B. „03 Konstruktionen / 03.01 Dachstuhl“ */
|
||||
ordner: string;
|
||||
kurztext: string;
|
||||
langtext: string;
|
||||
einheit: string;
|
||||
menge: number | null;
|
||||
/** Einheitspreis in Cent (nur Dateien mit Preisen, z. B. .x84/.x86) */
|
||||
ep: number | null;
|
||||
art: "normal" | "eventual" | "alternativ";
|
||||
}
|
||||
|
||||
export interface GaebLv {
|
||||
name: string;
|
||||
/** Datenaustauschphase, z. B. 81, 83, 84 */
|
||||
phase: string | null;
|
||||
positionen: GaebPosition[];
|
||||
titel: number;
|
||||
}
|
||||
|
||||
/** Einheiten aus GAEB (m2, Stck, lfm …) wie im Programm */
|
||||
export function gaebEinheit(qu: string): string {
|
||||
const t = qu.trim();
|
||||
const klein = t.toLowerCase().replace(/\.$/, "");
|
||||
const tabelle: Record<string, string> = {
|
||||
m2: "m²", qm: "m²", "m²": "m²", m3: "m³", cbm: "m³", "m³": "m³", m: "m", lfm: "m", lm: "m",
|
||||
st: "St", stk: "St", stck: "St", stück: "St", "stk.": "St", psch: "psch", pauschal: "psch", pausch: "psch",
|
||||
h: "h", std: "h", kg: "kg", t: "t",
|
||||
};
|
||||
return tabelle[klein] ?? einheitRichtig(t) ?? t;
|
||||
}
|
||||
|
||||
const zahl = (t: string | undefined) => {
|
||||
if (!t?.trim()) return null;
|
||||
const n = Number(t.trim().replace(",", "."));
|
||||
return Number.isFinite(n) ? n : null;
|
||||
};
|
||||
|
||||
export function leseGaeb(text: string): GaebLv {
|
||||
if (!/<\s*([\w-]+:)?GAEB[\s>]/.test(text.slice(0, 5000))) {
|
||||
throw new Error("Das ist keine GAEB-XML-Datei. Bitte das Leistungsverzeichnis als GAEB DA XML exportieren (Endung .x81, .x83 oder .x84).");
|
||||
}
|
||||
const gaeb = leseXml(text);
|
||||
const award = kind(gaeb, "Award");
|
||||
const boq = kind(award, "BoQ");
|
||||
if (!boq) throw new Error("In der GAEB-Datei steht kein Leistungsverzeichnis (BoQ).");
|
||||
const name = textVon(pfad(boq, "BoQInfo", "Name")) || textVon(pfad(boq, "BoQInfo", "LblBoQ")) || textVon(pfad(gaeb, "PrjInfo", "LblPrj")) || textVon(pfad(gaeb, "PrjInfo", "NamePrj")) || "GAEB";
|
||||
const phase = textVon(kind(award, "DP")) || null;
|
||||
const positionen: GaebPosition[] = [];
|
||||
let titel = 0;
|
||||
|
||||
const koerper = (body: XmlElement | undefined, oz: string[], ordner: string[]) => {
|
||||
if (!body) return;
|
||||
for (const c of elemente(body, "BoQCtgy")) {
|
||||
titel++;
|
||||
const nr = c.attr.RNoPart ?? "";
|
||||
const bez = absatzText(kind(c, "LblTx")).split("\n")[0] || "Titel";
|
||||
const ozNeu = [...oz, nr].filter(Boolean);
|
||||
koerper(kind(c, "BoQBody"), ozNeu, [...ordner, [ozNeu.join("."), bez].filter(Boolean).join(" ")]);
|
||||
}
|
||||
for (const liste of elemente(body, "Itemlist")) {
|
||||
for (const it of elemente(liste, "Item")) {
|
||||
const ct = pfad(it, "Description", "CompleteText");
|
||||
const kurz = absatzText(pfad(ct, "OutlineText", "OutlTxt", "TextOutlTxt")) || absatzText(pfad(ct, "OutlineText", "OutlTxt"));
|
||||
const lang = absatzText(pfad(ct, "DetailTxt", "Text")) || absatzText(kind(ct, "DetailTxt"));
|
||||
const provis = textVon(kind(it, "Provis"));
|
||||
const ozPos = [...oz, it.attr.RNoPart ?? ""].filter(Boolean).join(".");
|
||||
const up = zahl(textVon(kind(it, "UP")));
|
||||
positionen.push({
|
||||
oz: ozPos,
|
||||
ordner: ordner.join(" / "),
|
||||
kurztext: (kurz || lang.split("\n")[0] || `Position ${ozPos}`).replace(/\n/g, " ").slice(0, 300),
|
||||
langtext: lang,
|
||||
einheit: gaebEinheit(textVon(kind(it, "QU"))),
|
||||
menge: zahl(textVon(kind(it, "Qty"))),
|
||||
ep: up === null ? null : Math.round(up * 100),
|
||||
art: provis ? "eventual" : kind(it, "ALNSerNo") && textVon(kind(it, "ALNSerNo")) !== "0" ? "alternativ" : "normal",
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
koerper(kind(boq, "BoQBody"), [], []);
|
||||
if (!positionen.length) throw new Error("In der GAEB-Datei stehen keine Positionen.");
|
||||
return { name, phase, positionen, titel };
|
||||
}
|
||||
43
src/domain/ki.ts
Normal file
43
src/domain/ki.ts
Normal file
@@ -0,0 +1,43 @@
|
||||
// KI-Vorschlag im Angebot (Henning, 21.10.2026): Aus einer Beschreibung der Arbeiten schlägt Claude Leistungen
|
||||
// vor, aber nur aus seinen Stammdaten, mit Menge. Er hakt an, was er übernehmen will.
|
||||
|
||||
export interface KiLeistung { id: string; kurztext: string; einheit: string | null; ordner: string; nummer?: string | null }
|
||||
export interface KiVorschlag { id: string; menge: number | null; grund: string }
|
||||
|
||||
/** Anfrage an Claude: Aufgabe, die erlaubten Leistungen und das Antwortformat */
|
||||
export function kiAnfrage(aufgabe: string, leistungen: KiLeistung[]): string {
|
||||
const liste = leistungen.map((l) => `${l.id} | ${l.ordner} | ${l.kurztext} | ${l.einheit ?? ""}`).join("\n");
|
||||
return `Du hilfst einem Zimmereibetrieb, ein Angebot zusammenzustellen. Wähle aus der Liste der Leistungen die passenden aus.
|
||||
Regeln:
|
||||
- Nur Leistungen aus der Liste, mit ihrer id genau wie angegeben. Erfinde keine Leistungen.
|
||||
- Schätze die Menge in der Einheit der Leistung aus der Beschreibung; wenn sie sich nicht ableiten lässt, menge null.
|
||||
- grund: ein kurzer deutscher Satz, warum die Leistung passt oder wie die Menge entsteht.
|
||||
- Höchstens 25 Vorschläge, in sinnvoller Reihenfolge des Bauablaufs.
|
||||
Antworte nur mit JSON: [{"id": "...", "menge": 12.5, "grund": "..."}]
|
||||
|
||||
Beschreibung der Arbeiten:
|
||||
${aufgabe.trim()}
|
||||
|
||||
Leistungen (id | Ordner | Kurztext | Einheit):
|
||||
${liste}`;
|
||||
}
|
||||
|
||||
/** Antwort prüfen: nur bekannte ids, Mengen als Zahl ≥ 0, doppelte weg */
|
||||
export function kiVorschlaege(antwort: unknown, erlaubt: Set<string>): KiVorschlag[] {
|
||||
let wert = antwort;
|
||||
if (typeof wert === "string") {
|
||||
const json = /\[[\s\S]*\]/.exec(wert)?.[0];
|
||||
try { wert = json ? JSON.parse(json) : []; } catch { wert = []; }
|
||||
}
|
||||
if (!Array.isArray(wert)) return [];
|
||||
const gesehen = new Set<string>();
|
||||
const aus: KiVorschlag[] = [];
|
||||
for (const x of wert as Record<string, unknown>[]) {
|
||||
const id = String(x?.id ?? "");
|
||||
if (!erlaubt.has(id) || gesehen.has(id)) continue;
|
||||
gesehen.add(id);
|
||||
const m = typeof x.menge === "number" ? x.menge : typeof x.menge === "string" ? Number(x.menge.replace(",", ".")) : NaN;
|
||||
aus.push({ id, menge: Number.isFinite(m) && m >= 0 ? Math.round(m * 1000) / 1000 : null, grund: String(x.grund ?? "").slice(0, 300) });
|
||||
}
|
||||
return aus.slice(0, 25);
|
||||
}
|
||||
38
src/domain/kodierung.ts
Normal file
38
src/domain/kodierung.ts
Normal file
@@ -0,0 +1,38 @@
|
||||
// Zeichensatz von Importdateien erkennen: GAEB-XML nennt ihn in der ersten Zeile, DATANORM ist meist im alten
|
||||
// DOS-Zeichensatz (Codepage 850), manchmal Windows-1252 oder UTF-8. Codepage 850 kennt TextDecoder nicht.
|
||||
|
||||
const CP850 =
|
||||
"ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñѪº¿®¬½¼¡«»░▒▓│┤ÁÂÀ©╣║╗╝¢¥┐└┴┬├─┼ãÃ╚╔╩╦╠═╬¤ðÐÊËÈıÍÎÏ┘┌█▄¦Ì▀ÓßÔÒõÕµþÞÚÛÙýݯ´±‗¾¶§÷¸°¨·¹³²■ ";
|
||||
|
||||
export function cp850(bytes: Uint8Array): string {
|
||||
let s = "";
|
||||
for (let i = 0; i < bytes.length; i += 8192) {
|
||||
const teil = bytes.subarray(i, i + 8192);
|
||||
s += Array.from(teil, (b) => (b < 128 ? String.fromCharCode(b) : CP850[b - 128]!)).join("");
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
function utf8(bytes: Uint8Array): string | null {
|
||||
try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); } catch { return null; }
|
||||
}
|
||||
|
||||
/** Text einer Datei: UTF-8, sonst Codepage 850 oder Windows-1252, je nachdem, wo Umlaute plausibler sind */
|
||||
export function dateiText(bytes: Uint8Array): string {
|
||||
// GAEB-XML: Kodierung aus der XML-Deklaration
|
||||
const anfang = new TextDecoder("latin1").decode(bytes.subarray(0, 200));
|
||||
const dekl = /<\?xml[^>]*encoding=["']([^"']+)["']/i.exec(anfang);
|
||||
if (dekl) {
|
||||
const k = dekl[1]!.toLowerCase();
|
||||
if (k === "utf-8" || k === "utf8") return utf8(bytes) ?? new TextDecoder("windows-1252").decode(bytes);
|
||||
try { return new TextDecoder(k).decode(bytes); } catch { /* unbekannt: raten */ }
|
||||
}
|
||||
const u = utf8(bytes);
|
||||
if (u !== null) return u.replace(/^/, "");
|
||||
let dos = 0, win = 0;
|
||||
for (const b of bytes) {
|
||||
if (b === 0x81 || b === 0x84 || b === 0x94 || b === 0x8e || b === 0x99 || b === 0x9a || b === 0xe1) dos++;
|
||||
else if (b === 0xe4 || b === 0xf6 || b === 0xfc || b === 0xc4 || b === 0xd6 || b === 0xdc || b === 0xdf) win++;
|
||||
}
|
||||
return dos > win ? cp850(bytes) : new TextDecoder("windows-1252").decode(bytes);
|
||||
}
|
||||
@@ -19,6 +19,8 @@ export interface Ansatz {
|
||||
ek?: number | null;
|
||||
faktor?: number;
|
||||
aktiv?: boolean;
|
||||
/** Artikel aus dem Materialstamm: EK je Einheit und Einheit kommen von dort */
|
||||
artikel_id?: string | null;
|
||||
}
|
||||
|
||||
export interface Mengenvorlage {
|
||||
@@ -34,6 +36,13 @@ export interface Mengenvorlage {
|
||||
/** mitgeliefert, nicht änderbar */
|
||||
fest?: boolean;
|
||||
reihenfolge?: number;
|
||||
/** Leistungen (Stammdaten): OZ, Herkunft, „Preis festlegen auf“ in Cent, Importdatei */
|
||||
nummer?: string | null;
|
||||
herkunft?: "eigen" | "gaeb" | "plancraft";
|
||||
ep_fest?: number | string | null;
|
||||
quelle?: string | null;
|
||||
notiz?: string | null;
|
||||
geaendert_am?: string;
|
||||
}
|
||||
|
||||
const e = (kz: string, bez: string, einheit: string, formel: string): BlattWert => ({ kz, bez, einheit, formel, eingabe: true });
|
||||
|
||||
112
src/domain/xml.ts
Normal file
112
src/domain/xml.ts
Normal file
@@ -0,0 +1,112 @@
|
||||
// Kleiner XML-Leser ohne Abhängigkeiten, für GAEB DA XML. Kennt Elemente, Attribute, Text, CDATA und die
|
||||
// üblichen Entitäten; Kommentare, Verarbeitungsanweisungen und DOCTYPE werden übersprungen.
|
||||
// Namensräume fallen weg: aus <g:Item> wird „Item“.
|
||||
|
||||
export interface XmlElement {
|
||||
name: string;
|
||||
attr: Record<string, string>;
|
||||
kinder: XmlKnoten[];
|
||||
}
|
||||
export type XmlKnoten = XmlElement | string;
|
||||
|
||||
const ENTITAETEN: Record<string, string> = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'", nbsp: " " };
|
||||
|
||||
export function entschluesseln(t: string): string {
|
||||
return t.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (ganz, e: string) => {
|
||||
if (e[0] === "#") {
|
||||
const n = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
|
||||
return Number.isFinite(n) ? String.fromCodePoint(n) : ganz;
|
||||
}
|
||||
return ENTITAETEN[e] ?? ganz;
|
||||
});
|
||||
}
|
||||
|
||||
const ohnePraefix = (n: string) => n.slice(n.indexOf(":") + 1);
|
||||
|
||||
/** Liest ein XML-Dokument und gibt das Wurzelelement zurück */
|
||||
export function leseXml(text: string): XmlElement {
|
||||
const wurzel: XmlElement = { name: "#dokument", attr: {}, kinder: [] };
|
||||
const stapel: XmlElement[] = [wurzel];
|
||||
let i = 0;
|
||||
const n = text.length;
|
||||
while (i < n) {
|
||||
const lt = text.indexOf("<", i);
|
||||
if (lt < 0) { stapel[stapel.length - 1]!.kinder.push(entschluesseln(text.slice(i))); break; }
|
||||
if (lt > i) stapel[stapel.length - 1]!.kinder.push(entschluesseln(text.slice(i, lt)));
|
||||
if (text.startsWith("<!--", lt)) { const e = text.indexOf("-->", lt + 4); i = e < 0 ? n : e + 3; continue; }
|
||||
if (text.startsWith("<![CDATA[", lt)) {
|
||||
const e = text.indexOf("]]>", lt + 9);
|
||||
stapel[stapel.length - 1]!.kinder.push(text.slice(lt + 9, e < 0 ? n : e));
|
||||
i = e < 0 ? n : e + 3;
|
||||
continue;
|
||||
}
|
||||
if (text.startsWith("<?", lt)) { const e = text.indexOf("?>", lt + 2); i = e < 0 ? n : e + 2; continue; }
|
||||
if (text.startsWith("<!", lt)) {
|
||||
// DOCTYPE, ggf. mit [ … ]
|
||||
let tiefe = 0, j = lt + 2;
|
||||
for (; j < n; j++) { const c = text[j]; if (c === "[") tiefe++; else if (c === "]") tiefe--; else if (c === ">" && tiefe <= 0) break; }
|
||||
i = j + 1;
|
||||
continue;
|
||||
}
|
||||
// Ende des Tags finden, Anführungszeichen beachten
|
||||
let j = lt + 1, quote = "";
|
||||
for (; j < n; j++) {
|
||||
const c = text[j]!;
|
||||
if (quote) { if (c === quote) quote = ""; } else if (c === '"' || c === "'") quote = c; else if (c === ">") break;
|
||||
}
|
||||
if (j >= n) throw new Error("Die XML-Datei ist unvollständig (ein Tag endet nicht).");
|
||||
const tag = text.slice(lt + 1, j);
|
||||
i = j + 1;
|
||||
if (tag.startsWith("/")) {
|
||||
const name = ohnePraefix(tag.slice(1).trim());
|
||||
// bis zum passenden offenen Element schließen (verzeiht fehlerhafte Verschachtelung)
|
||||
for (let k = stapel.length - 1; k > 0; k--) if (stapel[k]!.name === name) { stapel.length = k; break; }
|
||||
continue;
|
||||
}
|
||||
const leer = tag.endsWith("/");
|
||||
const inhalt = leer ? tag.slice(0, -1) : tag;
|
||||
const m = /^\s*([^\s/>]+)/.exec(inhalt);
|
||||
if (!m) continue;
|
||||
const el: XmlElement = { name: ohnePraefix(m[1]!), attr: {}, kinder: [] };
|
||||
const re = /([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
|
||||
let a: RegExpExecArray | null;
|
||||
const rest = inhalt.slice(m[0].length);
|
||||
while ((a = re.exec(rest))) el.attr[ohnePraefix(a[1]!)] = entschluesseln(a[3] ?? a[4] ?? "");
|
||||
stapel[stapel.length - 1]!.kinder.push(el);
|
||||
if (!leer) stapel.push(el);
|
||||
}
|
||||
const erstes = wurzel.kinder.find((k): k is XmlElement => typeof k !== "string");
|
||||
if (!erstes) throw new Error("Die Datei enthält kein XML.");
|
||||
return erstes;
|
||||
}
|
||||
|
||||
export const elemente = (e: XmlElement, name?: string): XmlElement[] =>
|
||||
e.kinder.filter((k): k is XmlElement => typeof k !== "string" && (!name || k.name === name));
|
||||
export const kind = (e: XmlElement | undefined, name: string): XmlElement | undefined => (e ? elemente(e, name)[0] : undefined);
|
||||
/** Pfad aus Kindnamen, z. B. pfad(item, "Description", "CompleteText") */
|
||||
export const pfad = (e: XmlElement | undefined, ...namen: string[]): XmlElement | undefined => namen.reduce<XmlElement | undefined>((x, n) => kind(x, n), e);
|
||||
|
||||
/** reiner Text eines Elements, Leerraum zusammengefasst */
|
||||
export function textVon(e: XmlElement | undefined): string {
|
||||
if (!e) return "";
|
||||
const teile: string[] = [];
|
||||
const lauf = (x: XmlKnoten) => { if (typeof x === "string") teile.push(x); else x.kinder.forEach(lauf); };
|
||||
lauf(e);
|
||||
return teile.join("").replace(/\s+/g, " ").trim();
|
||||
}
|
||||
|
||||
/** Fließtext aus <p>, <br>, <span> (GAEB-Texte): Absätze als Zeilenumbruch */
|
||||
export function absatzText(e: XmlElement | undefined): string {
|
||||
if (!e) return "";
|
||||
let aus = "";
|
||||
const lauf = (x: XmlKnoten) => {
|
||||
if (typeof x === "string") { aus += x.replace(/\s+/g, " "); return; }
|
||||
if (x.name === "br") { aus += "\n"; return; }
|
||||
const block = x.name === "p" || x.name === "div" || x.name === "li";
|
||||
if (block && aus && !aus.endsWith("\n")) aus += "\n";
|
||||
x.kinder.forEach(lauf);
|
||||
if (block && !aus.endsWith("\n")) aus += "\n";
|
||||
};
|
||||
lauf(e);
|
||||
return aus.split("\n").map((z) => z.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
|
||||
}
|
||||
@@ -9,7 +9,8 @@ import { mitNeuplanung } from "./terminplan.js";
|
||||
import { werName } from "./anmeldung.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 type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
import { hatBlatt, vorlagen } from "./leistungen-daten.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsterArbeitstag } from "../domain/kalender.js";
|
||||
|
||||
@@ -130,11 +131,6 @@ async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void
|
||||
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<Pool, "query">): Promise<Mengenvorlage[]> {
|
||||
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“):
|
||||
@@ -173,6 +169,8 @@ const EinfuegenSchema = z.object({
|
||||
position_id: z.uuid().optional(),
|
||||
/** Eingaben der Vorlage, beim Einfügen abgefragt */
|
||||
eingaben: z.record(z.string().max(40), z.string().max(500)).default({}),
|
||||
/** Menge statt der aus dem Mengenblatt (KI-Vorschlag) */
|
||||
menge: z.number().min(0).max(1e9).optional(),
|
||||
});
|
||||
|
||||
export function registriereAngebote(
|
||||
@@ -311,10 +309,13 @@ export function registriereAngebote(
|
||||
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];
|
||||
// Leistungen aus GAEB haben oft kein Mengenblatt: dann zählt die eingetragene Menge; das Blatt merkt sich die Herkunft
|
||||
const mitBlatt = hatBlatt(vorlageBlatt);
|
||||
const menge = q.menge ?? (mitBlatt ? werteBlatt(vorlageBlatt, umg).menge ?? 1 : 1);
|
||||
const p = (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, langtext, menge, einheit, mit_kalkulation, mit_aufmass, aufmass, ep_fest)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning id`,
|
||||
[id, ort.titel_id, ort.reihenfolge, v.kurztext || v.name, v.langtext || null, menge, v.einheit || "St", ansaetze.length > 0, mitBlatt && q.menge === undefined, vorlageBlatt,
|
||||
v.ep_fest === null || v.ep_fest === undefined || v.ep_fest === "" ? null : Number(v.ep_fest)])).rows[0];
|
||||
await ansaetzeEinfuegen(c, p.id, ansaetze, 0);
|
||||
return p;
|
||||
});
|
||||
|
||||
@@ -26,6 +26,7 @@ import { registriereZeiten } from "./zeiten.js";
|
||||
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
|
||||
import { registriereStammdaten } from "./stammdaten.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
import { formatDatum, plusTage } from "../domain/datum.js";
|
||||
|
||||
@@ -93,6 +94,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
}
|
||||
|
||||
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
|
||||
registriereStammdaten(app, pool, ladeEinstellungen);
|
||||
|
||||
app.post("/api/projekte/:id/ordner", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
|
||||
67
src/server/leistungen-daten.ts
Normal file
67
src/server/leistungen-daten.ts
Normal file
@@ -0,0 +1,67 @@
|
||||
// Leistungen und Mengenvorlagen aus Programm und Datenbank, mit den aktuellen Artikelpreisen aus dem Materialstamm.
|
||||
// Eine Kostenzeile mit Artikel nimmt immer den EK des Artikels: neue Preise rechnen die Leistungen neu,
|
||||
// Angebote behalten ihre Preise, weil die Kostenzeilen dort beim Einfügen festgeschrieben werden.
|
||||
import type { Pool } from "./db.js";
|
||||
import type { Einstellungen } from "./einstellungen.js";
|
||||
import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js";
|
||||
import { type KKosten, type PositionErgebnis, type Saetze, berechnePosition, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
|
||||
import { ekJeEinheit } from "../domain/datanorm.js";
|
||||
|
||||
export interface ArtikelKurz { id: string; lieferant: string; artikelnummer: string; bezeichnung: string; einheit: string | null; ek: number | null; ek_je_einheit: number | null; preiseinheit: number; herkunft: string; stand: string | null }
|
||||
|
||||
/** Alle Vorlagen: mitgelieferte und eigene; Artikel-EK eingesetzt */
|
||||
export async function vorlagen(c: Pick<Pool, "query">): Promise<Mengenvorlage[]> {
|
||||
const eigene = (await c.query("select * from mengenvorlage order by gruppe, reihenfolge, name")).rows as Mengenvorlage[];
|
||||
const alle = [...STANDARD_VORLAGEN, ...eigene.map((v) => ({ ...v, fest: false }))];
|
||||
const ids = [...new Set(alle.flatMap((v) => (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x)))];
|
||||
if (!ids.length) return alle;
|
||||
const art = await artikelNach(c, ids);
|
||||
return alle.map((v) => ({
|
||||
...v,
|
||||
inhalt: { ...v.inhalt, ansaetze: (v.inhalt.ansaetze ?? []).map((z) => {
|
||||
const a = z.artikel_id ? art.get(z.artikel_id) : undefined;
|
||||
return a ? { ...z, ek: a.ek_je_einheit ?? z.ek ?? null, einheit: z.einheit || a.einheit } : z;
|
||||
}) },
|
||||
}));
|
||||
}
|
||||
|
||||
export async function artikelNach(c: Pick<Pool, "query">, ids: string[]): Promise<Map<string, ArtikelKurz>> {
|
||||
if (!ids.length) return new Map();
|
||||
const r = await c.query("select id, lieferant, artikelnummer, bezeichnung, einheit, ek, preiseinheit, herkunft, stand from artikel where id = any($1::uuid[])", [ids]);
|
||||
return new Map(r.rows.map((a) => [a.id, { ...a, ek: a.ek === null ? null : Number(a.ek), preiseinheit: Number(a.preiseinheit), ek_je_einheit: ekJeEinheit(a) }]));
|
||||
}
|
||||
|
||||
/** Sätze der Stammdaten: Vorgaben der Angebote aus den Einstellungen */
|
||||
export function stammSaetze(e: Einstellungen): Saetze {
|
||||
const k = e.kalkulation;
|
||||
return {
|
||||
stundensaetze: { ...k.stundensaetze }, zuschlaege: { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall,
|
||||
mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz,
|
||||
};
|
||||
}
|
||||
|
||||
export const hatBlatt = (b: Blatt) => b.werte.length > 0 || b.listen.length > 0 || b.zeilen.length > 0 || !!b.menge?.trim();
|
||||
|
||||
/** Vorkalkulation einer Leistung wie eine Position im Angebot: Menge aus dem Mengenblatt, sonst 1 */
|
||||
export function rechneLeistung(v: Mengenvorlage, s: Saetze): PositionErgebnis {
|
||||
const { ansaetze = [], ...rest } = v.inhalt;
|
||||
const blatt = alsBlatt(rest);
|
||||
const mitBlatt = hatBlatt(blatt);
|
||||
let menge = 1;
|
||||
if (mitBlatt) { try { menge = werteBlatt(blatt, umgebungVon(s)).menge ?? 1; } catch { menge = 1; } }
|
||||
const kosten: KKosten[] = ansaetze.map((z, i) => ({
|
||||
id: String(i), position_id: v.id, kostenart: z.kostenart, lohnart: z.lohnart ?? null, beschreibung: z.beschreibung ?? null, menge: z.menge,
|
||||
einheit: z.einheit ?? null, ek: z.ek ?? null, faktor: z.faktor ?? 1, bezug: z.bezug ?? null, personen: z.personen ?? 1, aktiv: z.aktiv ?? true, reihenfolge: i,
|
||||
}));
|
||||
return berechnePosition({
|
||||
id: v.id, kurztext: v.kurztext || v.name, menge: menge || 1, einheit: v.einheit || "St", ep_fest: v.ep_fest ?? null,
|
||||
mit_kalkulation: ansaetze.length > 0, mit_aufmass: mitBlatt, aufmass: mitBlatt ? blatt : null,
|
||||
}, kosten, s);
|
||||
}
|
||||
|
||||
/** Leistungen für Liste und Katalog: eine geänderte Kopie ersetzt die mitgelieferte mit gleichem Namen */
|
||||
export function nurLeistungen(alle: Mengenvorlage[]): Mengenvorlage[] {
|
||||
const eigene = new Set(alle.filter((v) => !v.fest).map((v) => `${v.gruppe}|${v.name}`));
|
||||
return alle.filter((v) => v.art === "muster" && !(v.fest && eigene.has(`${v.gruppe}|${v.name}`)));
|
||||
}
|
||||
119
src/server/migrations/017_stammdaten.sql
Normal file
119
src/server/migrations/017_stammdaten.sql
Normal file
@@ -0,0 +1,119 @@
|
||||
-- Stammdaten (Henning, 21.10.2026): Leistungen mit Ordnern aus GAEB oder selbst angelegt, Materialstamm aus
|
||||
-- DATANORM mit Rabatten je Lieferant. Leistungen sind die bisherigen Musterpositionen (mengenvorlage, art 'muster'),
|
||||
-- damit nichts doppelt existiert; der Ordner steht in „gruppe“ als Pfad mit „ / “.
|
||||
|
||||
-- Beim Einspielen einer Sicherung bleiben Zeitstempel erhalten und es entsteht kein Protokoll
|
||||
create or replace function stempel_und_protokoll() returns trigger language plpgsql as $$
|
||||
declare
|
||||
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
|
||||
begin
|
||||
if current_setting('betrieb.einspielen', true) = 'ja' then
|
||||
if tg_op = 'DELETE' then return old; end if;
|
||||
new.angelegt_am := coalesce(new.angelegt_am, now());
|
||||
new.geaendert_am := coalesce(new.geaendert_am, now());
|
||||
new.geaendert_von := coalesce(new.geaendert_von, wer);
|
||||
return new;
|
||||
end if;
|
||||
if tg_op = 'DELETE' then
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
|
||||
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
|
||||
return old;
|
||||
end if;
|
||||
new.geaendert_am := now();
|
||||
new.geaendert_von := wer;
|
||||
if tg_op = 'INSERT' then
|
||||
new.angelegt_am := now();
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
|
||||
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
|
||||
else
|
||||
new.angelegt_am := old.angelegt_am;
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
|
||||
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
-- Artikel ändern sich zu Tausenden mit jeder Preisliste: nur Zeitstempel, kein Protokoll
|
||||
create function nur_stempel() returns trigger language plpgsql as $$
|
||||
begin
|
||||
if current_setting('betrieb.einspielen', true) = 'ja' then
|
||||
new.angelegt_am := coalesce(new.angelegt_am, now());
|
||||
new.geaendert_am := coalesce(new.geaendert_am, now());
|
||||
return new;
|
||||
end if;
|
||||
new.geaendert_am := now();
|
||||
if tg_op = 'INSERT' then new.angelegt_am := now(); else new.angelegt_am := old.angelegt_am; end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
alter table mengenvorlage
|
||||
-- OZ aus der GAEB-Datei oder eigene Nummer
|
||||
add column nummer text,
|
||||
add column herkunft text not null default 'eigen' check (herkunft in ('eigen', 'gaeb', 'plancraft')),
|
||||
-- „Preis festlegen auf“ (Cent je Einheit); ohne Kalkulation der feste Preis
|
||||
add column ep_fest bigint check (ep_fest >= 0),
|
||||
-- Dateiname des Imports
|
||||
add column quelle text,
|
||||
add column notiz text;
|
||||
|
||||
create table artikel (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
-- leer = eigener Artikel ohne Lieferant
|
||||
lieferant text not null default '',
|
||||
artikelnummer text not null default '',
|
||||
bezeichnung text not null,
|
||||
langtext text,
|
||||
warengruppe text,
|
||||
rabattgruppe text,
|
||||
ean text,
|
||||
einheit text,
|
||||
-- Preis gilt je 1, 10, 100 oder 1000 Einheiten
|
||||
preiseinheit integer not null default 1 check (preiseinheit in (1, 10, 100, 1000)),
|
||||
-- brutto: Listenpreis, Rabatt wird abgezogen; netto: Preis ist schon der EK
|
||||
preisart text not null default 'brutto' check (preisart in ('brutto', 'netto')),
|
||||
-- Cent je Preiseinheit
|
||||
listenpreis bigint check (listenpreis >= 0),
|
||||
-- eigener Rabatt in %, sonst der Rabatt der Rabattgruppe des Lieferanten
|
||||
rabatt numeric(5, 2) check (rabatt >= 0 and rabatt <= 100),
|
||||
-- EK netto in Cent je Preiseinheit, aus Listenpreis und Rabatt gerechnet
|
||||
ek bigint check (ek >= 0),
|
||||
ek_vorher bigint,
|
||||
herkunft text not null default 'eigen' check (herkunft in ('eigen', 'datanorm')),
|
||||
-- Datum der Preisliste
|
||||
stand date,
|
||||
merkliste boolean not null default false,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now()
|
||||
);
|
||||
create unique index artikel_nummer on artikel (lieferant, artikelnummer) where artikelnummer <> '';
|
||||
create index artikel_warengruppe on artikel (lieferant, warengruppe);
|
||||
create trigger artikel_stempel before insert or update on artikel for each row execute function nur_stempel();
|
||||
|
||||
-- EK netto aus Listenpreis und Rabatt (eigener Rabatt, sonst der der Rabattgruppe); der alte EK bleibt zum Vergleich
|
||||
create function artikel_ek() returns trigger language plpgsql as $$
|
||||
begin
|
||||
if current_setting('betrieb.einspielen', true) = 'ja' then return new; end if;
|
||||
if new.listenpreis is not null then
|
||||
new.ek := case when new.preisart = 'netto' then new.listenpreis
|
||||
else round(new.listenpreis * (1 - coalesce(new.rabatt,
|
||||
(select r.rabatt from lieferant_rabatt r where r.lieferant = new.lieferant and r.rabattgruppe = new.rabattgruppe), 0) / 100)) end;
|
||||
end if;
|
||||
if tg_op = 'UPDATE' and new.ek is distinct from old.ek then new.ek_vorher := old.ek; end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
-- Rabatte je Lieferant und Rabattgruppe (DATANORM .RAB oder von Hand)
|
||||
create table lieferant_rabatt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
lieferant text not null,
|
||||
rabattgruppe text not null,
|
||||
bezeichnung text,
|
||||
rabatt numeric(5, 2) not null check (rabatt >= 0 and rabatt <= 100),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (lieferant, rabattgruppe)
|
||||
);
|
||||
create trigger lieferant_rabatt_protokoll before insert or update or delete on lieferant_rabatt
|
||||
for each row execute function stempel_und_protokoll();
|
||||
create trigger artikel_ek before insert or update on artikel for each row execute function artikel_ek();
|
||||
239
src/server/stammdaten.ts
Normal file
239
src/server/stammdaten.ts
Normal file
@@ -0,0 +1,239 @@
|
||||
// Stammdaten (Henning, 21.10.2026): Leistungen mit Vorkalkulation, GAEB-Import in Ordner, Materialstamm mit
|
||||
// DATANORM-Import und Rabatten je Lieferant. Siehe Entwürfe 1–4 in stammdaten/entwurf.
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { type Pool, transaktion } from "./db.js";
|
||||
import type { Einstellungen } from "./einstellungen.js";
|
||||
import { werName } from "./anmeldung.js";
|
||||
import { artikelNach, nurLeistungen, rechneLeistung, stammSaetze, vorlagen } from "./leistungen-daten.js";
|
||||
import { leseGaeb } from "../domain/gaeb.js";
|
||||
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
|
||||
const IdParam = z.object({ id: z.string().min(1).max(80) });
|
||||
const leeresInhalt = { werte: [], listen: [], zeilen: [], menge: null, ansaetze: [] };
|
||||
|
||||
const ArtikelImport = z.object({
|
||||
artikelnummer: z.string().trim().min(1).max(60),
|
||||
bezeichnung: z.string().trim().min(1).max(500),
|
||||
langtext: z.string().max(5000).nullable().optional(),
|
||||
einheit: z.string().max(20).nullable().optional(),
|
||||
preiseinheit: z.union([z.literal(1), z.literal(10), z.literal(100), z.literal(1000)]).default(1),
|
||||
preisart: z.enum(["brutto", "netto"]).default("brutto"),
|
||||
listenpreis: z.number().int().min(0).nullable().optional(),
|
||||
rabattgruppe: z.string().max(40).nullable().optional(),
|
||||
warengruppe: z.string().max(100).nullable().optional(),
|
||||
ean: z.string().max(20).nullable().optional(),
|
||||
loeschen: z.boolean().optional(),
|
||||
});
|
||||
const ImportSchema = z.object({
|
||||
lieferant: z.string().trim().min(1).max(100),
|
||||
stand: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
|
||||
artikel: z.array(ArtikelImport).max(5000).default([]),
|
||||
preise: z.array(z.object({ artikelnummer: z.string().trim().min(1).max(60), preisart: z.enum(["brutto", "netto"]), preis: z.number().int().min(0), rabatt: z.number().min(0).max(100).nullable() })).max(20000).default([]),
|
||||
rabatte: z.array(z.object({ rabattgruppe: z.string().trim().min(1).max(40), rabatt: z.number().min(0).max(100), bezeichnung: z.string().max(200).nullable().optional() })).max(5000).default([]),
|
||||
});
|
||||
|
||||
export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>): void {
|
||||
const wer = (req: FastifyRequest) => werName(req);
|
||||
|
||||
/** Leistungen mit Kosten, VK und Stunden je Einheit (Liste und Katalog im Angebot) */
|
||||
app.get("/api/leistungen", async () => {
|
||||
const s = stammSaetze(await einstellungen());
|
||||
return nurLeistungen(await vorlagen(pool)).map((v) => {
|
||||
const r = rechneLeistung(v, s);
|
||||
return {
|
||||
id: v.id, gruppe: v.gruppe, name: v.name, nummer: v.nummer ?? null, kurztext: v.kurztext || v.name, langtext: v.langtext ?? "", einheit: v.einheit ?? "",
|
||||
herkunft: v.fest ? "mitgeliefert" : v.herkunft ?? "eigen", fest: !!v.fest, ep_fest: v.ep_fest == null ? null : Number(v.ep_fest),
|
||||
geaendert_am: v.geaendert_am ?? null, quelle: v.quelle ?? null, zeilen: (v.inhalt.ansaetze ?? []).length,
|
||||
mit_blatt: v.inhalt.werte.length > 0 || v.inhalt.listen.length > 0,
|
||||
kosten: r.kosten_je_einheit, ep: r.ep, ep_kalkuliert: r.ep_kalkuliert, std: r.std_je_einheit,
|
||||
};
|
||||
});
|
||||
});
|
||||
|
||||
/** eine Leistung mit Vorkalkulation, Artikeln der Kostenzeilen und Verwendung in Angeboten */
|
||||
app.get("/api/leistungen/:id", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const v = (await vorlagen(pool)).find((x) => String(x.id) === id);
|
||||
if (!v) return reply.status(404).send({ fehler: "Diese Leistung gibt es nicht (mehr)." });
|
||||
const s = stammSaetze(await einstellungen());
|
||||
const artikel = Object.fromEntries(await artikelNach(pool, (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x)));
|
||||
const angebote = (await pool.query(`select a.id, a.nummer, a.datum from angebot_position p join angebot a on a.id = p.angebot_id
|
||||
where p.aufmass -> 'vorlage' ->> 'id' = $1 order by a.datum desc, a.nummer desc`, [id])).rows;
|
||||
return { leistung: v, ergebnis: rechneLeistung(v, s), saetze: s, artikel, angebote };
|
||||
});
|
||||
|
||||
/** GAEB-Datei (Text schon dekodiert) → Leistungen in Ordnern nach den Titeln. Erneutes Einlesen aktualisiert Texte. */
|
||||
app.post("/api/leistungen/gaeb", async (req, reply) => {
|
||||
const q = z.object({ dateiname: z.string().trim().min(1).max(200), text: z.string().min(1).max(30_000_000), ordner: z.string().trim().max(200).optional() }).parse(req.body ?? {});
|
||||
let lv;
|
||||
try { lv = leseGaeb(q.text); } catch (e) { return reply.status(400).send({ fehler: (e as Error).message }); }
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
const da = (await c.query("select id, nummer, gruppe from mengenvorlage where art = 'muster' and herkunft = 'gaeb'")).rows;
|
||||
const nach = new Map(da.map((x) => [`${x.gruppe}|${x.nummer}`, x.id as string]));
|
||||
let neu = 0, aktualisiert = 0;
|
||||
for (const [i, p] of lv.positionen.entries()) {
|
||||
const gruppe = [q.ordner, p.ordner || lv.name].filter(Boolean).join(" / ") || "GAEB";
|
||||
const alt = nach.get(`${gruppe}|${p.oz}`);
|
||||
if (alt) {
|
||||
await c.query(`update mengenvorlage set name = $2, kurztext = $2, langtext = $3, einheit = $4, ep_fest = coalesce($5, ep_fest), quelle = $6 where id = $1`,
|
||||
[alt, p.kurztext, p.langtext || null, p.einheit || null, p.ep, q.dateiname]);
|
||||
aktualisiert++;
|
||||
} else {
|
||||
await c.query(`insert into mengenvorlage (art, gruppe, name, kurztext, langtext, einheit, inhalt, nummer, herkunft, ep_fest, quelle, reihenfolge)
|
||||
values ('muster', $1, $2, $2, $3, $4, $5, $6, 'gaeb', $7, $8, $9)`,
|
||||
[gruppe, p.kurztext, p.langtext || null, p.einheit || null, leeresInhalt, p.oz, p.ep, q.dateiname, i]);
|
||||
neu++;
|
||||
}
|
||||
}
|
||||
return { neu, aktualisiert, name: lv.name, titel: lv.titel, mit_preis: lv.positionen.filter((p) => p.ep !== null).length };
|
||||
});
|
||||
return reply.status(201).send(r);
|
||||
});
|
||||
|
||||
/** Auswahl in der Liste: verschieben, kopieren, löschen, Preis um x % ändern */
|
||||
app.post("/api/leistungen/aktion", async (req) => {
|
||||
const q = z.object({
|
||||
ids: z.array(z.string().min(1).max(80)).min(1).max(5000),
|
||||
aktion: z.enum(["verschieben", "kopieren", "loeschen", "preis"]),
|
||||
ordner: z.string().trim().min(1).max(300).optional(),
|
||||
prozent: z.number().min(-90).max(500).optional(),
|
||||
}).parse(req.body ?? {});
|
||||
const s = stammSaetze(await einstellungen());
|
||||
const alle = new Map((await vorlagen(pool)).map((v) => [String(v.id), v]));
|
||||
const gewaehlt = q.ids.map((i) => alle.get(i)).filter((v): v is Mengenvorlage => !!v);
|
||||
const eigene = gewaehlt.filter((v) => !v.fest);
|
||||
return transaktion(pool, wer(req), async (c) => {
|
||||
let n = 0;
|
||||
if (q.aktion === "kopieren" || (q.aktion !== "loeschen" && gewaehlt.some((v) => v.fest))) {
|
||||
// mitgelieferte werden beim Ändern zu eigenen Kopien
|
||||
for (const v of q.aktion === "kopieren" ? gewaehlt : gewaehlt.filter((x) => x.fest)) {
|
||||
const kopie = (await c.query(`insert into mengenvorlage (art, gruppe, name, beschreibung, kurztext, langtext, einheit, inhalt, nummer, herkunft, ep_fest, quelle)
|
||||
values ('muster', $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning *`,
|
||||
[v.gruppe, q.aktion === "kopieren" && !v.fest ? `${v.name} (Kopie)` : v.name, v.beschreibung ?? null, q.aktion === "kopieren" && !v.fest ? `${v.kurztext || v.name} (Kopie)` : v.kurztext ?? null,
|
||||
v.langtext ?? null, v.einheit ?? null, { ...v.inhalt, ansaetze: (v.inhalt.ansaetze ?? []).map((z) => (z.artikel_id ? { ...z, ek: null } : z)) },
|
||||
v.nummer ?? null, v.herkunft ?? "eigen", v.ep_fest ?? null, v.quelle ?? null])).rows[0];
|
||||
if (q.aktion !== "kopieren") eigene.push({ ...kopie, fest: false });
|
||||
n++;
|
||||
}
|
||||
if (q.aktion === "kopieren") return { anzahl: n };
|
||||
}
|
||||
if (q.aktion === "loeschen") {
|
||||
const r = await c.query("delete from mengenvorlage where id = any($1::uuid[])", [eigene.map((v) => v.id)]);
|
||||
return { anzahl: r.rowCount ?? 0, uebersprungen: gewaehlt.length - eigene.length };
|
||||
}
|
||||
if (q.aktion === "verschieben") {
|
||||
if (!q.ordner) throw new Error("Ordner fehlt");
|
||||
const r = await c.query("update mengenvorlage set gruppe = $2 where id = any($1::uuid[])", [eigene.map((v) => v.id), q.ordner]);
|
||||
return { anzahl: r.rowCount ?? 0 };
|
||||
}
|
||||
const f = 1 + (q.prozent ?? 0) / 100;
|
||||
for (const v of eigene) {
|
||||
const ep = rechneLeistung(v, s).ep;
|
||||
await c.query("update mengenvorlage set ep_fest = $2 where id = $1", [v.id, Math.max(0, Math.round(ep * f))]);
|
||||
n++;
|
||||
}
|
||||
return { anzahl: n };
|
||||
});
|
||||
});
|
||||
|
||||
// ---------- Materialstamm ----------
|
||||
|
||||
/** Lieferanten, Warengruppen und Merkliste mit Anzahl (linke Spalte der Seite Material) */
|
||||
app.get("/api/artikel-uebersicht", async () => {
|
||||
const [l, w, m, g] = await Promise.all([
|
||||
pool.query("select lieferant, count(*)::int as anzahl, max(stand) as stand from artikel group by lieferant order by lieferant = '', lieferant"),
|
||||
pool.query("select coalesce(warengruppe, '') as warengruppe, count(*)::int as anzahl from artikel group by 1 order by 1"),
|
||||
pool.query("select count(*)::int as n from artikel where merkliste"),
|
||||
pool.query("select count(*)::int as n from artikel"),
|
||||
]);
|
||||
const rabatte = (await pool.query("select * from lieferant_rabatt order by lieferant, rabattgruppe")).rows.map((r) => ({ ...r, rabatt: Number(r.rabatt) }));
|
||||
return { lieferanten: l.rows, warengruppen: w.rows, merkliste: m.rows[0].n, gesamt: g.rows[0].n, rabatte };
|
||||
});
|
||||
|
||||
/** Artikel suchen: Text in Bezeichnung, Nummer, EAN; höchstens limit Treffer, dazu die Gesamtzahl */
|
||||
app.get("/api/artikel-suche", async (req) => {
|
||||
const q = z.object({
|
||||
q: z.string().max(200).default(""), lieferant: z.string().max(100).optional(), warengruppe: z.string().max(100).optional(),
|
||||
merkliste: z.enum(["1", "0"]).optional(), limit: z.coerce.number().int().min(1).max(2000).default(500),
|
||||
}).parse(req.query);
|
||||
const wo: string[] = [], werte: unknown[] = [];
|
||||
for (const wort of q.q.trim().split(/\s+/).filter(Boolean).slice(0, 6)) {
|
||||
werte.push(`%${wort.replace(/[%_\\]/g, (x) => `\\${x}`)}%`);
|
||||
wo.push(`(bezeichnung ilike $${werte.length} or artikelnummer ilike $${werte.length} or coalesce(ean, '') ilike $${werte.length} or coalesce(warengruppe, '') ilike $${werte.length})`);
|
||||
}
|
||||
if (q.lieferant !== undefined) { werte.push(q.lieferant); wo.push(`lieferant = $${werte.length}`); }
|
||||
if (q.warengruppe !== undefined) { werte.push(q.warengruppe); wo.push(`coalesce(warengruppe, '') = $${werte.length}`); }
|
||||
if (q.merkliste === "1") wo.push("merkliste");
|
||||
const bed = wo.length ? `where ${wo.join(" and ")}` : "";
|
||||
const anzahl = (await pool.query(`select count(*)::int as n from artikel ${bed}`, werte)).rows[0].n;
|
||||
werte.push(q.limit);
|
||||
const zeilen = (await pool.query(`select a.*, (select r.rabatt from lieferant_rabatt r where r.lieferant = a.lieferant and r.rabattgruppe = a.rabattgruppe) as gruppen_rabatt
|
||||
from artikel a ${bed} order by merkliste desc, lieferant, bezeichnung limit $${werte.length}`, werte)).rows;
|
||||
return { anzahl, zeilen };
|
||||
});
|
||||
|
||||
app.get("/api/artikel/:id/genutzt", async (req) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await pool.query(`select id, name from mengenvorlage where inhalt -> 'ansaetze' @> $1::jsonb order by name`, [JSON.stringify([{ artikel_id: id }])]);
|
||||
return r.rows;
|
||||
});
|
||||
|
||||
/** DATANORM-Import in Paketen: Rabatte, Artikel (neu oder geändert, L = löschen) und Preisänderungen eines Lieferanten */
|
||||
app.post("/api/artikel/import", async (req) => {
|
||||
const q = ImportSchema.parse(req.body ?? {});
|
||||
return transaktion(pool, wer(req), async (c) => {
|
||||
for (const r of q.rabatte) {
|
||||
await c.query(`insert into lieferant_rabatt (lieferant, rabattgruppe, rabatt, bezeichnung) values ($1, $2, $3, $4)
|
||||
on conflict (lieferant, rabattgruppe) do update set rabatt = excluded.rabatt, bezeichnung = coalesce(excluded.bezeichnung, lieferant_rabatt.bezeichnung)`,
|
||||
[q.lieferant, r.rabattgruppe, r.rabatt, r.bezeichnung ?? null]);
|
||||
}
|
||||
// EK der vorhandenen Artikel mit den neuen Rabatten neu rechnen (Trigger artikel_ek)
|
||||
if (q.rabatte.length) await c.query("update artikel set rabattgruppe = rabattgruppe where lieferant = $1 and rabattgruppe = any($2)", [q.lieferant, q.rabatte.map((r) => r.rabattgruppe)]);
|
||||
const weg = q.artikel.filter((a) => a.loeschen).map((a) => a.artikelnummer);
|
||||
const bleiben = q.artikel.filter((a) => !a.loeschen);
|
||||
const vorher = new Map((await c.query("select artikelnummer, listenpreis from artikel where lieferant = $1 and artikelnummer = any($2)",
|
||||
[q.lieferant, [...bleiben.map((a) => a.artikelnummer), ...q.preise.map((p) => p.artikelnummer)]])).rows.map((r) => [r.artikelnummer, r.listenpreis === null ? null : Number(r.listenpreis)]));
|
||||
let neu = 0, geaendert = 0, neuerPreis = 0;
|
||||
for (let i = 0; i < bleiben.length; i += 500) {
|
||||
const paket = bleiben.slice(i, i + 500);
|
||||
await c.query(`insert into artikel (lieferant, artikelnummer, bezeichnung, langtext, einheit, preiseinheit, preisart, listenpreis, rabattgruppe, warengruppe, ean, herkunft, stand)
|
||||
select $1, x.artikelnummer, x.bezeichnung, x.langtext, x.einheit, x.preiseinheit, x.preisart, x.listenpreis, x.rabattgruppe, x.warengruppe, x.ean, 'datanorm', $3
|
||||
from json_to_recordset($2::json) as x(artikelnummer text, bezeichnung text, langtext text, einheit text, preiseinheit int, preisart text, listenpreis bigint, rabattgruppe text, warengruppe text, ean text)
|
||||
on conflict (lieferant, artikelnummer) where artikelnummer <> '' do update set bezeichnung = excluded.bezeichnung, langtext = coalesce(excluded.langtext, artikel.langtext),
|
||||
einheit = excluded.einheit, preiseinheit = excluded.preiseinheit, preisart = excluded.preisart, listenpreis = coalesce(excluded.listenpreis, artikel.listenpreis),
|
||||
rabattgruppe = excluded.rabattgruppe, warengruppe = coalesce(excluded.warengruppe, artikel.warengruppe), ean = coalesce(excluded.ean, artikel.ean),
|
||||
herkunft = 'datanorm', stand = coalesce(excluded.stand, artikel.stand)`,
|
||||
[q.lieferant, JSON.stringify(paket), q.stand ?? null]);
|
||||
}
|
||||
for (const a of bleiben) {
|
||||
if (!vorher.has(a.artikelnummer)) neu++;
|
||||
else { geaendert++; if (a.listenpreis != null && vorher.get(a.artikelnummer) !== a.listenpreis) neuerPreis++; }
|
||||
}
|
||||
for (const p of q.preise) {
|
||||
const r = await c.query(`update artikel set listenpreis = $3, preisart = $4, rabatt = coalesce($5, rabatt), stand = coalesce($6, stand) where lieferant = $1 and artikelnummer = $2`,
|
||||
[q.lieferant, p.artikelnummer, p.preis, p.preisart, p.rabatt, q.stand ?? null]);
|
||||
if (r.rowCount && vorher.get(p.artikelnummer) !== p.preis) neuerPreis++;
|
||||
}
|
||||
const geloescht = weg.length ? (await c.query("delete from artikel where lieferant = $1 and artikelnummer = any($2)", [q.lieferant, weg])).rowCount ?? 0 : 0;
|
||||
return { neu, geaendert, neuer_preis: neuerPreis, geloescht, rabatte: q.rabatte.length };
|
||||
});
|
||||
});
|
||||
|
||||
/** Rabatt einer Rabattgruppe von Hand; die Artikel der Gruppe rechnen ihren EK neu */
|
||||
app.post("/api/lieferanten-rabatte/setzen", async (req) => {
|
||||
const q = z.object({ lieferant: z.string().trim().min(1).max(100), rabattgruppe: z.string().trim().min(1).max(40), rabatt: z.number().min(0).max(100).nullable() }).parse(req.body ?? {});
|
||||
return transaktion(pool, wer(req), async (c) => {
|
||||
if (q.rabatt === null) await c.query("delete from lieferant_rabatt where lieferant = $1 and rabattgruppe = $2", [q.lieferant, q.rabattgruppe]);
|
||||
else await c.query(`insert into lieferant_rabatt (lieferant, rabattgruppe, rabatt) values ($1, $2, $3)
|
||||
on conflict (lieferant, rabattgruppe) do update set rabatt = excluded.rabatt`, [q.lieferant, q.rabattgruppe, q.rabatt]);
|
||||
const r = await c.query("update artikel set rabattgruppe = rabattgruppe where lieferant = $1 and rabattgruppe = $2", [q.lieferant, q.rabattgruppe]);
|
||||
return { artikel: r.rowCount ?? 0 };
|
||||
});
|
||||
});
|
||||
|
||||
/** KI-Vorschlag: in der Testversion fragt der Browser Claude; auf dem Server kommt das mit eigenem Zugang später */
|
||||
app.post("/api/ki", async () => {
|
||||
throw Object.assign(new Error("Der KI-Vorschlag ist auf dem Server noch nicht eingerichtet. In der Testversion geht er schon."), { statusCode: 409 });
|
||||
});
|
||||
}
|
||||
@@ -26,6 +26,8 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
if (Number(belegt.rows[0]!.n) > 0) throw new NichtLeer("Eine Sicherung lässt sich nur in ein leeres Programm einspielen.");
|
||||
|
||||
const anzahl: Record<string, number> = {};
|
||||
// Zeitstempel aus der Sicherung behalten, kein Protokoll (Migration 017)
|
||||
await c.query("select set_config('betrieb.einspielen', 'ja', true)");
|
||||
// TABELLEN steht in der Reihenfolge der Fremdschlüssel, NUR_SICHERUNG hängt an ihnen
|
||||
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) {
|
||||
const zeilen = s.daten[t.pfad] ?? [];
|
||||
@@ -33,11 +35,20 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
// so passt eine ältere Sicherung auch nach einer Migration
|
||||
const vorhanden = new Set((await c.query<{ column_name: string }>(
|
||||
"select column_name from information_schema.columns where table_schema = current_schema() and table_name = $1", [t.name])).rows.map((r) => r.column_name));
|
||||
// gleich aufgebaute Zeilen zu Hunderten auf einmal (der Materialstamm hat schnell 20.000 Artikel)
|
||||
const pakete = new Map<string, Record<string, unknown>[]>();
|
||||
for (const zeile of zeilen) {
|
||||
// T15: Vorgänge aus einer Sicherung von vor 0.12 behalten ihre Dauer
|
||||
const z = t.name === "vorgang" && !("dauer_fest" in zeile) ? { ...zeile, dauer_fest: true } : zeile;
|
||||
const spalten = Object.keys(z).filter((k) => vorhanden.has(k)).join(", ");
|
||||
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_record(null::${t.name}, $1::json)`, [JSON.stringify(z)]);
|
||||
const paket = pakete.get(spalten) ?? [];
|
||||
paket.push(z);
|
||||
pakete.set(spalten, paket);
|
||||
}
|
||||
for (const [spalten, paket] of pakete) {
|
||||
for (let i = 0; i < paket.length; i += 500) {
|
||||
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_recordset(null::${t.name}, $1::json)`, [JSON.stringify(paket.slice(i, i + 500))]);
|
||||
}
|
||||
}
|
||||
anzahl[t.pfad] = zeilen.length;
|
||||
}
|
||||
@@ -46,6 +57,7 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
if (s.einstellungen !== undefined) {
|
||||
await c.query("update einstellungen set daten = $1", [EinstellungenSchema.parse(s.einstellungen)]);
|
||||
}
|
||||
await c.query("select set_config('betrieb.einspielen', '', true)");
|
||||
await c.query("select setval('vorgang_nummer_seq', greatest((select max(nummer) from vorgang), 1000))");
|
||||
// Sicherung von vor 0.6.0: dieselbe Regel wie Migration 006, damit laufende Projekte keinen automatischen Zahlungsplan bekommen
|
||||
if (!(s.daten.projekte ?? []).some((p) => "zahlungsplan" in p)) {
|
||||
|
||||
@@ -34,6 +34,8 @@ const ansatz = z.object({
|
||||
ek: z.number().int().min(0).nullable().optional(),
|
||||
faktor: z.number().positive().max(100).optional(),
|
||||
aktiv: z.boolean().optional(),
|
||||
/** Artikel aus dem Materialstamm: EK und Einheit kommen von dort */
|
||||
artikel_id: z.uuid().nullable().optional(),
|
||||
});
|
||||
|
||||
export interface Tabelle {
|
||||
@@ -211,6 +213,42 @@ export const TABELLEN: Tabelle[] = [
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
// Materialstamm (Stammdaten, 21.10.2026): DATANORM je Lieferant oder eigene Artikel; Preise in Cent je Preiseinheit
|
||||
{
|
||||
name: "artikel",
|
||||
pfad: "artikel",
|
||||
sortierung: "lieferant, artikelnummer, bezeichnung",
|
||||
schema: z.object({
|
||||
lieferant: z.string().trim().max(100).optional(),
|
||||
artikelnummer: z.string().trim().max(60).optional(),
|
||||
bezeichnung: text,
|
||||
langtext: optText,
|
||||
warengruppe: optText,
|
||||
rabattgruppe: optText,
|
||||
ean: optText,
|
||||
einheit: optText,
|
||||
preiseinheit: z.union([z.literal(1), z.literal(10), z.literal(100), z.literal(1000)]).optional(),
|
||||
preisart: z.enum(["brutto", "netto"]).optional(),
|
||||
listenpreis: cent.min(0).nullable().optional(),
|
||||
rabatt: z.number().min(0).max(100).nullable().optional(),
|
||||
ek: cent.min(0).nullable().optional(),
|
||||
ek_vorher: cent.nullable().optional(),
|
||||
herkunft: z.enum(["eigen", "datanorm"]).optional(),
|
||||
stand: datum.nullable().optional(),
|
||||
merkliste: z.boolean().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "lieferant_rabatt",
|
||||
pfad: "lieferanten-rabatte",
|
||||
sortierung: "lieferant, rabattgruppe",
|
||||
schema: z.object({
|
||||
lieferant: text,
|
||||
rabattgruppe: text,
|
||||
bezeichnung: optText,
|
||||
rabatt: z.number().min(0).max(100),
|
||||
}),
|
||||
},
|
||||
// Mengenvorlagen und Musterpositionen (A23): eigene; die mitgelieferten stehen im Programm (domain/mengenvorlagen.ts)
|
||||
{
|
||||
name: "mengenvorlage",
|
||||
@@ -226,6 +264,12 @@ export const TABELLEN: Tabelle[] = [
|
||||
einheit: optText,
|
||||
inhalt: blatt.extend({ ansaetze: z.array(ansatz).max(100).default([]) }),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
// Leistungen (Stammdaten): Nummer/OZ, Herkunft, „Preis festlegen auf“
|
||||
nummer: optText,
|
||||
herkunft: z.enum(["eigen", "gaeb", "plancraft"]).optional(),
|
||||
ep_fest: cent.min(0).nullable().optional(),
|
||||
quelle: optText,
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
{
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
// 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.
|
||||
// ihre Abschnitte. Rechts Summen, Bausteine, Leistungen, Mengenvorlagen und Material, 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";
|
||||
@@ -8,6 +8,7 @@ import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITI
|
||||
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 type { KiVorschlag } from "../domain/ki.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";
|
||||
@@ -90,13 +91,21 @@ interface Zustand {
|
||||
/** Langtext ohne Text sichtbar gemacht, oder mit Text ausgeblendet */
|
||||
langtextAn: Set<string>;
|
||||
langtextAus: Set<string>;
|
||||
reiter: "bausteine" | "vorlagen" | "kalkulation";
|
||||
reiter: "bausteine" | "leistungen" | "vorlagen" | "material" | "kalkulation";
|
||||
suche: string;
|
||||
/** Reiter Leistungen: Ordner-Filter */
|
||||
ordner: string;
|
||||
/** Reiter Material: Suche im Materialstamm und die Treffer */
|
||||
matSuche: string;
|
||||
matTreffer: Zeile[] | null;
|
||||
/** KI-Vorschlag aus den Leistungen der Stammdaten (0.18) */
|
||||
ki: { text: string; laeuft: boolean; fehler: string; vorschlaege: (KiVorschlag & { an: boolean })[] };
|
||||
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 };
|
||||
if (zustand?.angebot !== id) zustand = { angebot: id, aktiv: null, zu: new Set(), langtextAn: new Set(), langtextAus: new Set(), reiter: "bausteine", suche: "", ordner: "", matSuche: "", matTreffer: null,
|
||||
ki: { text: "", laeuft: false, fehler: "", vorschlaege: [] }, kopf: false };
|
||||
return zustand;
|
||||
};
|
||||
|
||||
@@ -132,7 +141,7 @@ function ordnung(d: Zeile) {
|
||||
|
||||
async function editor(id: string, gross: string | null): Promise<void> {
|
||||
const z = zustandFuer(id);
|
||||
let [d, vorlagen] = await Promise.all([api<Zeile>(`angebote/${id}/voll`), alleVorlagen()]);
|
||||
let [d, vorlagen, leistungen] = await Promise.all([api<Zeile>(`angebote/${id}/voll`), alleVorlagen(true), api<Zeile[]>("leistungen")]);
|
||||
let meldung = hinweis.text ? `${hinweis.gut ? "" : "! "}${hinweis.text}` : "";
|
||||
hinweis.text = ""; hinweis.gut = false;
|
||||
const wurzel = document.createElement("div");
|
||||
@@ -144,7 +153,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
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 = gross ? mengenblattHtml(d, z, vorlagen, meldung, gross) : html(d, z, vorlagen, meldung);
|
||||
wurzel.innerHTML = gross ? mengenblattHtml(d, z, vorlagen, meldung, gross) : html(d, z, vorlagen, meldung, leistungen);
|
||||
if (k) {
|
||||
const neu = wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`);
|
||||
if (neu) {
|
||||
@@ -237,7 +246,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
const r = await api<Zeile>(`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.`);
|
||||
return neuLaden(inPosition ? `Vorlage „${v.name}“ ist im Mengenblatt.` : `${v.art === "muster" ? "Leistung" : "Mengenvorlage"} „${v.kurztext || v.name}“ eingefügt.`);
|
||||
}
|
||||
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was, nach_id: nachId });
|
||||
z.aktiv = r.id;
|
||||
@@ -249,14 +258,14 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
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: "art", titel: "Speichern als", art: "auswahl", optionen: [["muster", "Leistung 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);
|
||||
{ name: "gruppe", titel: "Ordner", pflicht: true, hilfe: `Vorhanden: ${[...new Set(vorlagen.map((v) => v.gruppe))].slice(0, 12).join("; ")}. Unterordner mit „ / “.` },
|
||||
], { art: p.mit_kalkulation ? "muster" : "mengen", name: p.kurztext, gruppe: "Eigene Leistungen" }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const v = await api<Zeile>(`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.`;
|
||||
[vorlagen, leistungen] = await Promise.all([alleVorlagen(true), api<Zeile[]>("leistungen")]);
|
||||
meldung = `„${v.name}“ steht jetzt in den Stammdaten unter ${v.gruppe}. Dort kannst du Texte, Kalkulation und Mengenblatt nachschärfen.`;
|
||||
zeichne();
|
||||
};
|
||||
|
||||
@@ -314,12 +323,40 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (!el.dataset?.k) return;
|
||||
try { await speichern(el); await neuLaden(); } catch (e) { fehler(e); }
|
||||
});
|
||||
let matTimer: ReturnType<typeof setTimeout> | undefined;
|
||||
wurzel.addEventListener("input", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset?.kiText !== undefined) { z.ki.text = el.value; return; }
|
||||
if (el.dataset?.kiMenge !== undefined) { const v = z.ki.vorschlaege[Number(el.dataset.kiMenge)]; if (v) v.menge = el.value.trim() ? zahlAus(el.value) : null; return; }
|
||||
if (el.dataset?.matSuche !== undefined) {
|
||||
z.matSuche = el.value;
|
||||
clearTimeout(matTimer);
|
||||
matTimer = setTimeout(async () => {
|
||||
const q = z.matSuche.trim();
|
||||
z.matTreffer = q.length < 2 ? null : (await api<Zeile>(`artikel-suche?q=${encodeURIComponent(q)}&limit=40`)).zeilen;
|
||||
const ziel = wurzel.querySelector(".am-katalog-liste");
|
||||
if (ziel) ziel.innerHTML = katalogListe(d, z, vorlagen, !!gross, leistungen);
|
||||
}, 250);
|
||||
return;
|
||||
}
|
||||
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);
|
||||
if (ziel) ziel.innerHTML = katalogListe(d, z, vorlagen, !!gross, leistungen);
|
||||
});
|
||||
wurzel.addEventListener("change", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset?.ordnerWahl !== undefined) {
|
||||
z.ordner = el.value;
|
||||
const ziel = wurzel.querySelector(".am-katalog-liste");
|
||||
if (ziel) ziel.innerHTML = katalogListe(d, z, vorlagen, !!gross, leistungen);
|
||||
} else if (el.dataset?.kiWahl !== undefined) {
|
||||
const v = z.ki.vorschlaege[Number(el.dataset.kiWahl)];
|
||||
if (v) v.an = el.checked;
|
||||
const n = z.ki.vorschlaege.filter((x) => x.an).length;
|
||||
const k = wurzel.querySelector<HTMLButtonElement>('[data-a="ki-los"]');
|
||||
if (k) { k.textContent = `${n} übernehmen`; k.disabled = !n; }
|
||||
}
|
||||
});
|
||||
wurzel.addEventListener("keydown", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
@@ -381,6 +418,42 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
}
|
||||
if (a === "kopf") { z.kopf = !z.kopf; return zeichne(); }
|
||||
if (a === "neu") return await einfuegen(b.dataset.was!, z.aktiv);
|
||||
if (a === "ki") {
|
||||
z.ki.laeuft = true; z.ki.fehler = "";
|
||||
zeichne();
|
||||
try {
|
||||
const r = await api<{ vorschlaege: KiVorschlag[] }>("ki", "POST", { text: z.ki.text });
|
||||
z.ki.vorschlaege = r.vorschlaege.map((v) => ({ ...v, an: true }));
|
||||
if (!r.vorschlaege.length) z.ki.fehler = "Claude hat keine passende Leistung gefunden. Beschreibung genauer fassen oder Leistungen anlegen.";
|
||||
} catch (e) { z.ki.fehler = (e as Error).message; }
|
||||
z.ki.laeuft = false;
|
||||
return zeichne();
|
||||
}
|
||||
if (a === "ki-weg") { z.ki.vorschlaege = []; z.ki.fehler = ""; return zeichne(); }
|
||||
if (a === "ki-los") {
|
||||
// der Reihe nach unter die markierte Zeile, jede unter die vorige
|
||||
let nach = z.aktiv;
|
||||
const gewaehlt = z.ki.vorschlaege.filter((v) => v.an);
|
||||
for (const v of gewaehlt) {
|
||||
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was: "vorlage", vorlage_id: v.id, nach_id: nach, ...(v.menge != null ? { menge: v.menge } : {}) });
|
||||
nach = r.id;
|
||||
}
|
||||
z.aktiv = nach;
|
||||
z.ki.vorschlaege = [];
|
||||
return neuLaden(`${gewaehlt.length} ${gewaehlt.length === 1 ? "Leistung" : "Leistungen"} aus dem KI-Vorschlag eingefügt. Bitte Mengen und Texte prüfen.`);
|
||||
}
|
||||
if (a === "material-plus") {
|
||||
const art = z.matTreffer?.find((x) => x.id === zid);
|
||||
const p = z.aktiv ? pos(z.aktiv) : null;
|
||||
if (!art || !p) return;
|
||||
const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null;
|
||||
if (!p.mit_kalkulation) await api(`angebot-positionen/${p.id}`, "PATCH", { mit_kalkulation: true, ep_fest: null });
|
||||
await api("angebot-kosten", "POST", { position_id: p.id, kostenart: "material", beschreibung: art.bezeichnung, einheit: art.einheit ?? p.einheit ?? null,
|
||||
ek: art.ek == null ? null : Math.round(Number(art.ek) / Number(art.preiseinheit || 1)), bezug: blatt?.menge?.trim() || null, menge: 1,
|
||||
reihenfolge: kostenVon(p.id).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) });
|
||||
z.zu.delete(`${p.id}:kalk`);
|
||||
return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`);
|
||||
}
|
||||
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);
|
||||
@@ -589,7 +662,7 @@ function offenePosition(d: Zeile, z: Zustand, p: Zeile, frei: boolean): string {
|
||||
if (!teile.length) return "";
|
||||
return `<div class="m-offen">${teile.join("")}
|
||||
<div class="m-fertig"><span>Alles wird sofort gespeichert.${p.art && p.art !== "normal" ? ` Positionsart: ${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}.` : ""}</span>
|
||||
<span><button class="neben" data-a="als-vorlage" data-id="${p.id}">Als Musterposition speichern</button> <button class="haupt" data-a="fertig">Fertig</button></span></div></div>`;
|
||||
<span><button class="neben" data-a="als-vorlage" data-id="${p.id}">Als Leistung speichern</button> <button class="haupt" data-a="fertig">Fertig</button></span></div></div>`;
|
||||
}
|
||||
|
||||
const menue = (eintraege: [string, string, string, boolean?][]) => `<details class="am-menue"><summary class="punkte" aria-label="Weitere Aktionen" title="Weitere Aktionen">⋮</summary>
|
||||
@@ -601,7 +674,7 @@ function zeilenHtml(d: Zeile, z: Zustand, oz: Record<string, string>, p: Zeile,
|
||||
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"]]) : "";
|
||||
...(p.textzeile ? [] : [["als-vorlage", p.id, "Als Leistung speichern"] as [string, string, string]]), ["position-weg", p.id, "Löschen"]]) : "";
|
||||
if (p.textzeile) {
|
||||
return `<div class="am-zeile am-textzeile${aktiv ? " aktiv" : ""}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}"><div class="pos"></div>
|
||||
<div class="am-text-voll"><textarea data-k="angebot-positionen:${p.id}:kurztext" data-leer="pflicht" rows="2" aria-label="Text"${frei ? "" : " disabled"}>${esc(p.kurztext)}</textarea></div><div class="punkte-zelle">${knoepfe}</div></div>`;
|
||||
@@ -637,13 +710,61 @@ function zeilenHtml(d: Zeile, z: Zustand, oz: Record<string, string>, p: Zeile,
|
||||
}
|
||||
|
||||
/** Musterpositionen oder Mengenvorlagen für die Seitenleiste */
|
||||
function katalogListe(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: boolean): string {
|
||||
function katalogListe(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: boolean, leistungen: Zeile[] = []): 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;
|
||||
if (z.reiter === "leistungen" && !gross) return leistungenListe(z, leistungen, frei);
|
||||
if (z.reiter === "material" && !gross) return materialListe(z, !!aktivePos && frei);
|
||||
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 {
|
||||
/** Reiter Leistungen: die Leistungen der Stammdaten, nach Ordner gruppiert */
|
||||
function leistungenListe(z: Zustand, leistungen: Zeile[], frei: boolean): string {
|
||||
const w = z.suche.trim().toLowerCase().split(/\s+/).filter(Boolean);
|
||||
const passend = leistungen.filter((l) => (!z.ordner || l.gruppe === z.ordner || l.gruppe.startsWith(`${z.ordner} / `))
|
||||
&& w.every((x) => `${l.kurztext} ${l.nummer ?? ""} ${l.gruppe} ${l.langtext}`.toLowerCase().includes(x)));
|
||||
if (!passend.length) return `<p class="hinweis-k">${leistungen.length ? "Nichts gefunden." : 'Noch keine Leistungen. In den <a href="#stammdaten">Stammdaten</a> anlegen oder eine GAEB-Datei einlesen.'}</p>`;
|
||||
const gezeigt = passend.slice(0, 200);
|
||||
const gruppen = [...new Set(gezeigt.map((l) => l.gruppe))];
|
||||
const vk = (c: number | null) => (c == null ? "–" : `${formatEuro(Math.round(c), false)} €`);
|
||||
return gruppen.map((g) => `<div class="gr" title="${esc(g)}">${esc(g.split(" / ").at(-1) ?? g)}</div>${gezeigt.filter((l) => l.gruppe === g).map((l) => `<div class="baustein"${frei ? ` draggable="true" data-zieh="vorlage:${esc(l.id)}"` : ""}>
|
||||
<span class="g" aria-hidden="true">⋮⋮</span><span class="am-b-text">${esc(l.kurztext)}<small>${esc(l.einheit ?? "")} · ${vk(l.ep)}${l.std ? ` · ${zahlDeutsch(l.std, "h").replace(".", ",")} Std` : ""}</small></span>
|
||||
${frei ? `<button class="plus" data-a="vorlage" data-id="${esc(l.id)}" title="Unter der markierten Zeile einfügen" aria-label="${esc(l.kurztext)} einfügen">+</button>` : ""}
|
||||
<a class="am-b-bearb" href="#leistung-${esc(l.id)}" title="In den Stammdaten öffnen" aria-label="${esc(l.kurztext)} öffnen">✎</a></div>`).join("")}`).join("")
|
||||
+ (passend.length > gezeigt.length ? `<p class="hinweis-k">${gezeigt.length} von ${passend.length}; Suche eingrenzen.</p>` : "");
|
||||
}
|
||||
|
||||
/** Reiter Material: Treffer aus dem Materialstamm, + legt eine Materialzeile in der markierten Position an */
|
||||
function materialListe(z: Zustand, mitPlus: boolean): string {
|
||||
if (!z.matTreffer) return '<p class="hinweis-k">Artikel suchen (Bezeichnung, Artikelnummer).</p>';
|
||||
if (!z.matTreffer.length) return '<p class="hinweis-k">Kein Artikel gefunden.</p>';
|
||||
return z.matTreffer.map((a) => {
|
||||
const ek = a.ek == null ? null : Math.round(Number(a.ek) / Number(a.preiseinheit || 1));
|
||||
return `<div class="baustein"><span class="am-b-text">${esc(a.bezeichnung)}<small>${esc(a.lieferant || "eigener Artikel")} · ${ek == null ? "ohne Preis" : `${formatEuro(ek, false)} € / ${esc(a.einheit ?? "Einh.")}`}</small></span>
|
||||
${mitPlus ? `<button class="plus" data-a="material-plus" data-id="${esc(a.id)}" title="Als Materialzeile in die markierte Position" aria-label="${esc(a.bezeichnung)} übernehmen">+</button>` : ""}</div>`;
|
||||
}).join("");
|
||||
}
|
||||
|
||||
/** KI-Vorschlag: Beschreibung rein, Leistungen mit Menge zum Anhaken raus */
|
||||
function kiHtml(z: Zustand, leistungen: Zeile[]): string {
|
||||
const k = z.ki;
|
||||
const name = (id: string) => leistungen.find((l) => l.id === id);
|
||||
const an = k.vorschlaege.filter((v) => v.an).length;
|
||||
return `<details class="am-ki"${k.text || k.vorschlaege.length ? " open" : ""}><summary><b>KI-Vorschlag</b> <span class="hinweis-k">nur aus deinen Leistungen</span></summary>
|
||||
<textarea data-ki-text rows="3" placeholder="Was soll gemacht werden? z. B. Satteldach 10 × 12 m, 40° Neigung, Sparren neu, Aufdachdämmung, zwei Gauben" aria-label="Beschreibung der Arbeiten">${esc(k.text)}</textarea>
|
||||
<div class="am-ki-knoepfe"><button class="neben klein" data-a="ki"${k.laeuft ? " disabled" : ""}>${k.laeuft ? "Claude denkt nach …" : k.vorschlaege.length ? "Neu vorschlagen" : "Vorschlagen"}</button>
|
||||
${k.vorschlaege.length ? `<button class="verweis" data-a="ki-weg">verwerfen</button>` : ""}</div>
|
||||
${k.fehler ? `<p class="fehler">${esc(k.fehler)}</p>` : ""}
|
||||
${k.vorschlaege.length ? `<ul class="am-ki-liste">${k.vorschlaege.map((v, i) => {
|
||||
const l = name(v.id);
|
||||
return `<li><label><input type="checkbox" data-ki-wahl="${i}"${v.an ? " checked" : ""}><span><b>${esc(l?.kurztext ?? "?")}</b><small>${esc(v.grund)}</small></span></label>
|
||||
<span class="mit-einheit"><input class="zahl" data-ki-menge="${i}" value="${v.menge == null ? "" : zahlText(v.menge)}" placeholder="Menge" inputmode="decimal" aria-label="Menge"> ${esc(l?.einheit ?? "")}</span></li>`;
|
||||
}).join("")}</ul>
|
||||
<button class="haupt klein" data-a="ki-los"${an ? "" : " disabled"}>${an} übernehmen</button>
|
||||
<p class="hinweis-k">Kommt unter die markierte Zeile, sonst ans Ende. Ohne Menge rechnet das Mengenblatt der Leistung.</p>` : ""}</details>`;
|
||||
}
|
||||
|
||||
function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: string | null, leistungen: Zeile[] = []): string {
|
||||
const a = d.angebot, e = d.ergebnis, s = d.saetze;
|
||||
const frei = a.status === "entwurf";
|
||||
const feld = feldBau(frei);
|
||||
@@ -659,11 +780,19 @@ function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: st
|
||||
${([...KOSTENARTEN, "ohne"] as const).filter((x) => x === "lohn" || x === "material" || ka[x].kosten || ka[x].verkauf).map((x) => `<tr><td>${KOSTENART_NAME[x]}</td><td class="zahl">${euro(ka[x].kosten)}</td>
|
||||
<td class="zahl">${euro(ka[x].zuschlag)}<span class="unter">${prozentText(ka[x].prozent)}</span></td><td class="zahl">${euro(ka[x].verkauf)}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td>Summe</td><td class="zahl">${euro(e.kosten)}</td><td class="zahl">${euro(e.netto - e.kosten)}</td><td class="zahl">${euro(e.netto)}</td></tr></tfoot></table>`
|
||||
: `${reiter === "bausteine" && frei ? `${baustein("titel", "Titel")}${baustein("position", "Position")}${baustein("text", "Text")}` : ""}
|
||||
<input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="${reiter === "bausteine" ? "Musterposition suchen …" : "Mengenvorlage suchen …"}" aria-label="Suchen">
|
||||
: reiter === "bausteine" ? `${frei ? `${baustein("titel", "Titel")}${baustein("position", "Position")}${baustein("text", "Text")}<p class="hinweis-k">Ziehen oder + fügt unter der markierten Zeile ein. Fertige Positionen mit Texten und Kalkulation stehen unter „Leistungen“.</p>` : '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>'}`
|
||||
: reiter === "leistungen" ? `<div class="am-suchreihe"><input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Leistung suchen …" aria-label="Leistung suchen">
|
||||
<select data-ordner-wahl aria-label="Ordner"><option value="">alle Ordner</option>${[...new Set(leistungen.map((l) => l.gruppe as string))].sort((x, y) => x.localeCompare(y, "de", { numeric: true })).map((o) => `<option value="${esc(o)}"${z.ordner === o ? " selected" : ""}>${esc(o)}</option>`).join("")}</select></div>
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false, leistungen)}</div>
|
||||
<p class="hinweis-k">Ziehen oder + fügt unter der markierten Zeile ein, mit Texten, Kalkulation und Mengenblatt. <a href="#stammdaten">Alle Leistungen</a></p>
|
||||
${frei ? kiHtml(z, leistungen) : ""}`
|
||||
: reiter === "material" ? `<input class="suche" type="search" data-mat-suche value="${esc(z.matSuche)}" placeholder="Artikel suchen …" aria-label="Artikel suchen">
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false)}</div>
|
||||
<p class="hinweis-k">${aktivePos ? `+ legt den Artikel als Materialzeile in die Kalkulation von ${esc(oz[aktivePos.id])}, mit dem EK von heute.` : "Markiere eine Position, dann kommt der Artikel als Materialzeile in ihre Kalkulation."} <a href="#stammdaten-material">Materialstamm</a></p>`
|
||||
: `<input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Suchen">
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, !!gross)}</div>
|
||||
<p class="hinweis-k">${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."}
|
||||
<a href="#vorlagen">Alle Vorlagen und eigene anlegen</a></p>`;
|
||||
<p class="hinweis-k">${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."}
|
||||
<a href="#stammdaten-mengen">Alle Mengenvorlagen</a></p>`;
|
||||
return `<aside class="angebot-seite m-seite">
|
||||
<section class="karte summen"><dl>
|
||||
<dt>Netto</dt><dd>${euro(e.netto)}</dd><dt>USt</dt><dd>${euro(e.ust)}</dd><dt class="brutto">Brutto</dt><dd class="brutto">${euro(e.brutto)}</dd>
|
||||
@@ -671,7 +800,7 @@ function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: st
|
||||
<dt>Möglicher Überschuss</dt><dd>${e.kosten ? `${euro(e.netto - e.kosten)} <small>(${prozentText(e.ueberschuss_prozent)})</small>` : "–"}</dd>
|
||||
${e.stundensatz_verkauf ? `<dt>Verkauf je Lohnstunde</dt><dd>${euro(e.stundensatz_verkauf)}</dd>` : ""}
|
||||
${e.arbeitskosten_brutto ? `<dt title="§ 35a EStG, für Privatkunden">Arbeitskosten brutto</dt><dd>${euro(e.arbeitskosten_brutto)}</dd>` : ""}</dl></section>
|
||||
<section class="karte am-reiter-karte">${gross ? "<h3>Mengenvorlagen</h3>" : `<div class="reiter-k" role="group" aria-label="Seitenleiste">${reiterKnopf("bausteine", "Bausteine")}${reiterKnopf("vorlagen", "Mengenvorlagen")}${reiterKnopf("kalkulation", "Kalkulation")}</div>`}${katalog}</section>
|
||||
<section class="karte am-reiter-karte">${gross ? "<h3>Mengenvorlagen</h3>" : `<div class="reiter-k" role="group" aria-label="Seitenleiste">${reiterKnopf("bausteine", "Bausteine")}${reiterKnopf("leistungen", "Leistungen")}${reiterKnopf("vorlagen", "Mengen")}${reiterKnopf("material", "Material")}${reiterKnopf("kalkulation", "Kalk.")}</div>`}${katalog}</section>
|
||||
<section class="karte"><details class="am-vorgaben"${gross ? " open" : ""}><summary><h3>Vorgaben dieses Angebots</h3></summary>
|
||||
<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]}${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
|
||||
<span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")}
|
||||
@@ -723,7 +852,7 @@ function kopfHtml(d: Zeile, z: Zustand, meldung: string): string {
|
||||
|
||||
const datenlisten = (b: Blatt | null) => `<datalist id="einheiten">${EINHEITEN.map((x) => `<option value="${x}">`).join("")}</datalist>${kuerzelListe("am-kuerzel", b ?? leeresBlatt())}`;
|
||||
|
||||
function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string): string {
|
||||
function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string, leistungen: Zeile[]): string {
|
||||
const a = d.angebot, e = d.ergebnis;
|
||||
const frei = a.status === "entwurf";
|
||||
const feld = feldBau(frei);
|
||||
@@ -739,13 +868,13 @@ function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string):
|
||||
<section class="karte am-lv">
|
||||
<div class="am-zeile kopfzeile"><div>Pos.</div><div class="z">Menge</div><div>Einheit</div><div>Beschreibung</div><div class="z">EP</div><div class="z">Gesamt</div><div></div></div>
|
||||
${lv}
|
||||
${d.positionen.length ? "" : '<p class="hinweis leer am-leer">Lege Titel (z. B. „Dachstuhl“) und Positionen an, oder ziehe rechts eine Musterposition hinein.</p>'}
|
||||
${d.positionen.length ? "" : '<p class="hinweis leer am-leer">Lege Titel (z. B. „Dachstuhl“) und Positionen an, oder ziehe rechts eine Leistung hinein.</p>'}
|
||||
${frei ? `<div class="m-neu"><button class="verweis" data-a="neu" data-was="position">+ Position</button><button class="verweis" data-a="neu" data-was="titel">+ Titel</button>
|
||||
<button class="verweis" data-a="neu" data-was="text">+ Text</button><button class="verweis" data-a="reiter" data-was="bausteine">+ aus Katalog</button>
|
||||
<button class="verweis" data-a="neu" data-was="text">+ Text</button><button class="verweis" data-a="reiter" data-was="leistungen">+ aus Leistungen</button>
|
||||
${aktivePos || z.aktiv ? '<span class="hinweis-k">kommt unter die markierte Zeile</span>' : ""}</div>` : ""}
|
||||
<div class="m-summe"><span>Netto <b>${euro(e.netto)}</b></span><span>Brutto <b>${euro(e.brutto)}</b></span></div>
|
||||
</section>
|
||||
${seitenleiste(d, z, vorlagen, null)}
|
||||
${seitenleiste(d, z, vorlagen, null, leistungen)}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
|
||||
@@ -13,7 +13,8 @@ import { naechsteNummer } from "../domain/kalkulation.js";
|
||||
import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
|
||||
import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngebot } from "./angebote.js";
|
||||
import { vorlageSeite, vorlagenSeite } from "./mengenblatt.js";
|
||||
import { vorlageSeite } from "./mengenblatt.js";
|
||||
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
|
||||
|
||||
// ---------- Reiter ----------
|
||||
@@ -992,8 +993,8 @@ async function daten(): Promise<void> {
|
||||
};
|
||||
const vorlagenLink = document.createElement("a");
|
||||
vorlagenLink.className = "neben";
|
||||
vorlagenLink.href = "#vorlagen";
|
||||
vorlagenLink.textContent = "Vorlagen: Mengen und Musterpositionen";
|
||||
vorlagenLink.href = "#stammdaten";
|
||||
vorlagenLink.textContent = "Leistungen, Material und Mengenvorlagen: Stammdaten";
|
||||
inhalt.append(" ", kalkKnopf, " ", vorlagenLink);
|
||||
await vorlageEditor(e);
|
||||
}
|
||||
@@ -1065,7 +1066,7 @@ function reiterFuer(s: Sitzung): Reiter[] {
|
||||
const alle: Reiter[] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
|
||||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
];
|
||||
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||||
return alle;
|
||||
@@ -1078,6 +1079,7 @@ const SYMBOLE: Record<string, string> = {
|
||||
projekte: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
|
||||
terminplan: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
|
||||
kontakte: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
|
||||
stammdaten: '<rect x="4" y="3" width="16" height="18" rx="1"/><path d="M8 7h8M8 11h8M8 15h5"/>',
|
||||
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
|
||||
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
|
||||
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
|
||||
@@ -1112,12 +1114,14 @@ async function zeige(): Promise<void> {
|
||||
const angebot = /^angebot-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
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
|
||||
// Stammdaten (0.18): Leistungen, Material, Mengenvorlagen, Import
|
||||
const vorlage = /^vorlage-([\w-]{1,80})$/.exec(id)?.[1];
|
||||
const zuDaten = vorlage || id === "vorlagen";
|
||||
const leistung = /^leistung-([\w-]{1,80})$/.exec(id)?.[1];
|
||||
const sdTeil = /^stammdaten-(material|mengen|import)$/.exec(id)?.[1] ?? (id === "vorlagen" ? "mengen" : undefined);
|
||||
const zuStamm = vorlage || leistung || sdTeil;
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuDaten ? "daten" : id)) ?? REITER[0]!;
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
try {
|
||||
await (ablage ? ablageSeite(ablage)
|
||||
@@ -1128,8 +1132,9 @@ async function zeige(): Promise<void> {
|
||||
: 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()
|
||||
: vorlage && reiter[0] === "stammdaten" ? vorlageSeite(vorlage)
|
||||
: leistung && reiter[0] === "stammdaten" ? leistungSeite(leistung)
|
||||
: sdTeil && reiter[0] === "stammdaten" ? stammdatenSeite(sdTeil)
|
||||
: id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
|
||||
@@ -255,7 +255,7 @@ export function vorlagenListeHtml(liste: Mengenvorlage[], o: { art: "muster" | "
|
||||
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("");
|
||||
<a class="am-b-bearb" href="#${v.art === "muster" ? "leistung" : "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“) */
|
||||
@@ -303,7 +303,7 @@ function ansaetzeHtml(v: Mengenvorlage, a: Auswertung, frei: boolean): string {
|
||||
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; }
|
||||
if (!v) { inhalt.innerHTML = '<p class="fehler">Diese Vorlage gibt es nicht (mehr).</p><p><a href="#stammdaten-mengen">Zu den Mengenvorlagen</a></p>'; return; }
|
||||
v.inhalt = { ...alsBlatt(v.inhalt), ansaetze: v.inhalt.ansaetze ?? [] };
|
||||
let meldung = "";
|
||||
const wurzel = document.createElement("div");
|
||||
@@ -316,7 +316,7 @@ export async function vorlageSeite(id: string): Promise<void> {
|
||||
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>
|
||||
<div class="kopf am-kopf"><a class="neben zurueck" href="#stammdaten-mengen" aria-label="Zu den Mengenvorlagen">←</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>' : ""}
|
||||
@@ -327,7 +327,7 @@ export async function vorlageSeite(id: string): Promise<void> {
|
||||
<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 class="am-radio"><input type="radio" name="v-art" data-k="v:art" data-typ="roh" value="muster"${v!.art === "muster" ? " checked" : ""}${frei ? "" : " disabled"}> Leistung 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>
|
||||
@@ -337,7 +337,7 @@ export async function vorlageSeite(id: string): Promise<void> {
|
||||
<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>
|
||||
<p class="hinweis-k">Danach steht sie im Angebot rechts unter „Leistungen“ oder „Mengen“, für jedes neue Angebot.</p></section>
|
||||
</aside></div>`;
|
||||
if (k) wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`)?.focus();
|
||||
};
|
||||
@@ -400,52 +400,10 @@ export async function vorlageSeite(id: string): Promise<void> {
|
||||
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";
|
||||
location.hash = "stammdaten-mengen";
|
||||
}
|
||||
} 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}`;
|
||||
});
|
||||
}
|
||||
|
||||
795
src/web/stammdaten.ts
Normal file
795
src/web/stammdaten.ts
Normal file
@@ -0,0 +1,795 @@
|
||||
// Stammdaten (Henning, 21.10.2026, Entwürfe 1–4): Leistungen mit Ordnern und Vorkalkulation wie im Angebot,
|
||||
// Materialstamm mit DATANORM und Rabatten je Lieferant, Mengenvorlagen, Kataloge und Import (GAEB, DATANORM).
|
||||
// Listen wie überall filter- und sortierbar; Auswahl per Haken für „ins Angebot“, verschieben, kopieren, löschen.
|
||||
|
||||
import { type Auswertung, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
|
||||
import type { Ansatz, 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 { zahlDeutsch } from "../domain/formel.js";
|
||||
import { dateiText } from "../domain/kodierung.js";
|
||||
import { type Datanorm, ekNetto, leseDatanorm } from "../domain/datanorm.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, hinweis, hinweisHtml, inhalt, optionenHtml } from "./ui.js";
|
||||
import { liste, menue, menueSchliessen } from "./liste.js";
|
||||
import { alleVorlagen, blattAktion, blattHtml, kuerzelListe, setze, zahlAus, zahlText } from "./mengenblatt.js";
|
||||
import { entpacke, istZip } from "./zip.js";
|
||||
|
||||
const TEILE: [string, string][] = [["leistungen", "Leistungen"], ["material", "Material"], ["mengen", "Mengenvorlagen"], ["import", "Kataloge und Import"]];
|
||||
const HERKUNFT: Record<string, [string, string]> = {
|
||||
gaeb: ["GAEB", "gaeb"], eigen: ["eigene", "gut"], mitgeliefert: ["mitgeliefert", "grau"], plancraft: ["Plancraft", "gaeb"], datanorm: ["DATANORM", "datanorm"],
|
||||
};
|
||||
const marke = (h: string) => { const [t, k] = HERKUNFT[h] ?? [h, "grau"]; return `<span class="marke ${k}">${esc(t)}</span>`; };
|
||||
const euroFeld = (c: number | string | null | undefined) => (c === null || c === undefined || c === "" ? "" : formatEuro(Math.round(Number(c)), false));
|
||||
const ordnerTeile = (g: string) => g.split(" / ").map((x) => x.trim()).filter(Boolean);
|
||||
|
||||
let zahlen: { leistungen: number; material: number; mengen: number } | null = null;
|
||||
async function zahlenLaden(): Promise<NonNullable<typeof zahlen>> {
|
||||
if (zahlen) return zahlen;
|
||||
const [l, u, v] = await Promise.all([api<Zeile[]>("leistungen"), api<Zeile>("artikel-uebersicht"), alleVorlagen(true)]);
|
||||
zahlen = { leistungen: l.length, material: u.gesamt, mengen: v.filter((x) => x.art === "mengen").length };
|
||||
return zahlen;
|
||||
}
|
||||
const zahlenNeu = () => { zahlen = null; };
|
||||
|
||||
/** Kopf mit Titel, Knöpfen rechts und den vier Reitern */
|
||||
async function kopf(titel: string, knoepfe: string, aktiv: string, zurueck?: string): Promise<void> {
|
||||
const z = await zahlenLaden();
|
||||
const anzahl: Record<string, number> = { leistungen: z.leistungen, material: z.material, mengen: z.mengen };
|
||||
inhalt.innerHTML = `<div class="kopf">${zurueck ? `<a class="neben zurueck" href="#${zurueck}" aria-label="Zurück">←</a>` : ""}<h1>${titel}</h1><span class="kopf-knoepfe">${knoepfe}</span></div>
|
||||
<div class="teile-kopf sd-teile"><nav class="teile">${TEILE.map(([t, name]) => `<button data-sd-teil="${t}" class="${t === aktiv ? "aktiv" : ""}">${name}${anzahl[t] !== undefined ? ` <small>${anzahl[t]!.toLocaleString("de-DE")}</small>` : ""}</button>`).join("")}</nav></div>
|
||||
${hinweisHtml()}`;
|
||||
hinweis.text = "";
|
||||
hinweis.gut = false;
|
||||
inhalt.querySelector(".sd-teile")!.addEventListener("click", (ev) => {
|
||||
const t = (ev.target as HTMLElement).closest<HTMLElement>("[data-sd-teil]")?.dataset.sdTeil;
|
||||
if (t) location.hash = t === "leistungen" ? "stammdaten" : `stammdaten-${t}`;
|
||||
});
|
||||
}
|
||||
|
||||
export async function stammdatenSeite(teil = "leistungen"): Promise<void> {
|
||||
if (teil === "material") return materialSeite();
|
||||
if (teil === "mengen") return mengenSeite();
|
||||
if (teil === "import") return importSeite();
|
||||
return leistungenSeite();
|
||||
}
|
||||
|
||||
// ---------- Leistungen ----------
|
||||
|
||||
const sdZustand = { ordner: "", herkunft: "", suche: "", wahl: new Set<string>(), offen: new Set<string>() };
|
||||
|
||||
async function leistungenSeite(): Promise<void> {
|
||||
const alle = await api<Zeile[]>("leistungen");
|
||||
await kopf("Stammdaten", '<button class="neben" data-a="gaeb">GAEB importieren</button><button class="neben" data-a="ins-angebot">Auswahl ins Angebot …</button><button class="haupt" data-a="neu">Neue Leistung</button>', "leistungen");
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "sd-raster";
|
||||
inhalt.append(raster);
|
||||
const ids = new Set(alle.map((l) => l.id));
|
||||
for (const w of [...sdZustand.wahl]) if (!ids.has(w)) sdZustand.wahl.delete(w);
|
||||
|
||||
const passend = () => {
|
||||
const s = sdZustand.suche.trim().toLowerCase().split(/\s+/).filter(Boolean);
|
||||
return alle.filter((l) => (!sdZustand.ordner || l.gruppe === sdZustand.ordner || l.gruppe.startsWith(`${sdZustand.ordner} / `))
|
||||
&& (!sdZustand.herkunft || l.herkunft === sdZustand.herkunft)
|
||||
&& s.every((w) => `${l.kurztext} ${l.langtext} ${l.nummer ?? ""} ${l.gruppe}`.toLowerCase().includes(w)));
|
||||
};
|
||||
|
||||
// Ordnerbaum aus den Pfaden „A / B / C“
|
||||
const baum = () => {
|
||||
const knoten = new Map<string, number>();
|
||||
for (const l of alle) {
|
||||
const t = ordnerTeile(l.gruppe);
|
||||
for (let i = 1; i <= t.length; i++) { const p = t.slice(0, i).join(" / "); knoten.set(p, (knoten.get(p) ?? 0) + 1); }
|
||||
}
|
||||
const kinder = (eltern: string) => [...knoten.keys()].filter((p) => {
|
||||
const t = ordnerTeile(p);
|
||||
return t.length === (eltern ? ordnerTeile(eltern).length + 1 : 1) && (!eltern || p.startsWith(`${eltern} / `));
|
||||
}).sort((a, b) => a.localeCompare(b, "de", { numeric: true }));
|
||||
const zweig = (p: string): string => {
|
||||
const k = kinder(p);
|
||||
const auf = sdZustand.offen.has(p) || sdZustand.ordner === p || sdZustand.ordner.startsWith(`${p} / `);
|
||||
return `<li><div class="sd-knoten${sdZustand.ordner === p ? " an" : ""}">${k.length ? `<button class="sd-pfeil" data-auf="${esc(p)}" aria-label="${auf ? "zuklappen" : "aufklappen"}">${auf ? "▾" : "▸"}</button>` : '<span class="sd-pfeil"></span>'}
|
||||
<button class="sd-ordner" data-ordner="${esc(p)}">${esc(ordnerTeile(p).at(-1)!)}</button><small>${knoten.get(p)}</small></div>
|
||||
${k.length && auf ? `<ul>${k.map(zweig).join("")}</ul>` : ""}</li>`;
|
||||
};
|
||||
const herkunft = [...new Set(alle.map((l) => l.herkunft))];
|
||||
return `<button class="sd-alle${sdZustand.ordner || sdZustand.herkunft ? "" : " an"}" data-ordner="">Alle Leistungen <small>${alle.length}</small></button>
|
||||
<h3 class="gruppe">Ordner</h3><ul class="sd-baum">${kinder("").map(zweig).join("") || '<li class="hinweis-k">Noch keine Ordner</li>'}</ul>
|
||||
<h3 class="gruppe">Herkunft</h3>${herkunft.map((h) => `<button class="sd-herkunft${sdZustand.herkunft === h ? " an" : ""}" data-herkunft="${esc(h)}">${marke(h)}<span>${{ gaeb: "aus GAEB-Dateien", eigen: "selbst angelegt", mitgeliefert: "mitgeliefert", plancraft: "aus Plancraft" }[h as "gaeb"] ?? h}</span><small>${alle.filter((l) => l.herkunft === h).length}</small></button>`).join("")}`;
|
||||
};
|
||||
|
||||
const zeichne = () => {
|
||||
const zeilen = passend();
|
||||
raster.innerHTML = `<aside class="karte sd-seite">${baum()}</aside>
|
||||
<section class="karte sd-haupt"><div class="sd-suchleiste"><input type="search" class="sd-suche" placeholder="Leistungen durchsuchen (Kurztext, Langtext, Nummer) …" value="${esc(sdZustand.suche)}" aria-label="Leistungen durchsuchen">
|
||||
${sdZustand.ordner ? `<span class="chip"><span>Ordner: ${esc(ordnerTeile(sdZustand.ordner).at(-1)!)}</span><button type="button" data-ordner="" aria-label="Ordner-Filter entfernen">✕</button></span>` : ""}
|
||||
${sdZustand.herkunft ? `<span class="chip"><span>Herkunft: ${esc(HERKUNFT[sdZustand.herkunft]?.[0] ?? sdZustand.herkunft)}</span><button type="button" data-herkunft="" aria-label="Herkunft-Filter entfernen">✕</button></span>` : ""}</div>
|
||||
<div class="sd-auswahl"${sdZustand.wahl.size ? "" : " hidden"}><b>${sdZustand.wahl.size} ausgewählt</b>
|
||||
<button class="verweis" data-a="ins-angebot">ins Angebot übernehmen</button> · <button class="verweis" data-a="verschieben">in Ordner verschieben</button> ·
|
||||
<button class="verweis" data-a="preis">Preis ändern</button> · <button class="verweis" data-a="kopieren">kopieren</button> · <button class="verweis" data-a="loeschen">löschen</button> ·
|
||||
<button class="verweis" data-a="keine">Auswahl aufheben</button></div>
|
||||
<div class="sd-liste"></div></section>`;
|
||||
raster.querySelector(".sd-liste")!.append(liste({
|
||||
schluessel: "stammdaten-leistungen", einheit: ["Leistung", "Leistungen"], klasse: "sd-tabelle", leer: "Keine Leistung passt. Ordner, Herkunft oder Suche ändern.",
|
||||
spalten: [
|
||||
{ id: "wahl", titel: "Auswahl", fest: true, klasse: "sd-wahl", kopf: '<input type="checkbox" data-wahl-alle aria-label="Alle sichtbaren auswählen">',
|
||||
wert: (l) => `<input type="checkbox" data-wahl="${esc(l.id)}"${sdZustand.wahl.has(l.id) ? " checked" : ""} aria-label="${esc(l.kurztext)} auswählen">` },
|
||||
{ id: "beschreibung", titel: "Beschreibung", text: (l) => l.kurztext,
|
||||
wert: (l) => `<b>${esc(l.kurztext)}</b><span class="unter sd-lang">${esc((l.langtext || l.gruppe).replace(/\s+/g, " ").slice(0, 140))}</span>`, klasse: "sd-text" },
|
||||
{ id: "ordner", titel: "Ordner", text: (l) => l.gruppe, wert: (l) => esc(ordnerTeile(l.gruppe).at(-1) ?? ""), klasse: "optional sd-klein" },
|
||||
{ id: "einheit", titel: "Einheit", wert: (l) => esc(l.einheit) },
|
||||
{ id: "std", titel: "Std/Einh.", art: "zahl", wert: (l) => (l.std ? zahlDeutsch(l.std, "h").replace(".", ",") : "–"), sortWert: (l) => l.std, klasse: "zahl optional" },
|
||||
{ id: "kosten", titel: "Kosten", art: "zahl", wert: (l) => (l.zeilen ? euroFeld(l.kosten) : "–"), sortWert: (l) => l.kosten, klasse: "zahl" },
|
||||
{ id: "vk", titel: "VK", art: "zahl", wert: (l) => `<b>${euroFeld(l.ep)}</b>${l.ep_fest != null && l.zeilen ? '<span class="unter">festgelegt</span>' : ""}`, sortWert: (l) => l.ep, klasse: "zahl" },
|
||||
{ id: "herkunft", titel: "Herkunft", text: (l) => HERKUNFT[l.herkunft]?.[0] ?? l.herkunft, wert: (l) => marke(l.herkunft) },
|
||||
],
|
||||
zeilen, klick: (l) => { location.hash = `leistung-${l.id}`; },
|
||||
fuss: () => '<p class="hinweis-k sd-fuss">Zeile anklicken öffnet die Leistung. Kosten und VK rechnen mit den Vorgaben der Angebote (Einstellungen).</p>',
|
||||
}));
|
||||
};
|
||||
zeichne();
|
||||
|
||||
const auswahlLeiste = () => {
|
||||
const l = raster.querySelector<HTMLElement>(".sd-auswahl")!;
|
||||
l.hidden = !sdZustand.wahl.size;
|
||||
l.querySelector("b")!.textContent = `${sdZustand.wahl.size} ausgewählt`;
|
||||
};
|
||||
raster.addEventListener("input", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.classList.contains("sd-suche")) return;
|
||||
sdZustand.suche = el.value;
|
||||
const pos = el.selectionStart;
|
||||
zeichne();
|
||||
const neu = raster.querySelector<HTMLInputElement>(".sd-suche")!;
|
||||
neu.focus();
|
||||
neu.setSelectionRange(pos, pos);
|
||||
});
|
||||
raster.addEventListener("change", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset.wahl) { el.checked ? sdZustand.wahl.add(el.dataset.wahl) : sdZustand.wahl.delete(el.dataset.wahl); auswahlLeiste(); }
|
||||
else if (el.dataset.wahlAlle !== undefined) {
|
||||
raster.querySelectorAll<HTMLInputElement>("input[data-wahl]").forEach((x) => { x.checked = el.checked; el.checked ? sdZustand.wahl.add(x.dataset.wahl!) : sdZustand.wahl.delete(x.dataset.wahl!); });
|
||||
auswahlLeiste();
|
||||
}
|
||||
});
|
||||
inhalt.addEventListener("click", async function klick(ev) {
|
||||
if (!document.body.contains(raster)) return inhalt.removeEventListener("click", klick);
|
||||
const t = ev.target as HTMLElement;
|
||||
const auf = t.closest<HTMLElement>("[data-auf]")?.dataset.auf;
|
||||
if (auf !== undefined) { sdZustand.offen.has(auf) ? sdZustand.offen.delete(auf) : sdZustand.offen.add(auf); return zeichne(); }
|
||||
const o = t.closest<HTMLElement>("[data-ordner]")?.dataset.ordner;
|
||||
if (o !== undefined) { sdZustand.ordner = o; if (!o) sdZustand.herkunft = ""; return zeichne(); }
|
||||
const h = t.closest<HTMLElement>("[data-herkunft]")?.dataset.herkunft;
|
||||
if (h !== undefined) { sdZustand.herkunft = sdZustand.herkunft === h ? "" : h; return zeichne(); }
|
||||
const a = t.closest<HTMLElement>("[data-a]")?.dataset.a;
|
||||
if (!a || t.closest(".liste-leiste, thead")) return;
|
||||
try {
|
||||
const gewaehlt = [...sdZustand.wahl];
|
||||
if (a === "neu") {
|
||||
const ordner = [...new Set(alle.map((l) => l.gruppe))].sort();
|
||||
const r = await dialog("Neue Leistung", [
|
||||
{ name: "kurztext", titel: "Kurztext", pflicht: true }, { name: "einheit", titel: "Einheit", hilfe: "m, m², m³, St, psch" },
|
||||
{ name: "gruppe", titel: "Ordner", art: "auswahl", optionen: [["Eigene Leistungen", "Eigene Leistungen"], ...ordner.filter((x) => x !== "Eigene Leistungen").map((x): [string, string] => [x, x])], hilfe: "Neue Ordner entstehen beim Verschieben oder auf der Seite der Leistung." },
|
||||
], { einheit: "m", gruppe: sdZustand.ordner || "Eigene Leistungen" }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const neu = await api<Zeile>("mengenvorlagen", "POST", { art: "muster", gruppe: r.daten.gruppe || "Eigene Leistungen", name: r.daten.kurztext, kurztext: r.daten.kurztext,
|
||||
einheit: r.daten.einheit || null, herkunft: "eigen", inhalt: { werte: [], listen: [], zeilen: [], menge: null, ansaetze: [] } });
|
||||
zahlenNeu();
|
||||
location.hash = `leistung-${neu.id}`;
|
||||
return;
|
||||
}
|
||||
if (a === "gaeb") { location.hash = "stammdaten-import"; return; }
|
||||
if (a === "keine") { sdZustand.wahl.clear(); return zeichne(); }
|
||||
if (a === "ins-angebot") {
|
||||
if (!gewaehlt.length) { hinweis.text = "Zuerst Leistungen mit dem Haken auswählen."; return leistungenSeite(); }
|
||||
return insAngebot(gewaehlt);
|
||||
}
|
||||
if (a === "verschieben") {
|
||||
const ordner = [...new Set(alle.map((l) => l.gruppe))].sort();
|
||||
const r = await dialog(`${gewaehlt.length} ${gewaehlt.length === 1 ? "Leistung" : "Leistungen"} verschieben`, [
|
||||
{ name: "ordner", titel: "Ordner", pflicht: true, hilfe: `Vorhanden: ${ordner.slice(0, 8).join("; ")}${ordner.length > 8 ? " …" : ""}. Unterordner mit „ / “, z. B. „03 Konstruktionen / Dachstuhl“. Ein neuer Name legt den Ordner an.` },
|
||||
], { ordner: sdZustand.ordner }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
await api("leistungen/aktion", "POST", { ids: gewaehlt, aktion: "verschieben", ordner: String(r.daten.ordner).trim() });
|
||||
} else if (a === "preis") {
|
||||
const r = await dialog("Preis ändern", [{ name: "prozent", titel: "Preis ändern um (%)", art: "zahl", pflicht: true, hilfe: "z. B. 5 für 5 % teurer oder -3. Der neue Preis wird festgelegt („Preis festlegen auf“)." }], { prozent: 5 }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
await api("leistungen/aktion", "POST", { ids: gewaehlt, aktion: "preis", prozent: Number(r.daten.prozent) });
|
||||
} else if (a === "kopieren") {
|
||||
await api("leistungen/aktion", "POST", { ids: gewaehlt, aktion: "kopieren" });
|
||||
hinweis.gut = true;
|
||||
hinweis.text = `${gewaehlt.length} ${gewaehlt.length === 1 ? "Kopie" : "Kopien"} angelegt.`;
|
||||
} else if (a === "loeschen") {
|
||||
const fest = alle.filter((l) => sdZustand.wahl.has(l.id) && l.fest).length;
|
||||
if (!(await bestaetigen(`${gewaehlt.length - fest} ${gewaehlt.length - fest === 1 ? "Leistung" : "Leistungen"} löschen?${fest ? ` ${fest} mitgelieferte bleiben.` : ""} Angebote behalten ihre Positionen.`))) return;
|
||||
await api("leistungen/aktion", "POST", { ids: gewaehlt, aktion: "loeschen" });
|
||||
sdZustand.wahl.clear();
|
||||
} else return;
|
||||
zahlenNeu();
|
||||
await leistungenSeite();
|
||||
} catch (e) { hinweis.text = (e as Error).message; await leistungenSeite(); }
|
||||
});
|
||||
}
|
||||
|
||||
/** Leistungen in ein Angebot im Entwurf übernehmen, am Ende */
|
||||
async function insAngebot(ids: string[]): Promise<void> {
|
||||
const angebote = (await api<Zeile[]>("angebote-liste")).filter((a) => a.status === "entwurf");
|
||||
if (!angebote.length) { hinweis.text = "Es gibt kein Angebot im Entwurf. Lege zuerst im Projekt ein Angebot an."; return void (await stammdatenSeite()); }
|
||||
const r = await dialog(`${ids.length} ${ids.length === 1 ? "Leistung" : "Leistungen"} ins Angebot`, [
|
||||
{ name: "angebot", titel: "Angebot", art: "auswahl", optionen: angebote.map((a): [string, string] => [a.id, `${a.nummer} ${a.projekt_name ?? ""}`.trim()]), hilfe: "Die Positionen kommen ans Ende; Texte, Kalkulation und Mengenblatt kommen mit, die Preise rechnen mit den Sätzen des Angebots." },
|
||||
], { angebot: angebote[0]!.id }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
for (const id of ids) await api(`angebote/${r.daten.angebot}/einfuegen`, "POST", { was: "vorlage", vorlage_id: id });
|
||||
sdZustand.wahl.clear();
|
||||
location.hash = `angebot-${r.daten.angebot}`;
|
||||
}
|
||||
|
||||
// ---------- eine Leistung ----------
|
||||
|
||||
const ART_KURZ: [string, string][] = KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]);
|
||||
|
||||
export async function leistungSeite(id: string): Promise<void> {
|
||||
let d = await api<Zeile>(`leistungen/${id}`).catch(() => null);
|
||||
if (!d) { inhalt.innerHTML = '<p class="fehler">Diese Leistung gibt es nicht (mehr).</p><p><a href="#stammdaten">Zu den Stammdaten</a></p>'; return; }
|
||||
let v = structuredClone(d.leistung) as Mengenvorlage;
|
||||
v.inhalt = { ...alsBlatt(v.inhalt), ansaetze: v.inhalt.ansaetze ?? [] };
|
||||
const frei = !v.fest;
|
||||
const vorlagen = await alleVorlagen();
|
||||
const alleLeistungen = await api<Zeile[]>("leistungen");
|
||||
let meldung = "", blattAuf = v.inhalt.werte.length > 0 || v.inhalt.listen.length > 0;
|
||||
await kopf(`Leistung <span class="nummer">${esc(v.kurztext || v.name)}</span>`,
|
||||
`<button class="neben" data-a="kopie">${frei ? "Kopieren" : "Kopieren und ändern"}</button><button class="neben" data-a="ins-angebot">Ins Angebot …</button>${frei ? '<button class="neben gefahr" data-a="weg">Löschen</button>' : ""}<a class="knopf haupt" href="#stammdaten">Fertig</a>`,
|
||||
"leistungen", "stammdaten");
|
||||
const wurzel = document.createElement("div");
|
||||
inhalt.append(wurzel);
|
||||
|
||||
const zeichne = () => {
|
||||
const fokus = document.activeElement as HTMLInputElement | null;
|
||||
const k = fokus?.dataset?.k;
|
||||
const s = d!.saetze, e = d!.ergebnis;
|
||||
let a: Auswertung | null = null;
|
||||
try { a = werteBlatt(v.inhalt, umgebungVon(s)); } catch { a = null; }
|
||||
const einheit = v.einheit || "Einh.";
|
||||
const ordner = [...new Set(alleLeistungen.map((l) => l.gruppe))].sort();
|
||||
const feld = (key: string, wert: unknown, o: { titel: string; klasse?: string; platz?: string; liste?: string; typ?: string } ) =>
|
||||
`<input data-k="${key}" value="${esc(wert ?? "")}" class="${o.klasse ?? ""}" aria-label="${esc(o.titel)}" title="${esc(o.titel)}"${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.liste ? ` list="${o.liste}"` : ""}${o.typ ? ` inputmode="decimal"` : ""}${frei ? "" : " disabled"}>`;
|
||||
const kz = e.kostenzeilen as Zeile[];
|
||||
// Kostenzeilen nach Kostenart gruppiert, mit Zwischensumme je Art
|
||||
const arten = KOSTENARTEN.filter((x) => v.inhalt.ansaetze.some((z) => z.kostenart === x));
|
||||
const zeileHtml = (z: Ansatz, i: number) => {
|
||||
const lohn = z.kostenart === "lohn", fahrt = z.kostenart === "fahrt", mitPers = lohn || fahrt;
|
||||
const r = kz[i];
|
||||
const art = z.artikel_id ? d!.artikel[z.artikel_id] : null;
|
||||
const quelle = z.artikel_id ? (art ? marke(art.herkunft === "datanorm" ? "datanorm" : "eigen").replace("eigene", "eigener Artikel") : '<span class="marke schlecht">Artikel fehlt</span>')
|
||||
: !lohn && z.ek != null ? '<span class="marke gut">eigener Preis</span>' : "";
|
||||
const k = (f: string) => `vk:${i}:${f}`;
|
||||
return `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}">
|
||||
<td><select data-k="${k("kostenart")}" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ART_KURZ, z.kostenart)}</select></td>
|
||||
<td class="sd-bez">${feld(k("beschreibung"), z.beschreibung, { titel: z.kostenart === "material" ? "Material: Artikel suchen oder Text" : "Bezeichnung", klasse: `w-bez${z.kostenart === "material" ? " sd-artikel-suche" : ""}`, platz: z.kostenart === "material" ? "Artikel suchen …" : lohn ? "Tätigkeit" : "" })}
|
||||
${fahrt && r && !r.fehler ? `<span class="kz-rechnung">2 × ${esc(z.bezug ?? "")} km × ${zahlText(z.menge)} Tage</span>` : ""}</td>
|
||||
<td>${feld(k("bezug"), z.bezug, { titel: fahrt ? "Strecke einfach in km" : "Bezug (Kürzel aus dem Mengenblatt, leer = je Einheit)", klasse: `am-formel w-bezug${r?.fehler ? " mit-fehler" : ""}`, platz: fahrt ? "km" : `je ${einheit}`, liste: "sd-kuerzel" })}${r?.fehler ? `<span class="am-fehler">${esc(r.fehler)}</span>` : ""}</td>
|
||||
<td>${feld(k("menge"), zahlText(z.menge), { titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", klasse: "zahl w-ansatz am-eingabe", typ: "zahl" })}</td>
|
||||
<td>${mitPers ? feld(k("personen"), zahlText(z.personen ?? 1), { titel: fahrt ? "Fahrzeuge" : "Personen", klasse: "zahl w-pers am-eingabe", typ: "zahl" }) : ""}</td>
|
||||
<td>${lohn ? `<select data-k="${k("lohnart")}" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>`
|
||||
: fahrt ? "km" : feld(k("einheit"), z.einheit, { titel: "Einheit", klasse: "w-einheit", liste: "sd-einheiten" })}</td>
|
||||
<td>${feld(k("ek"), z.artikel_id ? euroFeld(art?.ek_je_einheit ?? z.ek) : euroFeld(z.ek), { titel: z.artikel_id ? "EK aus dem Materialstamm (ändern löst den Artikel)" : "EK je Einheit", klasse: "zahl w-ek", typ: "euro",
|
||||
platz: lohn ? euroFeld(s.stundensaetze[z.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00" })}</td>
|
||||
<td>${lohn || fahrt ? "" : feld(k("faktor"), zahlText(z.faktor ?? 1), { titel: "Faktor (z. B. Verschnitt)", klasse: "zahl w-faktor", typ: "zahl" })}</td>
|
||||
<td class="zahl">${r ? euroFeld(r.kosten) : ""}</td>
|
||||
<td class="sd-quelle">${quelle}</td>
|
||||
<td class="kz-aus"><input type="checkbox" data-k="${k("aktiv")}" ${z.aktiv === false ? "" : "checked"} aria-label="zählt mit"${frei ? "" : " disabled"}>${frei ? `<button class="weg" data-a="zeile-weg" data-i="${i}" title="Zeile löschen" aria-label="Zeile löschen">×</button>` : ""}</td></tr>`;
|
||||
};
|
||||
const rumpf = arten.map((art) => {
|
||||
const idx = v.inhalt.ansaetze.map((z, i) => [z, i] as const).filter(([z]) => z.kostenart === art);
|
||||
const summe = idx.reduce((x, [, i]) => x + (kz[i]?.aktiv ? kz[i]!.kosten : 0), 0);
|
||||
const std = art === "lohn" ? e.std_je_einheit : null;
|
||||
return `${idx.map(([z, i]) => zeileHtml(z, i)).join("")}<tr class="sd-zwischen"><td colspan="8">${KOSTENART_NAME[art]}${std ? ` ${zahlDeutsch(std, "h").replace(".", ",")} Std` : ""}</td><td class="zahl">${euroFeld(Math.round(summe))}</td><td colspan="2"></td></tr>`;
|
||||
}).join("");
|
||||
const ka = KOSTENARTEN.filter((x) => e.vk_je_einheit[x]);
|
||||
const kostenJe = (x: string) => kz.reduce((sum, r2, i) => sum + (r2.aktiv && v.inhalt.ansaetze[i]?.kostenart === x ? r2.kosten : 0), 0);
|
||||
const lohnK = kostenJe("lohn"), matK = kostenJe("material");
|
||||
const vkLohnstunde = e.std_je_einheit > 0 ? (e.ep - (e.kosten_je_einheit - lohnK)) / e.std_je_einheit : null;
|
||||
wurzel.innerHTML = `${kuerzelListe("sd-kuerzel", v.inhalt)}<datalist id="sd-einheiten">${["m", "m²", "m³", "St", "kg", "t", "h", "psch", "Pck", "l"].map((x) => `<option value="${x}">`).join("")}</datalist>
|
||||
<datalist id="sd-ordner">${ordner.map((o) => `<option value="${esc(o)}">`).join("")}</datalist>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
|
||||
${frei ? "" : '<p class="hinweis">Diese Leistung ist mitgeliefert. Mit „Kopieren und ändern“ wird sie deine eigene.</p>'}
|
||||
<div class="angebot-raster sd-leistung"><div class="am-haupt">
|
||||
<section class="karte sd-felder">
|
||||
<label>Kurztext${feld("v:kurztext", v.kurztext || v.name, { titel: "Kurztext" })}</label>
|
||||
<label>Langtext<textarea data-k="v:langtext" rows="4"${frei ? "" : " disabled"}>${esc(v.langtext ?? "")}</textarea></label>
|
||||
<div class="sd-felder-reihe"><label>Einheit${feld("v:einheit", v.einheit, { titel: "Einheit", klasse: "w-kurz", liste: "sd-einheiten" })}</label>
|
||||
<label class="sd-breit">Ordner${feld("v:gruppe", v.gruppe, { titel: "Ordner", liste: "sd-ordner", platz: "z. B. 03 Konstruktionen / Dachstuhl" })}</label>
|
||||
<label>${v.herkunft === "gaeb" ? "OZ aus GAEB" : "Nummer"}${feld("v:nummer", v.nummer, { titel: "Nummer / OZ", klasse: "w-oz" })}</label></div>
|
||||
<div class="sd-felder-reihe"><label class="sd-breit">Mengenvorlage<select data-k="v:mengenvorlage"${frei ? "" : " disabled"} aria-label="Mengenvorlage übernehmen">
|
||||
<option value="">${v.inhalt.vorlage ? `${esc(v.inhalt.vorlage.name)} (übernommen)` : v.inhalt.werte.length ? "eigenes Mengenblatt" : "– keine –"}</option>
|
||||
${vorlagen.filter((x) => x.art === "mengen" || (x.art === "muster" && x.inhalt.werte.length)).map((x) => `<option value="${esc(x.id)}">${esc(x.gruppe)}: ${esc(x.name)}</option>`).join("")}</select></label>
|
||||
<p class="hinweis-k">optional: fragt beim Einfügen ins Angebot die Eingaben ab und rechnet die Menge; Kürzel stehen als Bezug zur Verfügung.</p></div>
|
||||
</section>
|
||||
${v.inhalt.werte.length || v.inhalt.listen.length || blattAuf ? `<section class="karte"><details class="sd-block"${blattAuf ? " open" : ""}><summary><h3 class="am-h">Mengenblatt ${a?.menge != null ? `<span class="hinweis-k">Menge im Beispiel ${zahlDeutsch(a.menge, v.einheit).replace(".", ",")} ${esc(v.einheit ?? "")}</span>` : ""}</h3></summary>
|
||||
${a ? blattHtml(v.inhalt, a, { k: "vb:", frei, modus: "vorlage", einheit: v.einheit }) : '<p class="fehler">Das Mengenblatt enthält einen Fehler.</p>'}</details></section>`
|
||||
: frei ? '<p class="sd-blatt-neu"><button class="verweis" data-a="blatt-neu">+ Eigenes Mengenblatt anlegen</button></p>' : ""}
|
||||
<section class="karte"><div class="sd-block-kopf"><h3 class="am-h">Vorkalkulation <span class="hinweis-k">wie im Angebot</span></h3>
|
||||
<span class="hinweis-k">Kosten je ${esc(einheit)} <b>${euroFeld(e.kosten_je_einheit)} €</b> · ${zahlDeutsch(e.std_je_einheit, "h").replace(".", ",")} Std</span></div>
|
||||
<div class="kosten-rolle"><table class="kosten-tabelle sd-kosten"><thead><tr><th>Art</th><th>Bezeichnung</th><th>Bezug</th><th class="zahl">Ansatz</th><th class="zahl">Pers.</th><th>Lohnart / Einh.</th><th class="zahl">EK</th><th class="zahl">Faktor</th><th class="zahl">Kosten je ${esc(einheit)}</th><th>Quelle</th><th title="zählt mit">✓</th></tr></thead>
|
||||
<tbody>${rumpf || `<tr><td colspan="11" class="hinweis">Noch keine Kalkulation. ${e.ep ? `Es gilt der feste Preis ${euroFeld(e.ep)} €.` : ""} Mit Lohn, Material und weiteren Zeilen rechnet die Leistung ihren Preis selbst.</td></tr>`}</tbody>
|
||||
${rumpf ? `<tfoot><tr><td colspan="8">Kosten je ${esc(einheit)}</td><td class="zahl">${euroFeld(e.kosten_je_einheit)}</td><td colspan="2"></td></tr></tfoot>` : ""}</table></div>
|
||||
${frei ? `<div class="knopfreihe">${ART_KURZ.map(([x, t]) => `<button class="neben klein" data-a="zeile-neu" data-art="${x}">+ ${t}</button>`).join("")}</div>` : ""}
|
||||
<p class="hinweis-k">Menge = Bezug × Ansatz × Personen, ohne Bezug je ${esc(einheit)}. Material: in der Bezeichnung tippen und einen Artikel aus dem Materialstamm wählen, dann kommt der EK von dort. Fahrt: Bezug = Strecke einfach, Ansatz = Einsatztage, Pers. = Fahrzeuge.</p>
|
||||
</section>
|
||||
<section class="karte"><h3 class="am-h">Verkauf <span class="hinweis-k">EP ${euroFeld(e.ep)} € je ${esc(einheit)}${e.kosten_je_einheit ? ` · Überschuss ${zahlText(Math.round(((e.ep - e.kosten_je_einheit) / Math.max(1, e.ep)) * 10000) / 100)} %` : ""}</span></h3>
|
||||
${ka.length ? `<table class="kalk-tabelle"><thead><tr><th>Kostenart</th><th class="zahl">Kosten</th><th class="zahl">Zuschlag</th><th class="zahl">Wagnis, Gewinn, Ausfall</th><th class="zahl">VK je ${esc(einheit)}</th></tr></thead><tbody>
|
||||
${ka.map((x) => `<tr><td>${KOSTENART_NAME[x]}</td><td class="zahl">${euroFeld(Math.round(kostenJe(x)))}</td><td class="zahl">${zahlText(s.zuschlaege[x])} %</td><td class="zahl">${zahlText(s.wagnis + s.gewinn + s.ausfall)} %</td><td class="zahl">${euroFeld(Math.round(e.vk_je_einheit[x]))}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td>Summe</td><td class="zahl">${euroFeld(e.kosten_je_einheit)}</td><td></td><td></td><td class="zahl">${euroFeld(e.ep_kalkuliert)}</td></tr></tfoot></table>` : ""}
|
||||
<div class="sd-preis"><span>Einheitspreis kalkuliert <b>${ka.length ? `${euroFeld(e.ep_kalkuliert)} €` : "–"}</b></span>
|
||||
<label>${ka.length ? "Preis festlegen auf" : "Fester Preis"}${feld("v:ep_fest", euroFeld(v.ep_fest), { titel: "Preis festlegen auf", klasse: "zahl w-euro", typ: "euro", platz: ka.length ? "kalkuliert" : "0,00" })}</label></div>
|
||||
${ka.length && v.ep_fest != null && frei ? `<p class="hinweis-k">Es gilt der festgelegte Preis ${euroFeld(v.ep_fest)} €${v.herkunft === "gaeb" ? " aus der GAEB-Datei" : ""}, nicht der kalkulierte. <button class="verweis" data-a="ep-frei">Kalkulierten Preis nehmen</button></p>` : ""}
|
||||
<p class="hinweis-k">Zuschläge, Wagnis und Gewinn wie unter Einstellungen → Vorgaben der Angebote. Im Angebot rechnet die Leistung mit den Sätzen des Angebots weiter; die Stammdaten bleiben unberührt.</p>
|
||||
</section>
|
||||
</div>
|
||||
<aside class="angebot-seite">
|
||||
<section class="karte summen"><dl><dt>Kosten je ${esc(einheit)}</dt><dd>${euroFeld(e.kosten_je_einheit)} €</dd>
|
||||
${lohnK ? `<dt>davon Lohn</dt><dd>${euroFeld(Math.round(lohnK))} €</dd>` : ""}${matK ? `<dt>davon Material</dt><dd>${euroFeld(Math.round(matK))} €</dd>` : ""}
|
||||
<dt class="brutto">VK je ${esc(einheit)}</dt><dd class="brutto">${euroFeld(e.ep)} €</dd><dt>Std je ${esc(einheit)}</dt><dd>${zahlDeutsch(e.std_je_einheit, "h").replace(".", ",")}</dd>
|
||||
${vkLohnstunde && vkLohnstunde > 0 ? `<dt title="VK minus Material und sonstige Kosten, geteilt durch die Stunden">Verkauf je Lohnstunde</dt><dd>${euroFeld(Math.round(vkLohnstunde))} €</dd>` : ""}</dl></section>
|
||||
<section class="karte"><h3>Herkunft und Pflege</h3><dl class="sd-dl">
|
||||
<dt>Herkunft</dt><dd>${marke(v.fest ? "mitgeliefert" : v.herkunft ?? "eigen")}</dd>
|
||||
${v.quelle ? `<dt>Datei</dt><dd>${esc(v.quelle)}</dd>` : ""}${v.nummer ? `<dt>${v.herkunft === "gaeb" ? "OZ" : "Nummer"}</dt><dd>${esc(v.nummer)}</dd>` : ""}
|
||||
${v.geaendert_am ? `<dt>Bearbeitet</dt><dd>${dat(String(v.geaendert_am).slice(0, 10))}</dd>` : ""}
|
||||
<dt>In Angeboten</dt><dd>${d!.angebote.length ? `${d!.angebote.length}×, zuletzt <a href="#angebot-${esc(d!.angebote[0].id)}">${esc(d!.angebote[0].nummer)}</a>` : "noch nicht"}</dd></dl>
|
||||
<p class="hinweis-k">Material mit Artikel nimmt den EK aus dem Materialstamm: Neue Preise oder Rabatte rechnen diese Leistung neu. Bestehende Angebote behalten ihre Preise.</p></section>
|
||||
<section class="karte"><h3>Nachkalkulation</h3><p class="hinweis-k">Kommt mit Stufe 3c: Ist-Stunden je ${esc(einheit)} aus den Projekten neben dem Ansatz, z. B. Ansatz ${zahlDeutsch(e.std_je_einheit, "h").replace(".", ",")} Std, Ist im Schnitt aus den letzten Projekten.</p></section>
|
||||
</aside></div>`;
|
||||
if (k) wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`)?.focus();
|
||||
};
|
||||
|
||||
const speichern = async () => {
|
||||
if (!frei) return;
|
||||
await api(`mengenvorlagen/${id}`, "PATCH", {
|
||||
gruppe: v.gruppe, name: v.kurztext || v.name, kurztext: v.kurztext || v.name, langtext: v.langtext || null, einheit: v.einheit || null,
|
||||
nummer: v.nummer || null, ep_fest: v.ep_fest === "" || v.ep_fest == null ? null : Number(v.ep_fest), inhalt: v.inhalt,
|
||||
});
|
||||
d = await api<Zeile>(`leistungen/${id}`);
|
||||
v.geaendert_am = d!.leistung.geaendert_am;
|
||||
};
|
||||
const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); };
|
||||
zeichne();
|
||||
|
||||
// Material: Artikel aus dem Materialstamm suchen (Entwurf 2)
|
||||
let suchTimer: ReturnType<typeof setTimeout> | undefined;
|
||||
wurzel.addEventListener("input", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.classList.contains("sd-artikel-suche") || !frei) return;
|
||||
clearTimeout(suchTimer);
|
||||
suchTimer = setTimeout(async () => {
|
||||
const q = el.value.trim();
|
||||
if (q.length < 2) return menueSchliessen();
|
||||
const r = await api<Zeile>(`artikel-suche?q=${encodeURIComponent(q)}&limit=8`);
|
||||
if (document.activeElement !== el) return;
|
||||
const i = Number(el.dataset.k!.split(":")[1]);
|
||||
const m = menue(el, `<div class="fm-kopf"><b>Materialstamm · ${r.anzahl.toLocaleString("de-DE")} ${r.anzahl === 1 ? "Treffer" : "Treffer"}</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
|
||||
${r.zeilen.map((x: Zeile) => `<button type="button" class="fm-zeile sd-treffer" data-artikel="${esc(x.id)}"><span class="sd-t-name">${esc(x.bezeichnung)}<small>${esc([x.lieferant || "eigener Artikel", x.artikelnummer && `Art.-Nr. ${x.artikelnummer}`, x.stand && `Stand ${dat(x.stand)}`].filter(Boolean).join(" · "))}</small></span>
|
||||
<span class="sd-t-preis">${esc(x.einheit ?? "")} ${x.ek == null ? "–" : `${euroFeld(Math.round(Number(x.ek) / Number(x.preiseinheit || 1)))} €`}</span></button>`).join("") || '<p class="hinweis">Kein Artikel gefunden. Der Text bleibt als freie Bezeichnung.</p>'}
|
||||
<p class="hinweis-k">Preis je Einheit nach Rabatt</p>`, "sd-artikel-menue");
|
||||
m.addEventListener("click", async (e2) => {
|
||||
const b = (e2.target as HTMLElement).closest<HTMLElement>("[data-artikel]");
|
||||
if ((e2.target as HTMLElement).closest("[data-m]")) return menueSchliessen();
|
||||
if (!b) return;
|
||||
const x = r.zeilen.find((y: Zeile) => y.id === b.dataset.artikel)!;
|
||||
menueSchliessen();
|
||||
Object.assign(v.inhalt.ansaetze[i]!, { artikel_id: x.id, beschreibung: x.bezeichnung, einheit: x.einheit ?? v.inhalt.ansaetze[i]!.einheit, ek: null });
|
||||
try { await speichern(); zeichne(); } catch (er) { fehler(er); }
|
||||
});
|
||||
}, 250);
|
||||
});
|
||||
wurzel.addEventListener("change", async (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
const k = el.dataset?.k;
|
||||
if (!k) return;
|
||||
meldung = "";
|
||||
try {
|
||||
if (k === "v:mengenvorlage") {
|
||||
const mv = vorlagen.find((x) => String(x.id) === el.value);
|
||||
if (!mv) return;
|
||||
const { ansaetze: _a, ...blatt } = mv.inhalt;
|
||||
v.inhalt = { ...alsBlatt(blatt), vorlage: { id: String(mv.id), name: mv.name }, ansaetze: v.inhalt.ansaetze };
|
||||
if (!v.einheit && mv.einheit) v.einheit = mv.einheit;
|
||||
blattAuf = true;
|
||||
} else if (k.startsWith("v:")) {
|
||||
const f = k.slice(2);
|
||||
if (f === "gruppe" && !el.value.trim()) throw new Error("Der Ordner darf nicht leer sein.");
|
||||
if (f === "kurztext" && !el.value.trim()) throw new Error("Der Kurztext darf nicht leer sein.");
|
||||
if (f === "ep_fest") v.ep_fest = el.value.trim() ? parseEuro(el.value) : null;
|
||||
else (v as unknown as Zeile)[f] = el.value.trim();
|
||||
} else if (k.startsWith("vk:")) {
|
||||
const [, i, f] = k.split(":") as [string, string, string];
|
||||
const z = v.inhalt.ansaetze[Number(i)] as Ansatz & Record<string, unknown>;
|
||||
if (f === "aktiv") z.aktiv = 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; z.artikel_id = null; }
|
||||
else if (f === "beschreibung") {
|
||||
z.beschreibung = el.value.trim() || null;
|
||||
// Text von Hand geändert: Artikel bleibt nur, wenn der Name passt
|
||||
if (z.artikel_id && d!.artikel[z.artikel_id]?.bezeichnung !== z.beschreibung) z.artikel_id = null;
|
||||
} else z[f] = el.value.trim() || null;
|
||||
if (f === "kostenart") {
|
||||
z.lohnart = z.kostenart === "lohn" ? "geselle" : null;
|
||||
z.einheit = z.kostenart === "lohn" ? "h" : z.kostenart === "fahrt" ? "km" : z.einheit === "h" || z.einheit === "km" ? null : z.einheit;
|
||||
if (z.kostenart !== "material") z.artikel_id = 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 === "blatt-neu") {
|
||||
v.inhalt.werte.push({ kz: "L", bez: "Länge", einheit: v.einheit || "m", formel: "1", eingabe: true });
|
||||
v.inhalt.menge = "L";
|
||||
blattAuf = true;
|
||||
await speichern(); return zeichne();
|
||||
}
|
||||
if (a === "zeile-neu") {
|
||||
const art = b.dataset.art as Ansatz["kostenart"];
|
||||
v.inhalt.ansaetze.push({ kostenart: art, lohnart: art === "lohn" ? "geselle" : null, beschreibung: art === "fahrt" ? "Fahrt zur Baustelle" : "",
|
||||
bezug: art === "fahrt" ? null : v.inhalt.menge || null, menge: art === "lohn" ? 0.1 : 1, personen: 1, einheit: art === "lohn" ? "h" : art === "fahrt" ? "km" : v.einheit ?? null });
|
||||
await speichern(); zeichne();
|
||||
const neu = wurzel.querySelectorAll<HTMLInputElement>(`[data-k="vk:${v.inhalt.ansaetze.length - 1}:beschreibung"]`)[0];
|
||||
neu?.focus();
|
||||
return;
|
||||
}
|
||||
if (a === "ep-frei") { v.ep_fest = null; await speichern(); return zeichne(); }
|
||||
if (a === "zeile-weg") { v.inhalt.ansaetze.splice(Number(b.dataset.i), 1); await speichern(); return zeichne(); }
|
||||
} catch (e) { fehler(e); }
|
||||
});
|
||||
inhalt.querySelector(".kopf")!.addEventListener("click", async (ev) => {
|
||||
const a = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]")?.dataset.a;
|
||||
try {
|
||||
if (a === "ins-angebot") return await insAngebot([id]);
|
||||
if (a === "kopie") {
|
||||
await api("leistungen/aktion", "POST", { ids: [id], aktion: "kopieren" });
|
||||
const neu = (await api<Zeile[]>("leistungen")).filter((l) => !l.fest && l.gruppe === v.gruppe && (l.kurztext === (frei ? `${v.kurztext || v.name} (Kopie)` : v.kurztext || v.name)))
|
||||
.sort((x, y) => String(y.geaendert_am).localeCompare(String(x.geaendert_am)))[0];
|
||||
zahlenNeu();
|
||||
hinweis.gut = true;
|
||||
hinweis.text = frei ? "Kopie angelegt." : "Kopie angelegt. Sie gehört jetzt dir und lässt sich ändern.";
|
||||
location.hash = neu ? `leistung-${neu.id}` : "stammdaten";
|
||||
return;
|
||||
}
|
||||
if (a === "weg") {
|
||||
if (!(await bestaetigen(`Leistung „${v.kurztext || v.name}“ löschen? Angebote behalten ihre Positionen.`))) return;
|
||||
await api("leistungen/aktion", "POST", { ids: [id], aktion: "loeschen" });
|
||||
zahlenNeu();
|
||||
location.hash = "stammdaten";
|
||||
}
|
||||
} catch (e) { fehler(e); }
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Material ----------
|
||||
|
||||
const matZustand = { lieferant: null as string | null, warengruppe: null as string | null, merkliste: false, suche: "", gewaehlt: null as string | null };
|
||||
|
||||
async function materialSeite(): Promise<void> {
|
||||
const ue = await api<Zeile>("artikel-uebersicht");
|
||||
await kopf("Stammdaten", '<a class="knopf neben" href="#stammdaten-import">DATANORM einlesen</a><button class="haupt" data-a="artikel-neu">Neuer Artikel</button>', "material");
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "sd-raster";
|
||||
inhalt.append(raster);
|
||||
let treffer: Zeile = { anzahl: 0, zeilen: [] };
|
||||
const laden = async () => {
|
||||
const q = new URLSearchParams({ q: matZustand.suche, limit: "500" });
|
||||
if (matZustand.lieferant !== null) q.set("lieferant", matZustand.lieferant);
|
||||
if (matZustand.warengruppe !== null) q.set("warengruppe", matZustand.warengruppe);
|
||||
if (matZustand.merkliste) q.set("merkliste", "1");
|
||||
treffer = await api<Zeile>(`artikel-suche?${q}`);
|
||||
};
|
||||
const ekJe = (x: Zeile) => (x.ek == null ? null : Math.round(Number(x.ek) / Number(x.preiseinheit || 1)));
|
||||
const rabattVon = (x: Zeile) => (x.preisart === "netto" ? null : x.rabatt ?? x.gruppen_rabatt ?? null);
|
||||
const seiteHtml = () => {
|
||||
const an = (b: boolean) => (b ? " an" : "");
|
||||
return `<button class="sd-alle${an(matZustand.lieferant === null && matZustand.warengruppe === null && !matZustand.merkliste)}" data-m-alle>Alle Artikel <small>${ue.gesamt.toLocaleString("de-DE")}</small></button>
|
||||
<h3 class="gruppe">Lieferanten</h3>${ue.lieferanten.map((l: Zeile) => `<button class="sd-zeile${an(matZustand.lieferant === l.lieferant)}" data-lieferant="${esc(l.lieferant)}"><span>${esc(l.lieferant || "eigene Artikel")}</span><small>${l.anzahl.toLocaleString("de-DE")}</small></button>`).join("") || '<p class="hinweis-k">Noch keine</p>'}
|
||||
<h3 class="gruppe">Warengruppen</h3>${ue.warengruppen.slice(0, 40).map((w: Zeile) => `<button class="sd-zeile${an(matZustand.warengruppe === w.warengruppe)}" data-warengruppe="${esc(w.warengruppe)}"><span>${esc(w.warengruppe || "ohne Warengruppe")}</span><small>${w.anzahl.toLocaleString("de-DE")}</small></button>`).join("")}
|
||||
${ue.warengruppen.length > 40 ? '<p class="hinweis-k">weitere über die Suche</p>' : ""}
|
||||
<h3 class="gruppe">Merkliste</h3><button class="sd-zeile${an(matZustand.merkliste)}" data-merkliste><span>★ oft gebraucht</span><small>${ue.merkliste}</small></button>`;
|
||||
};
|
||||
const zeichne = async () => {
|
||||
const x = treffer;
|
||||
const g = matZustand.gewaehlt ? x.zeilen.find((z: Zeile) => z.id === matZustand.gewaehlt) : null;
|
||||
raster.innerHTML = `<aside class="karte sd-seite">${seiteHtml()}</aside>
|
||||
<section class="sd-spalte"><div class="karte sd-haupt"><div class="sd-suchleiste"><input type="search" class="sd-suche" placeholder="Artikel suchen (Bezeichnung, Art.-Nr., EAN) …" value="${esc(matZustand.suche)}" aria-label="Artikel suchen">
|
||||
${matZustand.lieferant !== null ? `<span class="chip"><span>Lieferant: ${esc(matZustand.lieferant || "eigene")}</span><button type="button" data-lieferant="${esc(matZustand.lieferant)}" aria-label="Filter entfernen">✕</button></span>` : ""}
|
||||
${matZustand.warengruppe !== null ? `<span class="chip"><span>Warengruppe: ${esc(matZustand.warengruppe || "ohne")}</span><button type="button" data-warengruppe="${esc(matZustand.warengruppe)}" aria-label="Filter entfernen">✕</button></span>` : ""}
|
||||
${matZustand.merkliste ? '<span class="chip"><span>nur ★ Merkliste</span><button type="button" data-merkliste aria-label="Filter entfernen">✕</button></span>' : ""}</div>
|
||||
<div class="sd-liste"></div>
|
||||
${x.anzahl > x.zeilen.length ? `<p class="hinweis-k sd-fuss">${x.zeilen.length.toLocaleString("de-DE")} von ${x.anzahl.toLocaleString("de-DE")} Artikeln geladen. Suche oder Lieferant/Warengruppe eingrenzen.</p>` : ""}
|
||||
<p class="hinweis-k sd-fuss">EK netto je Einheit nach Rabatt; eine Preiseinheit (z. B. je 100 St) wird umgerechnet.</p></div>
|
||||
${g ? `<div class="karte sd-artikel"><h3>${esc(g.bezeichnung)}</h3><dl class="sd-dl">
|
||||
${g.listenpreis != null && g.preisart === "brutto" ? `<dt>Listenpreis</dt><dd>${euroFeld(g.listenpreis)} € je ${g.preiseinheit > 1 ? `${g.preiseinheit} ` : ""}${esc(g.einheit ?? "")}</dd><dt>Rabatt</dt><dd>${rabattVon(g) == null ? "–" : `${zahlText(rabattVon(g))} %${g.rabatt == null ? ` (Gruppe ${esc(g.rabattgruppe ?? "")})` : " (eigener)"}`}</dd>` : ""}
|
||||
<dt>EK netto</dt><dd><b>${ekJe(g) == null ? "–" : `${euroFeld(ekJe(g))} € / ${esc(g.einheit ?? "")}`}</b></dd>
|
||||
${g.stand ? `<dt>Preis vom</dt><dd>${g.herkunft === "datanorm" ? "DATANORM " : ""}${dat(g.stand)}</dd>` : ""}
|
||||
${g.ek_vorher != null && g.ek != null && Number(g.ek_vorher) !== Number(g.ek) ? `<dt>vorher</dt><dd>${euroFeld(Math.round(Number(g.ek_vorher) / Number(g.preiseinheit || 1)))} € (${Number(g.ek) > Number(g.ek_vorher) ? "+" : ""}${zahlText(Math.round(((Number(g.ek) - Number(g.ek_vorher)) / Number(g.ek_vorher)) * 1000) / 10)} %)</dd>` : ""}
|
||||
${g.ean ? `<dt>EAN</dt><dd>${esc(g.ean)}</dd>` : ""}<dt>genutzt in</dt><dd class="sd-genutzt">…</dd></dl>
|
||||
${g.langtext ? `<p class="hinweis-k">${esc(g.langtext)}</p>` : ""}
|
||||
<div class="knopfreihe"><button class="neben klein" data-a="artikel-bearbeiten">${g.herkunft === "datanorm" ? "Rabatt ändern" : "Bearbeiten"}</button><button class="neben klein" data-a="merken">${g.merkliste ? "★ von der Merkliste" : "☆ auf die Merkliste"}</button>${g.herkunft === "eigen" ? '<button class="neben klein gefahr" data-a="artikel-weg">Löschen</button>' : ""}</div></div>` : ""}
|
||||
</section>`;
|
||||
raster.querySelector(".sd-liste")!.append(liste({
|
||||
schluessel: "stammdaten-material", einheit: ["Artikel", "Artikel"], klasse: "sd-tabelle", leer: ue.gesamt ? "Kein Artikel passt." : "Noch keine Artikel. DATANORM einlesen oder einen eigenen Artikel anlegen.",
|
||||
spalten: [
|
||||
{ id: "merk", titel: "Merkliste", fest: true, kopf: "★", wert: (a) => `<button class="sd-stern${a.merkliste ? " an" : ""}" data-merk="${esc(a.id)}" title="${a.merkliste ? "von der Merkliste" : "auf die Merkliste"}" aria-label="Merkliste">${a.merkliste ? "★" : "☆"}</button>` },
|
||||
{ id: "nummer", titel: "Art.-Nr.", wert: (a) => esc(a.artikelnummer || "–"), klasse: "sd-klein" },
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (a) => a.bezeichnung, wert: (a) => `<b>${esc(a.bezeichnung)}</b>${a.warengruppe ? `<span class="unter">${esc(a.warengruppe)}</span>` : ""}`, klasse: "sd-text" },
|
||||
{ id: "lieferant", titel: "Lieferant", wert: (a) => esc(a.lieferant || "–"), klasse: "optional sd-klein" },
|
||||
{ id: "einheit", titel: "Einheit", wert: (a) => esc(a.einheit ?? "") },
|
||||
{ id: "liste", titel: "Listenpreis", art: "zahl", wert: (a) => (a.preisart === "brutto" && a.listenpreis != null ? `${euroFeld(a.listenpreis)}${a.preiseinheit > 1 ? `<span class="unter">je ${a.preiseinheit}</span>` : ""}` : "–"), sortWert: (a) => Number(a.listenpreis ?? 0), klasse: "zahl optional" },
|
||||
{ id: "rabatt", titel: "Rabatt", art: "zahl", wert: (a) => (rabattVon(a) == null ? "–" : `${zahlText(rabattVon(a))} %`), sortWert: (a) => Number(rabattVon(a) ?? 0), klasse: "zahl optional" },
|
||||
{ id: "ek", titel: "EK netto", art: "zahl", wert: (a) => `<b>${ekJe(a) == null ? "–" : euroFeld(ekJe(a))}</b>`, sortWert: (a) => ekJe(a), klasse: "zahl" },
|
||||
{ id: "herkunft", titel: "Herkunft", text: (a) => (a.herkunft === "datanorm" ? "DATANORM" : "eigene"), wert: (a) => marke(a.herkunft) },
|
||||
],
|
||||
zeilen: x.zeilen, klick: (a) => { matZustand.gewaehlt = a.id; void zeichne(); },
|
||||
zeilenKlasse: (a) => (a.id === matZustand.gewaehlt ? "sd-gewaehlt" : ""),
|
||||
}));
|
||||
if (g) {
|
||||
const n = await api<Zeile[]>(`artikel/${g.id}/genutzt`);
|
||||
const ziel = raster.querySelector(".sd-genutzt");
|
||||
if (ziel) ziel.innerHTML = n.length ? n.slice(0, 5).map((l) => `<a href="#leistung-${esc(l.id)}">${esc(l.name)}</a>`).join(", ") + (n.length > 5 ? ` und ${n.length - 5} weitere` : "") : "keiner Leistung";
|
||||
}
|
||||
};
|
||||
await laden();
|
||||
await zeichne();
|
||||
|
||||
const artikelDialog = async (g: Zeile | null) => {
|
||||
const eigen = !g || g.herkunft === "eigen";
|
||||
const felder: Feld[] = eigen ? [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "artikelnummer", titel: "Artikelnummer" },
|
||||
{ name: "einheit", titel: "Einheit", hilfe: "m, m², m³, St, Pck, kg" }, { name: "warengruppe", titel: "Warengruppe", hilfe: "z. B. Bauholz / KVH" },
|
||||
{ name: "lieferant", titel: "Lieferant", hilfe: "leer = eigener Artikel ohne Lieferant" },
|
||||
{ name: "listenpreis", titel: "EK netto", art: "euro", pflicht: true, hilfe: "je Preiseinheit" },
|
||||
{ name: "preiseinheit", titel: "Preiseinheit", art: "auswahl", optionen: [["1", "je 1"], ["10", "je 10"], ["100", "je 100"], ["1000", "je 1000"]] },
|
||||
] : [{ name: "rabatt", titel: "Eigener Rabatt (%)", art: "zahl", hilfe: `Leer = Rabatt der Rabattgruppe ${g!.rabattgruppe ?? ""} des Lieferanten${g!.gruppen_rabatt != null ? ` (${zahlText(g!.gruppen_rabatt)} %)` : ""}. Der EK rechnet sich neu.` }];
|
||||
const r = await dialog(g ? (eigen ? "Artikel bearbeiten" : `Rabatt für ${g.bezeichnung}`) : "Neuer Artikel", felder,
|
||||
g ? { ...g, preiseinheit: String(g.preiseinheit), rabatt: g.rabatt == null ? null : Number(g.rabatt) } : { preiseinheit: "1", lieferant: "" }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
if (eigen) {
|
||||
const daten = { bezeichnung: r.daten.bezeichnung, artikelnummer: r.daten.artikelnummer || "", einheit: r.daten.einheit || null, warengruppe: r.daten.warengruppe || null,
|
||||
lieferant: r.daten.lieferant || "", listenpreis: r.daten.listenpreis, preisart: "netto", preiseinheit: Number(r.daten.preiseinheit || 1), herkunft: "eigen" };
|
||||
const neu = g ? await api<Zeile>(`artikel/${g.id}`, "PATCH", daten) : await api<Zeile>("artikel", "POST", daten);
|
||||
matZustand.gewaehlt = neu.id;
|
||||
} else await api(`artikel/${g!.id}`, "PATCH", { rabatt: r.daten.rabatt === null || r.daten.rabatt === "" ? null : Number(r.daten.rabatt) });
|
||||
zahlenNeu();
|
||||
await materialSeite();
|
||||
};
|
||||
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
raster.addEventListener("input", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.classList.contains("sd-suche")) return;
|
||||
matZustand.suche = el.value;
|
||||
clearTimeout(timer);
|
||||
timer = setTimeout(async () => {
|
||||
await laden();
|
||||
const pos = el.selectionStart;
|
||||
await zeichne();
|
||||
const neu = raster.querySelector<HTMLInputElement>(".sd-suche")!;
|
||||
neu.focus();
|
||||
neu.setSelectionRange(pos, pos);
|
||||
}, 300);
|
||||
});
|
||||
inhalt.addEventListener("click", async function klick(ev) {
|
||||
if (!document.body.contains(raster)) return inhalt.removeEventListener("click", klick);
|
||||
const t = ev.target as HTMLElement;
|
||||
const filter = t.closest<HTMLElement>("[data-lieferant],[data-warengruppe],[data-merkliste],[data-m-alle]");
|
||||
if (filter && !filter.closest(".liste")) {
|
||||
if (filter.dataset.mAlle !== undefined) Object.assign(matZustand, { lieferant: null, warengruppe: null, merkliste: false });
|
||||
else if (filter.dataset.lieferant !== undefined) matZustand.lieferant = matZustand.lieferant === filter.dataset.lieferant ? null : filter.dataset.lieferant;
|
||||
else if (filter.dataset.warengruppe !== undefined) matZustand.warengruppe = matZustand.warengruppe === filter.dataset.warengruppe ? null : filter.dataset.warengruppe;
|
||||
else matZustand.merkliste = !matZustand.merkliste;
|
||||
await laden();
|
||||
return zeichne();
|
||||
}
|
||||
const merk = t.closest<HTMLElement>("[data-merk]")?.dataset.merk;
|
||||
const a = t.closest<HTMLElement>("[data-a]")?.dataset.a;
|
||||
try {
|
||||
if (merk || a === "merken") {
|
||||
const z = treffer.zeilen.find((x: Zeile) => x.id === (merk ?? matZustand.gewaehlt));
|
||||
if (!z) return;
|
||||
await api(`artikel/${z.id}`, "PATCH", { merkliste: !z.merkliste });
|
||||
z.merkliste = !z.merkliste;
|
||||
ue.merkliste += z.merkliste ? 1 : -1;
|
||||
return zeichne();
|
||||
}
|
||||
if (a === "artikel-neu") return await artikelDialog(null);
|
||||
if (a === "artikel-bearbeiten") return await artikelDialog(treffer.zeilen.find((x: Zeile) => x.id === matZustand.gewaehlt) ?? null);
|
||||
if (a === "artikel-weg") {
|
||||
const z = treffer.zeilen.find((x: Zeile) => x.id === matZustand.gewaehlt);
|
||||
if (!z || !(await bestaetigen(`Artikel „${z.bezeichnung}“ löschen? Leistungen behalten den zuletzt bekannten Preis nicht: Die Zeile verliert ihren EK.`))) return;
|
||||
await api(`artikel/${z.id}`, "DELETE");
|
||||
matZustand.gewaehlt = null;
|
||||
zahlenNeu();
|
||||
return await materialSeite();
|
||||
}
|
||||
} catch (e) { hinweis.text = (e as Error).message; await materialSeite(); }
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Mengenvorlagen ----------
|
||||
|
||||
async function mengenSeite(): Promise<void> {
|
||||
const liste = (await alleVorlagen(true)).filter((v) => v.art === "mengen");
|
||||
await kopf("Stammdaten", '<button class="haupt" data-a="neu">Neue Mengenvorlage</button>', "mengen");
|
||||
const wurzel = document.createElement("div");
|
||||
inhalt.append(wurzel);
|
||||
const gruppen = [...new Set(liste.map((v) => v.gruppe))];
|
||||
wurzel.innerHTML = `<p class="hinweis">Mengenvorlagen rechnen die Menge einer Position aus Eingaben und Formeln (z. B. Dach, Wand mit W/G/F). Eine Leistung kann eine Mengenvorlage mitbringen; im Angebot stehen sie rechts unter „Mengen“.</p>
|
||||
${gruppen.map((g) => `<h2 class="am-gruppe">${esc(g)}</h2><ul class="dokumente">${liste.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.einheit ? `Menge in ${esc(v.einheit)}` : ""}${v.beschreibung ? ` · ${esc(v.beschreibung)}` : ""}</span></span><span class="marken">${marke(v.fest ? "mitgeliefert" : "eigen")}</span></a></li>`).join("")}</ul>`).join("") || '<p class="hinweis leer">Noch keine Mengenvorlage.</p>'}`;
|
||||
inhalt.querySelector('[data-a="neu"]')!.addEventListener("click", async () => {
|
||||
const r = await dialog("Neue Mengenvorlage", [
|
||||
{ name: "name", titel: "Name", pflicht: true }, { name: "gruppe", titel: "Gruppe", pflicht: true, hilfe: "z. B. Dach, Wand, Klempner / Blech" },
|
||||
{ name: "einheit", titel: "Einheit der Position", hilfe: "m, m², m³, St, psch" },
|
||||
], { einheit: "m" }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const neu = await api<Zeile>("mengenvorlagen", "POST", { name: r.daten.name, gruppe: r.daten.gruppe, 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: [] } });
|
||||
zahlenNeu();
|
||||
location.hash = `vorlage-${neu.id}`;
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Kataloge und Import ----------
|
||||
|
||||
/** Dateien lesen; ZIP-Archive werden entpackt */
|
||||
async function dateienLesen(dateien: FileList | File[]): Promise<{ name: string; text: string }[]> {
|
||||
const aus: { name: string; text: string }[] = [];
|
||||
for (const f of [...dateien]) {
|
||||
const b = new Uint8Array(await f.arrayBuffer());
|
||||
if (istZip(b)) for (const e of await entpacke(b)) aus.push({ name: e.name, text: dateiText(e.daten) });
|
||||
else aus.push({ name: f.name, text: dateiText(b) });
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
async function importSeite(): Promise<void> {
|
||||
const ue = await api<Zeile>("artikel-uebersicht");
|
||||
await kopf("Stammdaten", "", "import");
|
||||
const wurzel = document.createElement("div");
|
||||
wurzel.className = "sd-import";
|
||||
inhalt.append(wurzel);
|
||||
let dn: (Datanorm & { dateien: string[] }) | null = null;
|
||||
let gaebMeldung = "", dnMeldung = "", lieferant = "";
|
||||
const rabattEingabe: Record<string, string> = {};
|
||||
|
||||
const dnVorschau = () => {
|
||||
if (!dn) return "";
|
||||
const gruppen = new Map<string, number>();
|
||||
for (const a of dn.artikel) if (a.rabattgruppe) gruppen.set(a.rabattgruppe, (gruppen.get(a.rabattgruppe) ?? 0) + 1);
|
||||
for (const r of dn.rabatte) if (!gruppen.has(r.rabattgruppe)) gruppen.set(r.rabattgruppe, 0);
|
||||
const vorhanden = (rg: string) => ue.rabatte.find((r: Zeile) => r.lieferant === lieferant && r.rabattgruppe === rg)?.rabatt;
|
||||
const ausDatei = (rg: string) => dn!.rabatte.find((r) => r.rabattgruppe === rg)?.rabatt;
|
||||
const geloescht = dn.artikel.filter((a) => a.loeschen).length;
|
||||
const beispiel = dn.artikel.find((a) => !a.loeschen && a.listenpreis != null);
|
||||
return `<ol class="sd-schritte">
|
||||
<li><b>Dateien:</b> ${dn.dateien.map(esc).join(", ")}${dn.stand ? ` · Preisliste vom ${dat(dn.stand)}` : ""}${dn.version ? ` · DATANORM ${esc(dn.version)}` : ""}</li>
|
||||
<li><label class="sd-inline">Lieferant <input class="sd-lieferant" list="sd-lieferanten" value="${esc(lieferant)}" placeholder="z. B. Holzhandel Nord" aria-label="Lieferant"></label>
|
||||
<datalist id="sd-lieferanten">${ue.lieferanten.filter((l: Zeile) => l.lieferant).map((l: Zeile) => `<option value="${esc(l.lieferant)}">`).join("")}</datalist>
|
||||
<span class="hinweis-k">Artikel eines Lieferanten werden über die Artikelnummer erkannt und aktualisiert.</span></li>
|
||||
<li><b>Rabattgruppen</b> ${dn.rabatte.length ? "aus der .RAB-Datei, änderbar" : "aus den Artikeln; Rabatt in % eintragen (leer = kein Rabatt)"}:
|
||||
${gruppen.size ? `<div class="sd-rabatte">${[...gruppen].sort((a, b) => b[1] - a[1]).slice(0, 200).map(([rg, n]) => `<label>${esc(rg)} <small>${n} Art.</small>
|
||||
<span class="mit-einheit"><input class="zahl w-kurz" data-rg="${esc(rg)}" inputmode="decimal" value="${esc(rabattEingabe[rg] ?? zahlText(ausDatei(rg) ?? vorhanden(rg) ?? ""))}"> %</span></label>`).join("")}</div>` : '<span class="hinweis-k">keine</span>'}</li>
|
||||
<li><b>Vorschau:</b> ${dn.artikel.length - geloescht} Artikel${geloescht ? `, ${geloescht} entfallen` : ""}${dn.preise.length ? `, ${dn.preise.length} Preisänderungen` : ""}${dn.rabatte.length ? `, ${dn.rabatte.length} Rabattgruppen` : ""}${dn.uebersprungen ? ` (${dn.uebersprungen} Zeilen übersprungen)` : ""}.
|
||||
${beispiel ? `<br><span class="hinweis-k">Beispiel: ${esc(beispiel.artikelnummer)} ${esc(beispiel.bezeichnung)}, ${euroFeld(beispiel.listenpreis)} € je ${beispiel.preiseinheit > 1 ? `${beispiel.preiseinheit} ` : ""}${esc(beispiel.einheit ?? "")} ${beispiel.preisart === "netto" ? "netto" : `Liste, EK ${euroFeld(ekNetto(beispiel.listenpreis, "brutto", Number(String(rabattEingabe[beispiel.rabattgruppe ?? ""] ?? ausDatei(beispiel.rabattgruppe ?? "") ?? vorhanden(beispiel.rabattgruppe ?? "") ?? 0).replace(",", "."))))} €`}</span>` : ""}</li>
|
||||
<li><button class="haupt" data-a="dn-los"${lieferant.trim() ? "" : " disabled"}>Übernehmen</button> <span class="hinweis-k">Leistungen, die diese Artikel nutzen, rechnen sich neu. Angebote bleiben, wie sie sind.</span></li></ol>`;
|
||||
};
|
||||
|
||||
const zeichne = () => {
|
||||
wurzel.innerHTML = `<div class="sd-import-raster">
|
||||
<section class="karte"><h3>Leistungen aus GAEB</h3>
|
||||
<p class="hinweis-k">Leistungsverzeichnis als GAEB DA XML (.x81, .x83, .x84, .x86). Aus den Titeln werden Ordner, aus den Positionen Leistungen mit OZ, Kurztext, Langtext und Einheit; Preise (.x84) werden der feste Preis. Erneutes Einlesen aktualisiert die Texte, die Kalkulation bleibt.</p>
|
||||
<label class="sd-ablage" data-ziel="gaeb"><input type="file" accept=".x81,.x82,.x83,.x84,.x85,.x86,.xml,.zip" hidden data-datei="gaeb"><span>GAEB-Datei hierher ziehen oder <u>auswählen</u></span></label>
|
||||
<label class="sd-inline">Ordner davor (optional) <input class="sd-gaeb-ordner" placeholder="z. B. Zimmererarbeiten 3Plus" aria-label="Ordner davor"></label>
|
||||
${gaebMeldung ? `<div class="${gaebMeldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(gaebMeldung.replace(/^! /, ""))}</div>` : ""}</section>
|
||||
<section class="karte"><h3>Material aus DATANORM</h3>
|
||||
<p class="hinweis-k">DATANORM 4 oder 5 vom Händler: Artikel (.001), Preise (.002), Rabattgruppen (.RAB), auch als ZIP. Mehrere Dateien auf einmal wählen.</p>
|
||||
<label class="sd-ablage" data-ziel="datanorm"><input type="file" multiple hidden data-datei="datanorm"><span>DATANORM-Dateien hierher ziehen oder <u>auswählen</u></span></label>
|
||||
${dnVorschau()}
|
||||
${dnMeldung ? `<div class="${dnMeldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(dnMeldung.replace(/^! /, ""))}</div>` : ""}</section>
|
||||
<section class="karte"><h3>Rabatte je Lieferant</h3>
|
||||
${ue.rabatte.length ? `<table class="sd-rabatt-tabelle"><thead><tr><th>Lieferant</th><th>Rabattgruppe</th><th>Bezeichnung</th><th class="zahl">Rabatt</th></tr></thead><tbody>
|
||||
${ue.rabatte.map((r: Zeile) => `<tr><td>${esc(r.lieferant)}</td><td>${esc(r.rabattgruppe)}</td><td>${esc(r.bezeichnung ?? "")}</td><td class="zahl"><span class="mit-einheit"><input class="zahl w-kurz" data-rabatt-l="${esc(r.lieferant)}" data-rabatt-g="${esc(r.rabattgruppe)}" value="${zahlText(r.rabatt)}" inputmode="decimal" aria-label="Rabatt ${esc(r.rabattgruppe)}"> %</span></td></tr>`).join("")}</tbody></table>`
|
||||
: '<p class="hinweis-k">Noch keine Rabattgruppen. Sie kommen mit der .RAB-Datei oder beim Einlesen.</p>'}
|
||||
<p class="hinweis-k">Ein geänderter Rabatt rechnet den EK aller Artikel der Gruppe und die Leistungen damit neu.</p></section>
|
||||
<section class="karte"><h3>Plancraft</h3><p class="hinweis-k">Leistungen aus Plancraft kommen über den GAEB-Export (Leistungsverzeichnis → Export → GAEB XML). Die Kalkulation je Position übernehme ich, sobald ein Export mit Kalkulation vorliegt.</p></section></div>`;
|
||||
};
|
||||
zeichne();
|
||||
|
||||
const gaebLesen = async (dateien: FileList | File[]) => {
|
||||
try {
|
||||
const ordner = wurzel.querySelector<HTMLInputElement>(".sd-gaeb-ordner")?.value.trim() || undefined;
|
||||
let neu = 0, akt = 0;
|
||||
const namen: string[] = [];
|
||||
for (const f of await dateienLesen(dateien)) {
|
||||
if (!/\.(x8\d|xml)$/i.test(f.name) && !f.text.includes("<GAEB")) continue;
|
||||
const r = await api<Zeile>("leistungen/gaeb", "POST", { dateiname: f.name.split("/").pop(), text: f.text, ordner });
|
||||
neu += r.neu; akt += r.aktualisiert; namen.push(`${f.name.split("/").pop()} (${r.titel} Titel${r.mit_preis ? `, ${r.mit_preis} mit Preis` : ""})`);
|
||||
}
|
||||
if (!namen.length) throw new Error("Keine GAEB-XML-Datei gefunden. Bitte als GAEB DA XML (.x81, .x83, .x84) exportieren.");
|
||||
gaebMeldung = `${namen.join(", ")}: ${neu} Leistungen neu, ${akt} aktualisiert. Sie stehen unter Leistungen in ihren Ordnern.`;
|
||||
zahlenNeu();
|
||||
} catch (e) { gaebMeldung = `! ${(e as Error).message}`; }
|
||||
zeichne();
|
||||
};
|
||||
const dnLesen = async (dateien: FileList | File[]) => {
|
||||
try {
|
||||
const texte = await dateienLesen(dateien);
|
||||
const d = leseDatanorm(texte.map((t) => t.text));
|
||||
dn = { ...d, dateien: texte.map((t) => t.name.split("/").pop()!) };
|
||||
lieferant = lieferant || (d.absender ?? "");
|
||||
for (const k of Object.keys(rabattEingabe)) delete rabattEingabe[k];
|
||||
dnMeldung = "";
|
||||
} catch (e) { dn = null; dnMeldung = `! ${(e as Error).message}`; }
|
||||
zeichne();
|
||||
};
|
||||
const dnUebernehmen = async () => {
|
||||
if (!dn || !lieferant.trim()) return;
|
||||
const knopf = wurzel.querySelector<HTMLButtonElement>('[data-a="dn-los"]')!;
|
||||
knopf.disabled = true;
|
||||
try {
|
||||
// Rabatte aus den Eingaben (leer = keiner)
|
||||
const rabatte = Array.from(wurzel.querySelectorAll<HTMLInputElement>("input[data-rg]"), (el) => [el.dataset.rg!, el.value.trim()] as const)
|
||||
.filter(([, w]) => w !== "").map(([rg, w]) => ({ rabattgruppe: rg, rabatt: Math.min(100, Math.max(0, Number(w.replace(",", ".")) || 0)), bezeichnung: dn!.rabatte.find((r) => r.rabattgruppe === rg)?.bezeichnung ?? null }));
|
||||
const summe = { neu: 0, geaendert: 0, neuer_preis: 0, geloescht: 0 };
|
||||
const pakete = Math.max(1, Math.ceil(dn.artikel.length / 2000));
|
||||
for (let i = 0; i < pakete; i++) {
|
||||
knopf.textContent = `Übernehme … ${Math.round((i / pakete) * 100)} %`;
|
||||
const r = await api<Zeile>("artikel/import", "POST", {
|
||||
lieferant: lieferant.trim(), stand: dn.stand, rabatte: i === 0 ? rabatte : [], artikel: dn.artikel.slice(i * 2000, (i + 1) * 2000),
|
||||
preise: i === pakete - 1 ? dn.preise : [],
|
||||
});
|
||||
for (const k of Object.keys(summe) as (keyof typeof summe)[]) summe[k] += r[k] ?? 0;
|
||||
}
|
||||
dnMeldung = `${lieferant}: ${summe.neu} Artikel neu, ${summe.geaendert} aktualisiert, davon ${summe.neuer_preis} mit neuem Preis${summe.geloescht ? `, ${summe.geloescht} gelöscht` : ""}. Die Leistungen mit diesen Artikeln rechnen mit den neuen Preisen.`;
|
||||
dn = null;
|
||||
zahlenNeu();
|
||||
Object.assign(ue, await api<Zeile>("artikel-uebersicht"));
|
||||
} catch (e) { dnMeldung = `! ${(e as Error).message}`; }
|
||||
zeichne();
|
||||
};
|
||||
|
||||
wurzel.addEventListener("change", async (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset.datei === "gaeb" && el.files?.length) return gaebLesen(el.files);
|
||||
if (el.dataset.datei === "datanorm" && el.files?.length) return dnLesen(el.files);
|
||||
if (el.classList.contains("sd-lieferant")) { lieferant = el.value; return zeichne(); }
|
||||
if (el.dataset.rg) { rabattEingabe[el.dataset.rg] = el.value; return zeichne(); }
|
||||
if (el.dataset.rabattL) {
|
||||
const w = el.value.trim();
|
||||
try {
|
||||
await api("lieferanten-rabatte/setzen", "POST", { lieferant: el.dataset.rabattL, rabattgruppe: el.dataset.rabattG, rabatt: w === "" ? null : Number(w.replace(",", ".")) });
|
||||
Object.assign(ue, await api<Zeile>("artikel-uebersicht"));
|
||||
dnMeldung = `Rabatt ${el.dataset.rabattG} gespeichert; EK und Leistungen sind neu gerechnet.`;
|
||||
} catch (e) { dnMeldung = `! ${(e as Error).message}`; }
|
||||
zeichne();
|
||||
}
|
||||
});
|
||||
wurzel.addEventListener("click", (ev) => {
|
||||
if ((ev.target as HTMLElement).closest('[data-a="dn-los"]')) void dnUebernehmen();
|
||||
});
|
||||
wurzel.addEventListener("dragover", (ev) => {
|
||||
const z = (ev.target as HTMLElement).closest<HTMLElement>(".sd-ablage");
|
||||
if (!z) return;
|
||||
ev.preventDefault();
|
||||
z.classList.add("an");
|
||||
});
|
||||
wurzel.addEventListener("dragleave", (ev) => (ev.target as HTMLElement).closest?.(".sd-ablage")?.classList.remove("an"));
|
||||
wurzel.addEventListener("drop", (ev) => {
|
||||
const z = (ev.target as HTMLElement).closest<HTMLElement>(".sd-ablage");
|
||||
if (!z || !ev.dataTransfer?.files.length) return;
|
||||
ev.preventDefault();
|
||||
z.classList.remove("an");
|
||||
if (z.dataset.ziel === "gaeb") void gaebLesen(ev.dataTransfer.files); else void dnLesen(ev.dataTransfer.files);
|
||||
});
|
||||
}
|
||||
@@ -61,8 +61,8 @@ main { flex: 1; min-width: 0; padding: 22px 28px; max-width: 1280px; }
|
||||
h2 { font-size: 16px; margin: 26px 0 10px; }
|
||||
.leiste { display: flex; gap: 8px; margin-bottom: 14px; align-items: center; flex-wrap: wrap; }
|
||||
.leiste select, .leiste input { padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 8px; padding: 10px 18px; font: inherit; font-weight: 600; cursor: pointer; }
|
||||
button.haupt:hover { background: var(--akzent-hover); }
|
||||
button.haupt, a.knopf.haupt { display: inline-block; text-decoration: none; background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 8px; padding: 10px 18px; font: inherit; font-weight: 600; cursor: pointer; }
|
||||
button.haupt:hover, a.knopf.haupt:hover { background: var(--akzent-hover); }
|
||||
button.neben, a.neben { display: inline-block; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 8px; padding: 8px 14px; font: inherit; cursor: pointer; text-decoration: none; }
|
||||
button.neben:hover, a.neben:hover { border-color: var(--leise); }
|
||||
|
||||
@@ -797,7 +797,7 @@ table.kalk-tabelle tfoot td { font-weight: 600; border-bottom: 0; }
|
||||
.saetze-mehr .hinweis { font-size: 13px; margin: 6px 0 0; }
|
||||
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::before { content: "\2022"; 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; }
|
||||
@@ -944,8 +944,8 @@ details.am-spalten > summary { cursor: pointer; color: var(--akzent); }
|
||||
.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 { display: flex; flex-wrap: wrap; gap: 0; border-bottom: 1px solid var(--linie); margin: -4px -4px 10px; }
|
||||
.m-seite .reiter-k button { background: none; border: 0; padding: 6px 7px; white-space: nowrap; 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; }
|
||||
@@ -961,8 +961,8 @@ details.am-spalten > summary { cursor: pointer; color: var(--akzent); }
|
||||
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: "▸"; }
|
||||
details.am-vorgaben > summary h3::after { content: "\25BE"; color: var(--akzent); margin-left: auto; }
|
||||
details.am-vorgaben:not([open]) > summary h3::after { content: "\25B8"; }
|
||||
.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; }
|
||||
@@ -999,3 +999,113 @@ table.kosten-tabelle tr.kz-fahrt td:first-child { box-shadow: inset 3px 0 0 var(
|
||||
table.kosten-tabelle .kz-rechnung { display: block; font-size: 11.5px; color: var(--leise); margin-top: 2px; white-space: nowrap; }
|
||||
.kosten-rolle table.kosten-tabelle input, .kosten-rolle table.kosten-tabelle select { padding-left: 5px; padding-right: 5px; font-size: 13px; }
|
||||
.kosten-rolle table.kosten-tabelle select { padding-left: 3px; padding-right: 0; }
|
||||
|
||||
/* Stammdaten (0.18, Entwürfe 1–4): Ordner links, Liste rechts; Leistung wie die Angebotsmaske */
|
||||
.sd-teile { padding: 0; margin: -6px 0 14px; }
|
||||
.sd-raster { display: grid; grid-template-columns: 250px minmax(0, 1fr); gap: 16px; align-items: start; }
|
||||
.sd-seite { display: flex; flex-direction: column; gap: 2px; padding: 10px; position: sticky; top: 12px; max-height: calc(100vh - 24px); overflow-y: auto; }
|
||||
.sd-seite h3.gruppe { margin: 10px 4px 4px; padding: 6px 0 4px; }
|
||||
.sd-alle, .sd-zeile, .sd-herkunft, .sd-ordner { display: flex; align-items: center; gap: 8px; width: 100%; background: none; border: 0; border-radius: 7px; padding: 6px 8px; font: inherit; font-size: 14px; color: inherit; text-align: left; cursor: pointer; }
|
||||
.sd-alle { font-weight: 600; }
|
||||
.sd-zeile > span:first-child, .sd-herkunft > span:not(.marke), .sd-ordner { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.sd-alle small, .sd-zeile small, .sd-herkunft small, .sd-knoten small { margin-left: auto; color: var(--leise); font-size: 12px; font-variant-numeric: tabular-nums; }
|
||||
.sd-alle:hover, .sd-zeile:hover, .sd-herkunft:hover, .sd-knoten:hover { background: var(--bg); }
|
||||
.sd-alle.an, .sd-zeile.an, .sd-herkunft.an, .sd-knoten.an { background: var(--akzent-hell); color: var(--akzent); }
|
||||
.sd-herkunft .marke { font-size: 11px; padding: 1px 7px; }
|
||||
.sd-baum, .sd-baum ul { list-style: none; margin: 0; padding: 0; }
|
||||
.sd-baum ul { padding-left: 14px; }
|
||||
.sd-knoten { display: flex; align-items: center; gap: 2px; border-radius: 7px; padding-right: 8px; }
|
||||
.sd-knoten .sd-ordner { padding: 5px 4px; background: none; }
|
||||
.sd-knoten.an .sd-ordner { font-weight: 600; color: inherit; }
|
||||
.sd-pfeil { width: 20px; flex: none; background: none; border: 0; padding: 0; color: var(--leise); font: inherit; font-size: 12px; cursor: pointer; text-align: center; }
|
||||
.sd-haupt { padding: 0; overflow: hidden; }
|
||||
.sd-suchleiste { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; padding: 12px 14px; border-bottom: 1px solid var(--linie); }
|
||||
.sd-suche { flex: 1 1 260px; min-width: 0; padding: 8px 11px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.sd-auswahl { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; padding: 9px 14px; background: var(--akzent-hell); color: var(--text); font-size: 14px; border-bottom: 1px solid var(--linie); }
|
||||
.sd-auswahl b { margin-right: 6px; }
|
||||
.sd-auswahl[hidden] { display: none; }
|
||||
.sd-liste { padding: 0 14px 6px; min-width: 0; }
|
||||
.sd-tabelle td.sd-wahl, .sd-tabelle th.sd-wahl { width: 34px; }
|
||||
.sd-lang { max-width: 40ch; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
td.sd-klein { font-size: 13px; color: var(--leise); white-space: nowrap; }
|
||||
.sd-tabelle td.sd-text { min-width: 16em; }
|
||||
.sd-fuss { padding: 0 14px 12px; }
|
||||
tr.sd-gewaehlt td { background: var(--akzent-hell); }
|
||||
.sd-stern { background: none; border: 0; padding: 2px 4px; font: inherit; font-size: 16px; color: var(--leise); cursor: pointer; }
|
||||
.sd-stern.an { color: var(--holz); }
|
||||
.marke.gaeb { background: var(--art-lohn-bg); color: var(--art-lohn); }
|
||||
.marke.datanorm { background: var(--art-mat-bg); color: var(--art-mat); }
|
||||
.sd-spalte { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
|
||||
.sd-artikel h3 { margin: 0 0 8px; font-size: 16px; }
|
||||
.sd-dl { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: 4px 14px; margin: 0 0 8px; font-size: 14px; }
|
||||
.sd-dl dt { color: var(--leise); }
|
||||
.sd-dl dd { margin: 0; }
|
||||
.sd-artikel-menue { max-width: min(460px, calc(100vw - 32px)); }
|
||||
.sd-treffer { justify-content: space-between; }
|
||||
.sd-treffer .sd-t-name { width: auto !important; flex: 1; display: block !important; color: var(--text) !important; min-width: 0; }
|
||||
.sd-treffer .sd-t-name small { display: block; color: var(--leise); font-size: 12px; }
|
||||
.sd-treffer .sd-t-preis { width: auto !important; white-space: nowrap; color: var(--text) !important; font-variant-numeric: tabular-nums; }
|
||||
/* eine Leistung */
|
||||
.sd-leistung .am-haupt { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
|
||||
.sd-felder { display: flex; flex-direction: column; gap: 10px; }
|
||||
.sd-felder label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; }
|
||||
.sd-felder-reihe { display: flex; gap: 12px; flex-wrap: wrap; align-items: flex-end; }
|
||||
.sd-felder-reihe > label { flex: 0 1 auto; }
|
||||
.sd-felder-reihe > .sd-breit { flex: 1 1 240px; }
|
||||
.sd-felder-reihe .hinweis-k { flex: 1 1 220px; margin: 0; }
|
||||
.angebot-raster input.w-oz { width: 9em; }
|
||||
.sd-block > summary { cursor: pointer; list-style: none; }
|
||||
.sd-block > summary::-webkit-details-marker { display: none; }
|
||||
.sd-block > summary h3 { display: inline-flex; gap: 10px; align-items: baseline; margin: 0; }
|
||||
.sd-block > summary h3::before { content: "\25B8"; color: var(--leise); }
|
||||
.sd-block[open] > summary h3::before { content: "\25BE"; }
|
||||
.sd-block-kopf { display: flex; justify-content: space-between; align-items: baseline; gap: 12px; flex-wrap: wrap; margin-bottom: 8px; }
|
||||
.sd-block-kopf h3 { margin: 0; }
|
||||
.sd-blatt-neu { margin: -4px 0 0; }
|
||||
.sd-kosten td.sd-bez { min-width: 9em; }
|
||||
.kosten-rolle table.sd-kosten input.w-bez { width: 15em; }
|
||||
.sd-kosten td.sd-quelle .marke { font-size: 11px; padding: 1px 7px; }
|
||||
.sd-kosten tr.sd-zwischen td { font-size: 12.5px; color: var(--leise); border-top: 0; padding-top: 2px; padding-bottom: 8px; }
|
||||
.sd-kosten tr.sd-zwischen td.zahl { font-weight: 600; color: var(--text); }
|
||||
.sd-preis { display: flex; justify-content: space-between; align-items: flex-end; gap: 14px; flex-wrap: wrap; margin-top: 10px; padding-top: 10px; border-top: 1px solid var(--linie); }
|
||||
.sd-preis label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); }
|
||||
/* Import */
|
||||
.sd-import-raster { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px; align-items: start; }
|
||||
.sd-import-raster h3 { margin: 0 0 6px; }
|
||||
.sd-ablage { display: grid; place-items: center; min-height: 92px; margin: 12px 0; border: 2px dashed var(--linie); border-radius: 10px; color: var(--leise); text-align: center; padding: 14px; cursor: pointer; }
|
||||
.sd-ablage:hover, .sd-ablage.an { border-color: var(--akzent); background: var(--akzent-hell); color: var(--akzent); }
|
||||
.sd-inline { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; font-size: 14px; }
|
||||
.sd-inline input, .sd-rabatte input, .sd-rabatt-tabelle input { padding: 6px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; min-width: 0; }
|
||||
.sd-inline input { flex: 1 1 200px; }
|
||||
.sd-rabatte input, .sd-rabatt-tabelle input { width: 4.5em; text-align: right; }
|
||||
.sd-schritte { margin: 12px 0 0; padding-left: 20px; display: flex; flex-direction: column; gap: 10px; font-size: 14px; }
|
||||
.sd-rabatte { display: flex; flex-wrap: wrap; gap: 8px 14px; margin-top: 6px; max-height: 220px; overflow-y: auto; }
|
||||
.sd-rabatte label { display: flex; gap: 6px; align-items: center; }
|
||||
.sd-rabatte small { color: var(--leise); }
|
||||
.sd-rabatt-tabelle { width: 100%; border-collapse: collapse; font-size: 14px; }
|
||||
.sd-rabatt-tabelle th, .sd-rabatt-tabelle td { padding: 5px 6px; border-bottom: 1px solid var(--linie); text-align: left; }
|
||||
.sd-rabatt-tabelle .zahl { text-align: right; }
|
||||
@media (max-width: 900px) {
|
||||
.sd-raster, .sd-import-raster { grid-template-columns: 1fr; }
|
||||
.sd-seite { position: static; max-height: 260px; }
|
||||
.sd-tabelle td.sd-text { min-width: 12em; }
|
||||
.sd-lang { max-width: 26ch; }
|
||||
}
|
||||
|
||||
/* Angebot: Reiter Leistungen und Material, KI-Vorschlag (0.18) */
|
||||
.am-suchreihe { display: flex; gap: 6px; margin: 4px 0 8px; }
|
||||
.m-seite .am-suchreihe input.suche { margin: 0; flex: 1 1 55%; }
|
||||
.m-seite .am-suchreihe select { flex: 1 1 45%; min-width: 0; }
|
||||
.am-ki { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--linie); }
|
||||
.am-ki > summary { cursor: pointer; display: flex; gap: 8px; align-items: baseline; }
|
||||
.am-ki > summary .hinweis-k { margin: 0; }
|
||||
.am-ki textarea { margin-top: 8px; }
|
||||
.am-ki-knoepfe { display: flex; gap: 10px; align-items: center; margin: 8px 0; }
|
||||
.am-ki-liste { list-style: none; margin: 8px 0; padding: 0; display: flex; flex-direction: column; gap: 6px; max-height: 360px; overflow-y: auto; }
|
||||
.am-ki-liste li { display: flex; gap: 8px; align-items: flex-start; justify-content: space-between; border: 1px solid var(--linie); border-radius: 8px; padding: 6px 8px; font-size: 13.5px; }
|
||||
.am-ki-liste label { display: flex; gap: 7px; align-items: flex-start; min-width: 0; flex: 1; }
|
||||
.angebot-raster .am-ki-liste label input[type="checkbox"] { width: 16px; height: 16px; padding: 0; margin-top: 2px; flex: none; }
|
||||
.am-ki-liste small { display: block; color: var(--leise); font-size: 12px; }
|
||||
.am-ki-liste .mit-einheit { flex: none; display: flex; align-items: center; gap: 4px; font-size: 12.5px; color: var(--leise); }
|
||||
.am-ki-liste .mit-einheit input { width: 5em; padding: 4px 6px; }
|
||||
button.haupt.klein { padding: 6px 12px; font-size: 14px; }
|
||||
|
||||
37
src/web/zip.ts
Normal file
37
src/web/zip.ts
Normal file
@@ -0,0 +1,37 @@
|
||||
// ZIP-Archive im Browser entpacken (DATANORM kommt oft als ZIP). Liest das Inhaltsverzeichnis am Ende der Datei;
|
||||
// „deflate“ entpackt der Browser selbst (DecompressionStream), „stored“ wird nur kopiert.
|
||||
|
||||
export interface ZipEintrag { name: string; daten: Uint8Array }
|
||||
|
||||
const u16 = (b: Uint8Array, i: number) => b[i]! | (b[i + 1]! << 8);
|
||||
const u32 = (b: Uint8Array, i: number) => (b[i]! | (b[i + 1]! << 8) | (b[i + 2]! << 16) | (b[i + 3]! << 24)) >>> 0;
|
||||
|
||||
export const istZip = (b: Uint8Array) => b.length > 4 && u32(b, 0) === 0x04034b50;
|
||||
|
||||
async function inflate(daten: Uint8Array): Promise<Uint8Array> {
|
||||
const strom = new Blob([daten as BlobPart]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
|
||||
return new Uint8Array(await new Response(strom).arrayBuffer());
|
||||
}
|
||||
|
||||
export async function entpacke(b: Uint8Array): Promise<ZipEintrag[]> {
|
||||
let ende = -1;
|
||||
for (let i = b.length - 22; i >= Math.max(0, b.length - 65557); i--) if (u32(b, i) === 0x06054b50) { ende = i; break; }
|
||||
if (ende < 0) throw new Error("Das ZIP-Archiv ist beschädigt (kein Inhaltsverzeichnis).");
|
||||
const anzahl = u16(b, ende + 10);
|
||||
let p = u32(b, ende + 16);
|
||||
const aus: ZipEintrag[] = [];
|
||||
for (let n = 0; n < anzahl; n++) {
|
||||
if (u32(b, p) !== 0x02014b50) throw new Error("Das ZIP-Archiv ist beschädigt.");
|
||||
const methode = u16(b, p + 10), groesse = u32(b, p + 20), nameLaenge = u16(b, p + 28), extra = u16(b, p + 30), kommentar = u16(b, p + 32);
|
||||
const lokal = u32(b, p + 42);
|
||||
const name = new TextDecoder().decode(b.subarray(p + 46, p + 46 + nameLaenge));
|
||||
p += 46 + nameLaenge + extra + kommentar;
|
||||
if (name.endsWith("/")) continue;
|
||||
const start = lokal + 30 + u16(b, lokal + 26) + u16(b, lokal + 28);
|
||||
const roh = b.subarray(start, start + groesse);
|
||||
if (methode === 0) aus.push({ name, daten: roh });
|
||||
else if (methode === 8) aus.push({ name, daten: await inflate(roh) });
|
||||
else throw new Error(`„${name}“ ist mit einem unbekannten Verfahren gepackt.`);
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
Reference in New Issue
Block a user