+ Dokument mit Belegkette und GAEB-Import X/P/D 81–86 (0.28.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:
87
src/domain/belege.ts
Normal file
87
src/domain/belege.ts
Normal file
@@ -0,0 +1,87 @@
|
||||
// Dokumentarten im Projekt und die Belegkette A10 (Henning „baue das so“, 22.10.2026): „+ Dokument“ zeigt alle Arten,
|
||||
// grau mit Grund, wenn das Vorgängerdokument fehlt; „erstellen aus …“ bietet nur, was zum Stand des Projekts passt.
|
||||
// Hauptkette Anfrage → (KVA) → Angebot → AB; aus der AB Nachtrag, Lieferschein, Bestellschein; aus dem Angebot die
|
||||
// Ausschreibung an Subunternehmer. Rechnungen bleiben extern.
|
||||
|
||||
export const BELEGARTEN = ["kostenvoranschlag", "angebot", "nachtrag", "auftragsbestaetigung", "lieferschein", "ausschreibung", "bestellschein"] as const;
|
||||
export type Belegart = (typeof BELEGARTEN)[number];
|
||||
|
||||
export interface BelegInfo {
|
||||
name: string;
|
||||
/** Nummernkreis je Belegart (A10); das Angebot behält die Projektnummer A-26-… */
|
||||
praefix: string;
|
||||
gruppe: "kunde" | "sub";
|
||||
/** ohne das gibt es die Art noch nicht */
|
||||
braucht: null | "auftrag" | "angenommen";
|
||||
/** Vorgänger, aus denen übernommen werden kann */
|
||||
aus: Belegart[];
|
||||
/** nur angenommene Vorgänger vom Typ Angebot/Nachtrag */
|
||||
nurAngenommen: boolean;
|
||||
/** wird angenommen (→ Auftrag) statt nur versendet */
|
||||
annehmbar: boolean;
|
||||
}
|
||||
|
||||
export const BELEG: Record<Belegart, BelegInfo> = {
|
||||
kostenvoranschlag: { name: "Kostenvoranschlag", praefix: "KV", gruppe: "kunde", braucht: null, aus: [], nurAngenommen: false, annehmbar: false },
|
||||
angebot: { name: "Angebot", praefix: "A", gruppe: "kunde", braucht: null, aus: ["kostenvoranschlag"], nurAngenommen: false, annehmbar: true },
|
||||
nachtrag: { name: "Nachtragsangebot", praefix: "NA", gruppe: "kunde", braucht: "auftrag", aus: ["angebot", "auftragsbestaetigung"], nurAngenommen: true, annehmbar: true },
|
||||
auftragsbestaetigung: { name: "Auftragsbestätigung", praefix: "AB", gruppe: "kunde", braucht: "angenommen", aus: ["angebot", "nachtrag"], nurAngenommen: true, annehmbar: false },
|
||||
lieferschein: { name: "Lieferschein", praefix: "LS", gruppe: "kunde", braucht: "auftrag", aus: ["auftragsbestaetigung", "angebot", "nachtrag"], nurAngenommen: true, annehmbar: false },
|
||||
ausschreibung: { name: "Ausschreibung Subunternehmer", praefix: "AS", gruppe: "sub", braucht: null, aus: ["angebot", "kostenvoranschlag"], nurAngenommen: false, annehmbar: false },
|
||||
bestellschein: { name: "Bestellschein Lieferant", praefix: "BS", gruppe: "sub", braucht: "auftrag", aus: ["auftragsbestaetigung", "angebot", "nachtrag"], nurAngenommen: true, annehmbar: false },
|
||||
};
|
||||
|
||||
export interface Dokument { id: string; nummer: string; belegart: string; status: string }
|
||||
|
||||
const angenommen = (d: Dokument) => d.status === "angenommen" && (d.belegart === "angebot" || d.belegart === "nachtrag");
|
||||
const NACH_AUFTRAG = ["auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"];
|
||||
|
||||
/** Grund, warum es die Art im Projekt noch nicht gibt, sonst null */
|
||||
export function gesperrt(art: Belegart, projektStatus: string, dokumente: Dokument[]): string | null {
|
||||
const b = BELEG[art].braucht;
|
||||
if (b === "angenommen" && !dokumente.some(angenommen)) return "ab angen. Angebot";
|
||||
if (b === "auftrag" && !dokumente.some(angenommen) && !NACH_AUFTRAG.includes(projektStatus)) return "ab Auftrag";
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Vorgängerdokumente im Projekt, aus denen die Art übernommen werden kann */
|
||||
export function vorgaenger<T extends Dokument>(art: Belegart, dokumente: T[]): T[] {
|
||||
const info = BELEG[art];
|
||||
return dokumente.filter((d) => info.aus.includes(d.belegart as Belegart)
|
||||
&& (!info.nurAngenommen || d.belegart === "auftragsbestaetigung" || angenommen(d)) && d.status !== "abgelehnt");
|
||||
}
|
||||
|
||||
/** Nächste Nummer im Nummernkreis der Art, z. B. KV-26-004 */
|
||||
export function belegNummer(art: Belegart, vorhanden: string[], jahr: number): string {
|
||||
const jj = String(jahr % 100).padStart(2, "0");
|
||||
const p = BELEG[art].praefix;
|
||||
let max = 0;
|
||||
for (const n of vorhanden) {
|
||||
const m = new RegExp(`^${p}-(\\d{2})-(\\d{1,4})`).exec(n.trim());
|
||||
if (m && m[1] === jj) max = Math.max(max, Number(m[2]));
|
||||
}
|
||||
return `${p}-${jj}-${String(max + 1).padStart(3, "0")}`;
|
||||
}
|
||||
|
||||
/** Passt die GAEB-Phase zur gewählten Art? Sonst die passende Art (z. B. X86 = Auftragserteilung → AB). */
|
||||
const PHASE_ARTEN: Record<string, Belegart[]> = {
|
||||
"81": ["angebot", "kostenvoranschlag", "nachtrag", "ausschreibung"],
|
||||
"82": ["kostenvoranschlag", "angebot"],
|
||||
"83": ["angebot", "kostenvoranschlag", "nachtrag", "ausschreibung"],
|
||||
"84": ["angebot", "nachtrag", "kostenvoranschlag", "ausschreibung"],
|
||||
"85": ["angebot", "nachtrag"],
|
||||
"86": ["auftragsbestaetigung", "lieferschein", "bestellschein"],
|
||||
};
|
||||
|
||||
export function gaebPasst(phase: string | null, art: Belegart): { passt: boolean; vorschlag: Belegart | null; hinweis: string } {
|
||||
const arten = phase ? PHASE_ARTEN[phase] : undefined;
|
||||
if (!arten || arten.includes(art)) {
|
||||
const hinweis = phase === "84" && art === "ausschreibung"
|
||||
? "Eine X84 von einem Subunternehmer ist sein Angebot; der Preisspiegel (A16) kommt später."
|
||||
: "";
|
||||
return { passt: true, vorschlag: null, hinweis };
|
||||
}
|
||||
const vorschlag = arten[0]!;
|
||||
const was = { "81": "eine Leistungsbeschreibung", "82": "ein Kostenansatz", "83": "eine Angebotsaufforderung", "84": "ein abgegebenes Angebot", "85": "ein Nebenangebot", "86": "eine Auftragserteilung" }[phase!];
|
||||
return { passt: false, vorschlag, hinweis: `Die Datei ist Phase ${phase}, also ${was}. Passend wäre: ${BELEG[vorschlag].name}.` };
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
// 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.
|
||||
// GAEB lesen: DA XML 3.x (.x81–.x86), GAEB 2000 (.p81–.p86) und GAEB 90 (.d81–.d86). Leistungsverzeichnis mit
|
||||
// Titeln und Positionen (OZ, Kurztext, Langtext, Menge, Einheit, Einheitspreis, Positionsart), dazu Phase,
|
||||
// Auftraggeber und Vortexte. Daraus werden Leistungen der Stammdaten oder ein Dokument im Projekt (Henning 22.10.2026).
|
||||
import { type XmlElement, absatzText, elemente, kind, leseXml, pfad, textVon } from "./xml.js";
|
||||
import { einheitRichtig } from "./kalkulation.js";
|
||||
|
||||
@@ -14,17 +14,35 @@ export interface GaebPosition {
|
||||
menge: number | null;
|
||||
/** Einheitspreis in Cent (nur Dateien mit Preisen, z. B. .x84/.x86) */
|
||||
ep: number | null;
|
||||
art: "normal" | "eventual" | "alternativ";
|
||||
art: "normal" | "eventual" | "eventual_summe" | "alternativ";
|
||||
/** OZ des innersten Titels, zu dem die Position gehört */
|
||||
titelOz: string | null;
|
||||
}
|
||||
|
||||
export type GaebFormat = "GAEB DA XML" | "GAEB 2000" | "GAEB 90";
|
||||
|
||||
export interface GaebAdresse { name: string; strasse: string | null; plz: string | null; ort: string | null }
|
||||
|
||||
export interface GaebLv {
|
||||
name: string;
|
||||
/** Datenaustauschphase, z. B. 81, 83, 84 */
|
||||
phase: string | null;
|
||||
positionen: GaebPosition[];
|
||||
titel: number;
|
||||
format: GaebFormat;
|
||||
version: string | null;
|
||||
titelListe: { oz: string; bezeichnung: string }[];
|
||||
auftraggeber: GaebAdresse | null;
|
||||
/** Vorbemerkungen, z. B. ZTV, als Text */
|
||||
vortexte: string;
|
||||
/** Bauvorhaben laut Datei */
|
||||
projekt: string | null;
|
||||
}
|
||||
|
||||
export const GAEB_PHASE: Record<string, string> = {
|
||||
"81": "Leistungsbeschreibung", "82": "Kostenansatz", "83": "Angebotsaufforderung", "84": "Angebotsabgabe", "85": "Nebenangebot", "86": "Auftragserteilung",
|
||||
};
|
||||
|
||||
/** Einheiten aus GAEB (m2, Stck, lfm …) wie im Programm */
|
||||
export function gaebEinheit(qu: string): string {
|
||||
const t = qu.trim();
|
||||
@@ -43,6 +61,28 @@ const zahl = (t: string | undefined) => {
|
||||
return Number.isFinite(n) ? n : null;
|
||||
};
|
||||
|
||||
/** Welches GAEB-Format: am Inhalt erkannt, die Endung hilft nur bei GAEB 90 */
|
||||
export function gaebFormat(text: string, dateiname = ""): GaebFormat | null {
|
||||
const anfang = text.slice(0, 5000);
|
||||
if (/<\s*([\w-]+:)?GAEB[\s>]/.test(anfang)) return "GAEB DA XML";
|
||||
if (/#begin\[GAEB\]/i.test(anfang)) return "GAEB 2000";
|
||||
const zeilen = anfang.split(/\r?\n/).filter((z) => z.trim());
|
||||
if (/\.d8\d$/i.test(dateiname) || (zeilen[0]?.startsWith("00") && zeilen.slice(0, 5).every((z) => /^[0-9T][0-9]/.test(z) && z.length >= 70 && z.length <= 82))) return "GAEB 90";
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Jede GAEB-Datei: X8x, P8x oder D8x */
|
||||
export function leseGaebDatei(text: string, dateiname = ""): GaebLv {
|
||||
const f = gaebFormat(text, dateiname);
|
||||
if (f === "GAEB 2000") return leseGaeb2000(text);
|
||||
if (f === "GAEB 90") return leseGaeb90(text, dateiname);
|
||||
if (f === "GAEB DA XML") return leseGaeb(text);
|
||||
throw new Error("Das ist keine GAEB-Datei. Gelesen werden GAEB DA XML (.x81–.x86), GAEB 2000 (.p81–.p86) und GAEB 90 (.d81–.d86).");
|
||||
}
|
||||
|
||||
/** Phase aus der Datei, sonst aus der Endung (.x83, .p84, .d86) */
|
||||
const phaseVon = (inDatei: string | null | undefined, dateiname: string) => (inDatei?.match(/8[1-6]/)?.[0]) ?? /\.[xpd](8[1-6])$/i.exec(dateiname)?.[1] ?? 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).");
|
||||
@@ -51,9 +91,10 @@ export function leseGaeb(text: string): GaebLv {
|
||||
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 name = textVon(pfad(boq, "BoQInfo", "LblBoQ")) || textVon(pfad(boq, "BoQInfo", "Name")) || textVon(pfad(gaeb, "PrjInfo", "LblPrj")) || textVon(pfad(gaeb, "PrjInfo", "NamePrj")) || "GAEB";
|
||||
const phase = textVon(kind(award, "DP")) || null;
|
||||
const positionen: GaebPosition[] = [];
|
||||
const titelListe: GaebLv["titelListe"] = [];
|
||||
let titel = 0;
|
||||
|
||||
const koerper = (body: XmlElement | undefined, oz: string[], ordner: string[]) => {
|
||||
@@ -63,6 +104,7 @@ export function leseGaeb(text: string): GaebLv {
|
||||
const nr = c.attr.RNoPart ?? "";
|
||||
const bez = absatzText(kind(c, "LblTx")).split("\n")[0] || "Titel";
|
||||
const ozNeu = [...oz, nr].filter(Boolean);
|
||||
titelListe.push({ oz: ozNeu.join("."), bezeichnung: bez });
|
||||
koerper(kind(c, "BoQBody"), ozNeu, [...ordner, [ozNeu.join("."), bez].filter(Boolean).join(" ")]);
|
||||
}
|
||||
for (const liste of elemente(body, "Itemlist")) {
|
||||
@@ -71,6 +113,7 @@ export function leseGaeb(text: string): GaebLv {
|
||||
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 titelOz = oz.length ? oz.join(".") : null;
|
||||
const ozPos = [...oz, it.attr.RNoPart ?? ""].filter(Boolean).join(".");
|
||||
const up = zahl(textVon(kind(it, "UP")));
|
||||
positionen.push({
|
||||
@@ -81,12 +124,177 @@ export function leseGaeb(text: string): GaebLv {
|
||||
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",
|
||||
art: provis === "WithTotal" ? "eventual_summe" : provis ? "eventual" : kind(it, "ALNSerNo") && textVon(kind(it, "ALNSerNo")) !== "0" ? "alternativ" : "normal",
|
||||
titelOz,
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
koerper(kind(boq, "BoQBody"), [], []);
|
||||
if (!positionen.length) throw new Error("In der GAEB-Datei stehen keine Positionen.");
|
||||
return { name, phase, positionen, titel };
|
||||
const adr = pfad(award, "OWN", "Address");
|
||||
const auftraggeber = adr ? adresse([textVon(kind(adr, "Name1")), textVon(kind(adr, "Name2"))], textVon(kind(adr, "Street")), textVon(kind(adr, "PCode")), textVon(kind(adr, "City"))) : null;
|
||||
const vortexte = [...(award ? elemente(award, "AddText") : []), ...elemente(boq, "AddText")]
|
||||
.map((t) => [absatzText(kind(t, "OutlineAddText")), absatzText(kind(t, "DetailAddText"))].filter(Boolean).join("\n")).filter(Boolean).join("\n\n");
|
||||
return { name, phase, positionen, titel, format: "GAEB DA XML", version: textVon(pfad(gaeb, "GAEBInfo", "Version")) || null, titelListe, auftraggeber, vortexte,
|
||||
projekt: [textVon(pfad(gaeb, "PrjInfo", "LblPrj")), textVon(pfad(gaeb, "PrjInfo", "NamePrj"))].find((x) => x && !/^\d+$/.test(x)) || null };
|
||||
}
|
||||
|
||||
function adresse(namen: (string | undefined)[], strasse?: string, plz?: string, ort?: string): GaebAdresse | null {
|
||||
const name = namen.map((n) => n?.replace(/[\s,]+$/, "").trim()).filter(Boolean).join(" ");
|
||||
if (!name) return null;
|
||||
return { name, strasse: strasse?.trim() || null, plz: plz?.trim() || null, ort: ort?.trim() || null };
|
||||
}
|
||||
|
||||
// ---------- GAEB 2000 (.p8x): #begin[Name] … #end[Name] mit [Feld]Wert[end] ----------
|
||||
|
||||
interface Knoten { name: string; kinder: Knoten[]; werte: [string, string][] }
|
||||
|
||||
function baum2000(text: string): Knoten {
|
||||
const wurzel: Knoten = { name: "", kinder: [], werte: [] };
|
||||
const stapel = [wurzel];
|
||||
const re = /#begin\[([^\]]+)\]|#end\[([^\]]+)\]|\[([^\]\r\n]+)\]([\s\S]*?)\[end\]/gi;
|
||||
for (const m of text.matchAll(re)) {
|
||||
const oben = stapel.at(-1)!;
|
||||
if (m[1]) { const k: Knoten = { name: m[1], kinder: [], werte: [] }; oben.kinder.push(k); stapel.push(k); }
|
||||
else if (m[2]) { if (stapel.length > 1) stapel.pop(); }
|
||||
else oben.werte.push([m[3]!, m[4]!.replace(/\r/g, "").replace(/\s*\n\s*/g, "\n").trim()]);
|
||||
}
|
||||
return wurzel;
|
||||
}
|
||||
const wert = (k: Knoten | undefined, ...namen: string[]) => k?.werte.find(([n]) => namen.some((x) => x.toLowerCase() === n.toLowerCase()))?.[1];
|
||||
/** Wert auch in Unterknoten (z. B. Beschreibung → Kurztext) */
|
||||
const wertTief = (k: Knoten | undefined, ...namen: string[]): string | undefined => {
|
||||
if (!k) return undefined;
|
||||
const hier = wert(k, ...namen);
|
||||
if (hier !== undefined) return hier;
|
||||
for (const x of k.kinder) { const w = wertTief(x, ...namen); if (w !== undefined) return w; }
|
||||
return undefined;
|
||||
};
|
||||
const knoten = (k: Knoten | undefined, name: string) => k?.kinder.find((x) => x.name.toLowerCase() === name.toLowerCase());
|
||||
/** alle Werte unter einem Knoten, als Absätze */
|
||||
const textUnter = (k: Knoten | undefined): string => (k ? [...k.werte.map(([, v]) => v), ...k.kinder.map(textUnter)].filter(Boolean).join("\n") : "");
|
||||
const suche = (k: Knoten, name: RegExp): Knoten[] => k.kinder.flatMap((x) => (name.test(x.name) ? [x] : suche(x, name)));
|
||||
const ozTeile = (oz: string | undefined) => (oz ?? "").trim().split(/[\s.]+/).filter(Boolean);
|
||||
const zahl2000 = (t: string | undefined) => (t ? zahl(t.includes(",") ? t.replace(/\./g, "") : t) : null);
|
||||
|
||||
export function leseGaeb2000(text: string): GaebLv {
|
||||
const w = baum2000(text);
|
||||
const gaeb = knoten(w, "GAEB");
|
||||
if (!gaeb) throw new Error("Das ist keine GAEB-2000-Datei.");
|
||||
const vergabe = knoten(gaeb, "Vergabe");
|
||||
const lv = knoten(vergabe, "LV");
|
||||
if (!lv) throw new Error("In der GAEB-Datei steht kein Leistungsverzeichnis (LV).");
|
||||
const positionen: GaebPosition[] = [];
|
||||
const titelListe: GaebLv["titelListe"] = [];
|
||||
const bereich = (k: Knoten, oz: string[], ordner: string[]) => {
|
||||
for (const c of k.kinder) {
|
||||
if (/^LVBereich$/i.test(c.name)) {
|
||||
const ozNeu = ozTeile(wert(c, "OZ"));
|
||||
const bez = (wert(c, "BezTx", "Bez", "Bezeichnung") ?? textUnter(knoten(c, "Bez")) ?? "").split("\n")[0] || "Titel";
|
||||
const z = ozNeu.length ? ozNeu : [...oz, String(titelListe.length + 1)];
|
||||
titelListe.push({ oz: z.join("."), bezeichnung: bez });
|
||||
bereich(c, z, [...ordner, `${z.join(".")} ${bez}`]);
|
||||
} else if (/^Position$/i.test(c.name)) {
|
||||
const ozPos = ozTeile(wert(c, "OZ")).join(".");
|
||||
const kurzK = suche(c, /^(Kurztext|KurzTx|TextKurz)$/i)[0];
|
||||
const langK = suche(c, /^(Langtext|LangTx|TextLang)$/i)[0];
|
||||
const kurz = wertTief(c, "Kurztext", "KurzTx", "Stichwort") ?? textUnter(kurzK);
|
||||
const lang = wertTief(c, "Langtext", "LangTx") ?? textUnter(langK);
|
||||
const ep = zahl2000(wert(c, "EP"));
|
||||
const bedarf = (wert(c, "Bedarf") ?? "").trim().toUpperCase();
|
||||
positionen.push({
|
||||
oz: ozPos || `${oz.join(".")}.${positionen.length + 1}`,
|
||||
ordner: ordner.join(" / "),
|
||||
kurztext: (kurz || lang.split("\n")[0] || `Position ${ozPos}`).replace(/\n/g, " ").slice(0, 300),
|
||||
langtext: lang,
|
||||
einheit: gaebEinheit(wert(c, "ME", "Einheit") ?? ""),
|
||||
menge: zahl2000(wert(c, "Menge")),
|
||||
ep: ep === null || (bedarf && ep === 0) ? null : Math.round(ep * 100),
|
||||
art: bedarf === "M" ? "eventual_summe" : bedarf ? "eventual" : (wert(c, "Wahl", "Alternativ") ?? "").trim() && wert(c, "Wahl", "Alternativ") !== "0" ? "alternativ" : "normal",
|
||||
titelOz: oz.length ? oz.join(".") : null,
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
bereich(lv, [], []);
|
||||
if (!positionen.length) throw new Error("In der GAEB-Datei stehen keine Positionen.");
|
||||
const ag = knoten(knoten(vergabe, "AG"), "Adresse");
|
||||
const lvInfo = knoten(lv, "LVInfo");
|
||||
return {
|
||||
name: wert(lvInfo, "Name", "Bez") ?? wert(knoten(gaeb, "PrjInfo"), "Name") ?? "GAEB",
|
||||
phase: phaseVon(wert(vergabe, "DP"), ""), positionen, titel: titelListe.length, format: "GAEB 2000",
|
||||
version: wert(knoten(gaeb, "GAEBInfo"), "Version") ?? null, titelListe,
|
||||
auftraggeber: ag ? adresse([wert(ag, "Name1"), wert(ag, "Name2")], wert(ag, "Strasse"), wert(ag, "PLZ"), wert(ag, "Ort")) : null,
|
||||
vortexte: suche(gaeb, /^(Vortext|Vorbemerkung|ZusTexte?|AddText)$/i).map(textUnter).filter(Boolean).join("\n\n"),
|
||||
projekt: wert(knoten(gaeb, "PrjInfo"), "Name", "Bez") ?? null,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------- GAEB 90 (.d8x): Zeilen zu 80 Zeichen, Zeilenart in Spalte 1–2, Satznummer in 75–80 ----------
|
||||
// Ohne Beispieldatei nach der Satzbeschreibung gelesen (OZ 9 Stellen, Menge 11 Stellen mit 3 Nachkommastellen,
|
||||
// Einheit 4 Stellen, Kurztext 25, Langtext 26); Einheitspreise werden nicht übernommen, sie kalkulierst du selbst.
|
||||
|
||||
export function leseGaeb90(text: string, dateiname = ""): GaebLv {
|
||||
const zeilen = text.split(/\r?\n/).map((z) => z.replace(/\r$/, "")).filter((z) => z.length >= 2);
|
||||
const daten = (z: string) => z.slice(2, 74);
|
||||
let maske = "", phase: string | null = null, name = "", ag = "";
|
||||
const positionen: GaebPosition[] = [];
|
||||
const titelListe: GaebLv["titelListe"] = [];
|
||||
const offen: { oz: string; bezeichnung: string }[] = [];
|
||||
let pos: GaebPosition | null = null;
|
||||
const ozAus = (roh: string): string[] => {
|
||||
if (!maske) return ozTeile(roh);
|
||||
const teile: string[] = [];
|
||||
let i = 0;
|
||||
while (i < maske.length) {
|
||||
let j = i;
|
||||
while (j < maske.length && maske[j] === maske[i]) j++;
|
||||
if (maske[i] !== "I") teile.push(roh.slice(i, j).trim());
|
||||
i = j;
|
||||
}
|
||||
return teile.filter(Boolean);
|
||||
};
|
||||
const vortext: string[] = [];
|
||||
for (const z of zeilen) {
|
||||
const za = z.slice(0, 2);
|
||||
const d = daten(z);
|
||||
if (za === "00") {
|
||||
maske = /([1-9]+P+I?)/.exec(d)?.[1]?.padEnd(9, "I") ?? "";
|
||||
phase = phaseVon(/(?:^|\D)(8[1-6])(?:\D|$)/.exec(d)?.[1], dateiname);
|
||||
} else if (za === "01") name ||= d.trim();
|
||||
else if (za === "02") name ||= d.trim();
|
||||
else if (za === "03") ag ||= d.trim();
|
||||
else if (za === "T1") vortext.push(d.trim());
|
||||
else if (za === "11") {
|
||||
pos = null;
|
||||
const t = { oz: ozAus(d.slice(0, 9)).join("."), bezeichnung: "" };
|
||||
offen.push(t);
|
||||
titelListe.push(t);
|
||||
} else if (za === "12") {
|
||||
const t = offen.at(-1);
|
||||
if (t) t.bezeichnung = [t.bezeichnung, d.trim()].filter(Boolean).join(" ");
|
||||
} else if (za === "31") { offen.pop(); pos = null; }
|
||||
else if (za === "21") {
|
||||
const oz = ozAus(d.slice(0, 9)).join(".");
|
||||
const art1 = d[9] ?? "N", art2 = d[10] ?? "N";
|
||||
let menge: number | null = null, einheit = "";
|
||||
const fest = /^\d{11}$/.exec(z.slice(23, 34));
|
||||
if (fest) { menge = Number(fest[0]) / 1000; einheit = z.slice(34, 38).trim(); }
|
||||
else {
|
||||
const m = /(\d{9,11})\s*([^\s\d]{1,4})?/.exec(d.slice(11));
|
||||
if (m) { menge = Number(m[1]) / 1000; einheit = m[2] ?? ""; }
|
||||
}
|
||||
const titel = offen.at(-1);
|
||||
pos = { oz, ordner: offen.map((t) => `${t.oz} ${t.bezeichnung}`.trim()).join(" / "), kurztext: "", langtext: "", einheit: gaebEinheit(einheit), menge, ep: null,
|
||||
art: art2 === "M" ? "eventual_summe" : art2 === "E" ? "eventual" : art1 === "A" ? "alternativ" : "normal", titelOz: titel?.oz ?? null };
|
||||
positionen.push(pos);
|
||||
} else if (za === "25" && pos) pos.kurztext = [pos.kurztext, d.trim()].filter(Boolean).join(" ");
|
||||
else if (za === "26" && pos) pos.langtext = [pos.langtext, d.trim()].filter(Boolean).join("\n");
|
||||
}
|
||||
for (const p of positionen) p.kurztext = (p.kurztext || p.langtext.split("\n")[0] || `Position ${p.oz}`).slice(0, 300);
|
||||
for (const t of titelListe) t.bezeichnung ||= "Titel";
|
||||
if (!positionen.length) throw new Error("In der GAEB-90-Datei stehen keine Positionen (Zeilenart 21).");
|
||||
return { name: name || "GAEB", phase: phase ?? phaseVon(null, dateiname), positionen, titel: titelListe.length, format: "GAEB 90", version: null, titelListe,
|
||||
auftraggeber: ag ? { name: ag, strasse: null, plz: null, ort: null } : null, vortexte: vortext.join("\n"), projekt: null };
|
||||
}
|
||||
|
||||
@@ -14,6 +14,8 @@ import { hatBlatt, vorlagen } from "./leistungen-daten.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsterArbeitstag } from "../domain/kalender.js";
|
||||
import { aktuelleSaetze } from "./stundensaetze.js";
|
||||
import { BELEG, BELEGARTEN, type Belegart, belegNummer, gaebPasst, gesperrt } from "../domain/belege.js";
|
||||
import { type GaebLv, GAEB_PHASE, leseGaebDatei } from "../domain/gaeb.js";
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
@@ -107,13 +109,37 @@ export async function pruefeBearbeitbar(c: Client, tabelle: string, id: string |
|
||||
}
|
||||
}
|
||||
|
||||
const GaebDatei = z.object({ dateiname: z.string().trim().min(1).max(200), text: z.string().min(1).max(30_000_000) });
|
||||
const NeuSchema = z.object({
|
||||
projekt_id: z.uuid(),
|
||||
belegart: z.enum(["angebot", "kostenvoranschlag"]).default("angebot"),
|
||||
// Kopie eines anderen Angebots (neue Version, Vorlage aus einem früheren Angebot)
|
||||
belegart: z.enum(BELEGARTEN).optional(),
|
||||
// Kopie eines anderen Dokuments (neue Version, früheres Dokument, Vorlage)
|
||||
von_angebot_id: z.uuid().optional(),
|
||||
// Übernahme aus dem Vorgängerdokument der Belegkette (A10), mit Verweis darauf
|
||||
vorbeleg_id: z.uuid().optional(),
|
||||
// GAEB-Import (X81–X86, P81–P86, D81–D86); kunde: Kontakt als Kunde des Projekts eintragen, „neu“ legt ihn an
|
||||
gaeb: GaebDatei.extend({ kunde: z.union([z.uuid(), z.literal("neu")]).optional() }).optional(),
|
||||
});
|
||||
|
||||
/** GAEB-Datei lesen; Fehler als 400 */
|
||||
function gaebLesen(d: { dateiname: string; text: string }): GaebLv {
|
||||
try { return leseGaebDatei(d.text, d.dateiname); } catch (e) { throw Object.assign(new Error((e as Error).message), { statusCode: 400 }); }
|
||||
}
|
||||
|
||||
/** Titel und Positionen aus GAEB ins Dokument; Preise aus .x84/.x86 werden feste Einheitspreise */
|
||||
async function gaebEinfuegen(c: Client, angebotId: string, lv: GaebLv): Promise<void> {
|
||||
const titel = new Map<string, string>();
|
||||
for (const [i, t] of lv.titelListe.entries()) {
|
||||
const n = (await c.query("insert into angebot_titel (angebot_id, oz, bezeichnung, reihenfolge) values ($1, $2, $3, $4) returning id", [angebotId, t.oz || null, t.bezeichnung.slice(0, 500), i])).rows[0];
|
||||
titel.set(t.oz, n.id);
|
||||
}
|
||||
for (const [i, p] of lv.positionen.entries()) {
|
||||
await c.query(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, mit_kalkulation, reihenfolge)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
|
||||
[angebotId, p.titelOz ? titel.get(p.titelOz) ?? null : null, p.oz || null, p.kurztext, p.langtext || null, p.menge ?? 1, p.einheit || "St", p.art, p.ep, p.ep === null, i]);
|
||||
}
|
||||
}
|
||||
|
||||
async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void> {
|
||||
const titelNeu = new Map<string, string>();
|
||||
for (const t of (await c.query("select * from angebot_titel where angebot_id = $1 order by reihenfolge", [von])).rows) {
|
||||
@@ -204,29 +230,72 @@ export function registriereAngebote(
|
||||
if (!p) return null;
|
||||
const nummern = (await c.query("select nummer from angebot union all select nummer from projekt")).rows.map((r) => r.nummer as string);
|
||||
const belegt = new Set((await c.query("select nummer from angebot")).rows.map((r) => r.nummer as string));
|
||||
// das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie
|
||||
const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear());
|
||||
const quelleId = q.vorbeleg_id ?? q.von_angebot_id;
|
||||
const vorlage = quelleId ? (await c.query("select * from angebot where id = $1", [quelleId])).rows[0] : undefined;
|
||||
if (quelleId && !vorlage) throw new AngebotFehler("Das Dokument, aus dem übernommen werden soll, gibt es nicht mehr.");
|
||||
const art: Belegart = q.belegart ?? (q.vorbeleg_id ? "angebot" : vorlage?.belegart) ?? "angebot";
|
||||
const dokumente = (await c.query("select id, nummer, belegart, status from angebot where projekt_id = $1", [p.id])).rows;
|
||||
const grund = gesperrt(art, p.status, dokumente);
|
||||
if (grund) throw new AngebotFehler(`${BELEG[art].name} gibt es erst ${grund.replace("ab ", "ab dem ").replace("angen.", "angenommenen")}.`);
|
||||
if (q.vorbeleg_id && vorlage.projekt_id !== p.id) throw new AngebotFehler("Der Vorbeleg gehört zu einem anderen Projekt.");
|
||||
const lv = q.gaeb ? gaebLesen(q.gaeb) : null;
|
||||
// das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie; andere Arten haben eigene Nummernkreise (A10)
|
||||
const jahr = new Date().getFullYear();
|
||||
const nummer = art !== "angebot" ? belegNummer(art, nummern, jahr)
|
||||
: /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, jahr);
|
||||
const k = e.kalkulation;
|
||||
const datum = heute();
|
||||
// M17: Sätze aus den Stundensatz-Tabellen, die heute gelten; Vollkostensatz, daher Lohnzuschlag 0 % (A37, S4)
|
||||
const neue = await aktuelleSaetze(c, datum);
|
||||
const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined;
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`,
|
||||
[q.projekt_id, nummer, vorlage?.belegart ?? q.belegart, datum, k.bindefristWochen ? plusTage(datum, 7 * k.bindefristWochen) : null,
|
||||
vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
|
||||
const quelle = lv ? `${lv.format}${lv.phase ? ` Phase ${lv.phase}` : ""} · ${q.gaeb!.dateiname}` : q.vorbeleg_id ? `aus ${BELEG[vorlage.belegart as Belegart]?.name ?? "Dokument"} ${vorlage.nummer}` : null;
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze, vorbeleg_id, quelle, notiz)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) returning *`,
|
||||
[q.projekt_id, nummer, art, datum, k.bindefristWochen && BELEG[art].gruppe === "kunde" && !["lieferschein", "auftragsbestaetigung"].includes(art) ? plusTage(datum, 7 * k.bindefristWochen) : null,
|
||||
vorlage?.betreff ?? (lv ? (lv.projekt ?? lv.name).slice(0, 300) : null), vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
|
||||
vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall,
|
||||
// A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen
|
||||
{ stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
|
||||
zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum }])).rows[0];
|
||||
zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum },
|
||||
q.vorbeleg_id ?? null, quelle, lv?.vortexte ? `Vorbemerkungen aus der GAEB-Datei:\n${lv.vortexte}`.slice(0, 100_000) : null])).rows[0];
|
||||
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
|
||||
if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
|
||||
if (lv) await gaebEinfuegen(c, neu.id, lv);
|
||||
// Ausschreibung an Subunternehmer ohne eigene Preise (A15)
|
||||
if (art === "ausschreibung" && vorlage) {
|
||||
await c.query("delete from angebot_kosten where position_id in (select id from angebot_position where angebot_id = $1)", [neu.id]);
|
||||
await c.query("update angebot_position set ep_fest = null where angebot_id = $1", [neu.id]);
|
||||
}
|
||||
// Auftraggeber aus der GAEB-Datei als Kunde des Projekts
|
||||
if (lv && q.gaeb?.kunde && BELEG[art].gruppe === "kunde") {
|
||||
const ag = lv.auftraggeber;
|
||||
const kid = q.gaeb.kunde === "neu"
|
||||
? ag ? (await c.query("insert into kontakt (name, rolle, notiz) values ($1, 'bauherr', $2) returning id",
|
||||
[ag.name.slice(0, 300), [ag.strasse, [ag.plz, ag.ort].filter(Boolean).join(" ")].filter(Boolean).join(", ") || null])).rows[0].id : null
|
||||
: q.gaeb.kunde;
|
||||
if (kid) await c.query("update projekt set bauherr_id = $2 where id = $1", [p.id, kid]);
|
||||
}
|
||||
if (p.status === "anfrage" && ["angebot", "kostenvoranschlag"].includes(art)) await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
|
||||
return neu;
|
||||
});
|
||||
if (!a) return reply.status(404).send({ fehler: "Projekt nicht gefunden" });
|
||||
return reply.status(201).send(a);
|
||||
});
|
||||
|
||||
// GAEB-Datei ansehen, bevor daraus ein Dokument wird: Format, Phase, Umfang, Auftraggeber und ob die Phase passt
|
||||
app.post("/api/gaeb/vorschau", async (req) => {
|
||||
const q = GaebDatei.extend({ belegart: z.enum(BELEGARTEN).default("angebot"), projekt_id: z.uuid() }).parse(req.body ?? {});
|
||||
const lv = gaebLesen(q);
|
||||
const p = (await pool.query("select p.bauherr_id, k.name from projekt p left join kontakt k on k.id = p.bauherr_id where p.id = $1", [q.projekt_id])).rows[0];
|
||||
const ag = lv.auftraggeber;
|
||||
const treffer = ag ? (await pool.query("select id, name, firma from kontakt where lower(name) = lower($1) or lower(firma) = lower($1) or name ilike '%' || $1 || '%' order by name limit 5", [ag.name])).rows : [];
|
||||
return {
|
||||
format: lv.format, version: lv.version, phase: lv.phase, phase_name: lv.phase ? GAEB_PHASE[lv.phase] ?? null : null, name: lv.name, projekt: lv.projekt,
|
||||
titel: lv.titelListe.length, positionen: lv.positionen.length, mit_preis: lv.positionen.filter((x) => x.ep !== null).length,
|
||||
mit_langtext: lv.positionen.filter((x) => x.langtext).length, vortexte: !!lv.vortexte,
|
||||
auftraggeber: ag, treffer, kunde: p?.bauherr_id ? { id: p.bauherr_id, name: p.name } : null,
|
||||
...gaebPasst(lv.phase, q.belegart),
|
||||
};
|
||||
});
|
||||
|
||||
app.get("/api/angebote/:id/voll", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const e = await einstellungen();
|
||||
@@ -392,6 +461,7 @@ export function registriereAngebote(
|
||||
const r = await transaktion(pool, wer(req), async (c) => (await mitNeuplanung(c, woche, async () => {
|
||||
const x = await ladeAngebot(c, id, e);
|
||||
if (!x) return null;
|
||||
if (!BELEG[x.angebot.belegart as Belegart]?.annehmbar) throw new AngebotFehler(`Ein${x.angebot.belegart === "auftragsbestaetigung" ? "e" : ""} ${BELEG[x.angebot.belegart as Belegart]?.name ?? "Dokument"} wird nicht angenommen; angenommen werden Angebote und Nachträge.`);
|
||||
if (!["entwurf", "versendet"].includes(x.angebot.status)) throw new AngebotFehler("Das Angebot ist schon angenommen oder abgelehnt.");
|
||||
if (!x.positionen.length) throw new AngebotFehler("Das Angebot hat noch keine Position.");
|
||||
await c.query("update angebot set status = 'angenommen', entschieden_am = $2, versendet_am = coalesce(versendet_am, $2), staende = staende || $3::jsonb where id = $1",
|
||||
|
||||
9
src/server/migrations/021_dokumente.sql
Normal file
9
src/server/migrations/021_dokumente.sql
Normal file
@@ -0,0 +1,9 @@
|
||||
-- „+ Dokument“ (Henning 22.10.2026, A7/A10/A11): alle Dokumentarten der Belegkette, Verweis auf den Vorbeleg,
|
||||
-- Herkunft (z. B. GAEB-Datei) und Dokumente, die als Vorlage angeboten werden. Der Vorbeleg ist bewusst ohne
|
||||
-- Fremdschlüssel, damit Sicherungen in jeder Reihenfolge zurückgespielt werden können.
|
||||
alter table angebot drop constraint angebot_belegart_check;
|
||||
alter table angebot add constraint angebot_belegart_check check (belegart in
|
||||
('kostenvoranschlag', 'angebot', 'nachtrag', 'auftragsbestaetigung', 'lieferschein', 'ausschreibung', 'bestellschein'));
|
||||
alter table angebot add column vorbeleg_id uuid;
|
||||
alter table angebot add column quelle text;
|
||||
alter table angebot add column ist_vorlage boolean not null default false;
|
||||
@@ -7,7 +7,7 @@ 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 { leseGaebDatei } from "../domain/gaeb.js";
|
||||
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
|
||||
const IdParam = z.object({ id: z.string().min(1).max(80) });
|
||||
@@ -68,7 +68,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell
|
||||
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 }); }
|
||||
try { lv = leseGaebDatei(q.text, q.dateiname); } 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]));
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
// Eingabeprüfung für die Tabellen aus Stufe 0. Feldnamen = Spaltennamen.
|
||||
import { BELEGARTEN } from "../domain/belege.js";
|
||||
import { z } from "zod";
|
||||
|
||||
const datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Datum im Format JJJJ-MM-TT");
|
||||
@@ -137,7 +138,10 @@ export const TABELLEN: Tabelle[] = [
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
nummer: text,
|
||||
belegart: z.enum(["angebot", "kostenvoranschlag"]).optional(),
|
||||
belegart: z.enum(BELEGARTEN).optional(),
|
||||
vorbeleg_id: id.nullable().optional(),
|
||||
quelle: optText,
|
||||
ist_vorlage: z.boolean().optional(),
|
||||
datum: datum.optional(),
|
||||
bindefrist: datum.nullable().optional(),
|
||||
betreff: optText,
|
||||
|
||||
@@ -13,9 +13,15 @@ import { alleVorlagen, blattAktion, blattHtml, eingabenAbfragen, kuerzelListe, s
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, istHandy, lies, merke, optionenHtml, seite } from "./ui.js";
|
||||
import { liste } from "./liste.js";
|
||||
import { BELEG, BELEGARTEN, type Belegart } from "../domain/belege.js";
|
||||
|
||||
export const ANGEBOT_STATUS: Record<string, string> = { entwurf: "Entwurf", versendet: "Versendet", angenommen: "Angenommen", abgelehnt: "Abgelehnt" };
|
||||
const BELEGART: Record<string, string> = { angebot: "Angebot", kostenvoranschlag: "Kostenvoranschlag" };
|
||||
const BELEGART: Record<string, string> = Object.fromEntries(BELEGARTEN.map((a) => [a, BELEG[a].name]));
|
||||
const annehmbar = (a: Zeile) => BELEG[a.belegart as Belegart]?.annehmbar ?? true;
|
||||
|
||||
/** Nach „+ Dokument → KI-Vorschlag“ öffnet das neue Dokument gleich den Reiter KI */
|
||||
let reiterNachAnlegen: Zustand["reiter"] | null = null;
|
||||
export const dokumentReiterNachAnlegen = (r: Zustand["reiter"]) => { reiterNachAnlegen = r; };
|
||||
const MARKE: Record<string, string> = { entwurf: "grau", versendet: "offen", angenommen: "gut", abgelehnt: "schlecht" };
|
||||
|
||||
const prozentText = (n: number | null | undefined) => (n == null ? "–" : `${String(n).replace(".", ",")} %`);
|
||||
@@ -38,7 +44,7 @@ export async function neuesAngebot(projektId: string, vonAngebot?: string): Prom
|
||||
|
||||
/** Die Angebote eines Projekts im Reiter Dokumente */
|
||||
export function angeboteHtml(angebote: Zeile[]): string {
|
||||
if (!angebote.length) return '<p class="hinweis leer">Noch kein Angebot. Mit „+ Angebot“ legst du eins an; die Nummer ist die des Projekts.</p>';
|
||||
if (!angebote.length) return '<p class="hinweis leer">Noch kein Dokument. Mit „+ Dokument“ legst du ein Angebot, einen Kostenvoranschlag oder anderes an, auch aus einer GAEB-Datei.</p>';
|
||||
return `<ul class="dokumente">${angebote.map((a) => `<li><a class="dokument" href="#angebot-${a.id}"><span><b>${esc(BELEGART[a.belegart] ?? "Angebot")} ${esc(a.nummer)}</b>${a.betreff ? ` ${esc(a.betreff)}` : ""}
|
||||
<span class="unter">vom ${dat(a.datum)} · ${euro(a.netto)} netto · ${a.positionen} ${a.positionen === 1 ? "Position" : "Positionen"}${a.bindefrist && a.status === "versendet" ? ` · gebunden bis ${dat(a.bindefrist)}` : ""}</span></span>
|
||||
<span class="marken">${angebotMarke(a)}</span></a></li>`).join("")}</ul>`;
|
||||
@@ -63,7 +69,7 @@ export async function angeboteSeite(): Promise<void> {
|
||||
schluessel: "angebote", einheit: ["Angebot", "Angebote"], vorgabe: { sort: [["datum", "ab"]] },
|
||||
leer: "Noch keine Angebote. Ein Angebot legst du hier oder auf der Projektseite unter Dokumente an.",
|
||||
spalten: [
|
||||
{ id: "nummer", titel: "Nummer", text: (a) => a.nummer, wert: (a) => `<strong>${esc(a.nummer)}</strong>${a.belegart === "kostenvoranschlag" ? ' <small class="hinweis">KVA</small>' : ""}<span class="unter">${esc(a.betreff || a.projekt_name)}</span>` },
|
||||
{ id: "nummer", titel: "Nummer", text: (a) => a.nummer, wert: (a) => `<strong>${esc(a.nummer)}</strong>${a.belegart !== "angebot" ? ` <small class="hinweis">${esc(BELEGART[a.belegart] ?? a.belegart)}</small>` : ""}<span class="unter">${esc(a.betreff || a.projekt_name)}</span>` },
|
||||
{ id: "projekt", titel: "Projekt", text: (a) => `${a.projekt_nummer} ${a.projekt_name}`, wert: (a) => `${esc(a.projekt_name)}<span class="unter">${esc(a.projekt_nummer)}</span>`, klasse: "optional" },
|
||||
{ id: "kunde", titel: "Kunde", wert: (a) => esc(a.bauherr_name ?? ""), klasse: "optional" },
|
||||
{ id: "datum", titel: "Datum", art: "datum", wert: (a) => dat(a.datum), sortWert: (a) => a.datum },
|
||||
@@ -111,8 +117,8 @@ interface Zustand {
|
||||
}
|
||||
let zustand: Zustand | null = null;
|
||||
const zustandFuer = (id: string): Zustand => {
|
||||
if (zustand?.angebot !== id) zustand = { angebot: id, aktiv: null, ziel: null, auf: new Set(), reiter: "bausteine", katalog: "leistungen", suche: "", ordner: "", matSuche: "", matTreffer: null,
|
||||
ki: { text: "", laeuft: false, fehler: "", vorschlaege: [] }, vorher: null };
|
||||
if (zustand?.angebot !== id) { zustand = { angebot: id, aktiv: null, ziel: null, auf: new Set(), reiter: reiterNachAnlegen ?? "bausteine", katalog: "leistungen", suche: "", ordner: "", matSuche: "", matTreffer: null,
|
||||
ki: { text: "", laeuft: false, fehler: "", vorschlaege: [] }, vorher: null }; reiterNachAnlegen = null; }
|
||||
return zustand;
|
||||
};
|
||||
|
||||
@@ -660,12 +666,17 @@ function handyHtml(d: Zeile, meldung: string): string {
|
||||
}).join("");
|
||||
const fehler = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length, n = d.pruefung.length;
|
||||
const allgemein = d.pruefung.filter((p: Zeile) => !p.position_id);
|
||||
const knoepfe = {
|
||||
const knoepfe = (annehmbar(a) ? {
|
||||
entwurf: `<button class="haupt breit" data-a="versenden">Freigeben (als versendet markieren)</button><button class="neben breit" data-a="annehmen">Angebot annehmen → Auftrag</button>`,
|
||||
versendet: `<button class="haupt breit" data-a="annehmen">Angebot annehmen → Auftrag</button><button class="neben breit" data-a="ablehnen">Abgelehnt</button><button class="neben breit" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
abgelehnt: `<button class="neben breit" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
}[a.status as string] ?? "";
|
||||
} : {
|
||||
entwurf: `<button class="haupt breit" data-a="versenden">Freigeben (als versendet markieren)</button>`,
|
||||
versendet: `<button class="neben breit" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
abgelehnt: `<button class="neben breit" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
})[a.status as string] ?? "";
|
||||
return `<div class="angebot-handy">
|
||||
<div class="kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(a.nummer)} <span class="nummer">${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}</div>
|
||||
@@ -1030,6 +1041,9 @@ function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], leistunge
|
||||
panel = frei ? kiHtml(z, leistungen) : '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>';
|
||||
} else if (reiter === "vorgaben") {
|
||||
panel = `<label class="am-beleg">Beleg ${auswahl("angebote:x:belegart", Object.entries(BELEGART), a.belegart, "Belegart")}</label>
|
||||
<label class="am-radio"><input type="checkbox" data-k="angebote:x:ist_vorlage" data-typ="bool"${a.ist_vorlage ? " checked" : ""}> Als Vorlage anbieten (unter „+ Dokument“ → Vorlage)</label>
|
||||
${a.quelle ? `<p class="hinweis-k">Herkunft: ${esc(a.quelle)}</p>` : ""}
|
||||
${a.notiz ? `<details class="am-notiz"><summary>${/^Vorbemerkungen aus der GAEB/.test(a.notiz) ? "Vorbemerkungen aus der GAEB-Datei" : "Notiz"}</summary><div>${esc(a.notiz.replace(/^Vorbemerkungen aus der GAEB-Datei:\n/, ""))}</div></details>` : ""}
|
||||
${vorgabenHtml(d, frei)}
|
||||
<h3 class="am-h">Kalkulation nach Kostenart</h3>
|
||||
<table class="kalk-tabelle"><thead><tr><th></th><th class="zahl">Kosten</th><th class="zahl">Zuschlag</th><th class="zahl">Verkauf</th></tr></thead><tbody>
|
||||
@@ -1072,12 +1086,17 @@ function summenLeiste(d: Zeile): string {
|
||||
/** Kopfleiste mit Zurück, Nummer, Status und Knöpfen */
|
||||
function titelleiste(d: Zeile, meldung: string): string {
|
||||
const a = d.angebot;
|
||||
const knoepfe = {
|
||||
const knoepfe = (annehmbar(a) ? {
|
||||
entwurf: `<button class="neben" data-a="annehmen">Annehmen</button><button class="haupt" data-a="versenden">Als versendet markieren</button>`,
|
||||
versendet: `<button class="neben" data-a="ablehnen">Abgelehnt</button><button class="neben" data-a="bearbeiten">Wieder bearbeiten</button><button class="haupt" data-a="annehmen">Annehmen</button>`,
|
||||
abgelehnt: `<button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
}[a.status as string] ?? "";
|
||||
} : {
|
||||
entwurf: `<button class="haupt" data-a="versenden">Als versendet markieren</button>`,
|
||||
versendet: `<button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
abgelehnt: `<button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
})[a.status as string] ?? "";
|
||||
return `<div class="kopf angebot-kopf am-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)} · ${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}
|
||||
<span class="kopf-knoepfe">${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}</span></div>
|
||||
|
||||
@@ -15,7 +15,8 @@ import { type Eckdaten, type Reihenfolge, STANDARD_REIHENFOLGE, eckdatenRechnen,
|
||||
import { formatEuro, parseEuro } from "../domain/geld.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 { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite } from "./angebote.js";
|
||||
import { dokumentMenue } from "./dokument.js";
|
||||
import { vorlageSeite } from "./mengenblatt.js";
|
||||
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js";
|
||||
@@ -339,8 +340,8 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const rechnungen = eigeneZahlungen.filter((z) => z.status !== "geplant").sort((a, b) => (a.rechnungsdatum ?? a.termin).localeCompare(b.rechnungsdatum ?? b.termin));
|
||||
let abschlag = 0;
|
||||
const art = (z: Zeile) => (z.art === "abschlag" ? `${++abschlag}. Abschlag` : ZAHLUNGSART_TEXT[z.art] ?? z.art);
|
||||
knopf("+ Angebot", () => void neuesAngebot(id));
|
||||
teil.innerHTML = `<h3 class="gruppe">Angebote</h3>${angeboteHtml(angebote)}
|
||||
knopf("+ Dokument ▾", () => void dokumentMenue(knopfOrt.querySelector("button")!, p, angebote));
|
||||
teil.innerHTML = `<h3 class="gruppe">Angebote und weitere Dokumente</h3>${angeboteHtml(angebote)}
|
||||
<h3 class="gruppe">Rechnungen</h3>${rechnungen.length ? `<ul class="dokumente">${rechnungen.map((z) => {
|
||||
const ueberfaellig = z.status === "gestellt" && z.termin < heute();
|
||||
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
|
||||
|
||||
188
src/web/dokument.ts
Normal file
188
src/web/dokument.ts
Normal file
@@ -0,0 +1,188 @@
|
||||
// „+ Dokument ▾“ auf der Projektseite (Henning „baue das so“, 22.10.2026, Entwurf dokument-menue-entwurf.html):
|
||||
// 1. Dokumentart wählen, grau mit Grund, wenn der Vorgänger fehlt; 2. „<Art> erstellen aus …“ mit Blanko, GAEB-Import,
|
||||
// Übernahme aus dem Vorgängerdokument, KI-Vorschlag, Kopie und Vorlage; 3. GAEB-Datei mit Vorschau einlesen.
|
||||
|
||||
import { BELEG, BELEGARTEN, type Belegart, type Dokument, gesperrt, vorgaenger } from "../domain/belege.js";
|
||||
import { dateiText } from "../domain/kodierung.js";
|
||||
import { menue, menueSchliessen } from "./liste.js";
|
||||
import { type Zeile, api, dat, esc, euro, huelle, optionenHtml } from "./ui.js";
|
||||
import { entpacke, istZip } from "./zip.js";
|
||||
import { ANGEBOT_STATUS, dokumentReiterNachAnlegen } from "./angebote.js";
|
||||
|
||||
const GAEB_ENDUNGEN = [..."xpd"].flatMap((b) => [1, 2, 3, 4, 5, 6].map((n) => `.${b}8${n}`));
|
||||
const MIT_KI: Belegart[] = ["angebot", "kostenvoranschlag", "nachtrag"];
|
||||
|
||||
async function anlegen(body: Zeile): Promise<void> {
|
||||
const a = await api<Zeile>("angebote/neu", "POST", body);
|
||||
location.hash = `angebot-${a.id}`;
|
||||
}
|
||||
|
||||
/** Menü unter dem Knopf „+ Dokument“ */
|
||||
export async function dokumentMenue(anker: HTMLElement, projekt: Zeile, dokumente: Zeile[]): Promise<void> {
|
||||
const docs = dokumente as unknown as (Dokument & Zeile)[];
|
||||
const eintrag = (art: Belegart) => {
|
||||
const grund = gesperrt(art, projekt.status, docs);
|
||||
return `<button class="dok-eintrag" data-art="${art}"${grund ? ` disabled title="Noch nicht möglich: ${esc(grund)}"` : ""}><span>${esc(BELEG[art].name)}</span>${grund ? `<small>${esc(grund)}</small>` : "<b>›</b>"}</button>`;
|
||||
};
|
||||
const gruppe = (titel: string, g: "kunde" | "sub") => `<h4>${titel}</h4>${BELEGARTEN.filter((a) => BELEG[a].gruppe === g).map(eintrag).join("")}`;
|
||||
const stufe1 = () => `<div class="dok-kopf">Neues Dokument</div>${gruppe("An den Kunden", "kunde")}${gruppe("An Subunternehmer / Lieferanten", "sub")}
|
||||
<p class="dok-fuss">Grau heißt: das Vorgängerdokument fehlt noch. Rechnungen schreibst du weiter extern.</p>`;
|
||||
let alle: Zeile[] | null = null;
|
||||
const m = menue(anker, stufe1(), "dok-menue");
|
||||
|
||||
const stufe2 = async (art: Belegart) => {
|
||||
const name = BELEG[art].name;
|
||||
m.innerHTML = `<div class="dok-kopf"><button class="dok-zurueck" data-a="zurueck" aria-label="Zurück zur Dokumentart">‹</button>${esc(name)} erstellen aus …</div><p class="dok-fuss">Lädt …</p>`;
|
||||
alle ??= await api<Zeile[]>("angebote-liste").catch(() => []);
|
||||
const vor = vorgaenger(art, docs);
|
||||
const frueher = alle.filter((d) => d.belegart === art);
|
||||
const vorlagen = alle.filter((d) => d.ist_vorlage);
|
||||
const zeile = (a: string, titel: string, unter: string, extra = "", aus = false) =>
|
||||
`<button class="dok-eintrag" data-a="${a}"${extra}${aus ? " disabled" : ""}><span>${titel}<small>${unter}</small></span></button>`;
|
||||
m.innerHTML = `<div class="dok-kopf"><button class="dok-zurueck" data-a="zurueck" aria-label="Zurück zur Dokumentart">‹</button>${esc(name)} erstellen aus …</div>
|
||||
${zeile("blanko", "Blanko", "leeres Dokument")}
|
||||
${zeile("gaeb", "GAEB-Import", "X81–X86, P81–P86, D81–D86")}
|
||||
${vor.map((d) => zeile("vorbeleg", `aus ${esc(BELEG[d.belegart as Belegart]?.name ?? "Dokument")} ${esc(d.nummer)}`,
|
||||
`✓ vorhanden · ${esc(ANGEBOT_STATUS[d.status] ?? d.status)}${d.netto != null ? ` · ${euro(d.netto)}` : ""}`, ` data-id="${d.id}"`)).join("")}
|
||||
${MIT_KI.includes(art) ? zeile("ki", "KI-Vorschlag aus der Anfrage", "Anfrage beschreiben, Claude schlägt Leistungen vor") : ""}
|
||||
${zeile("kopie", `Kopie eines früheren Dokuments`, frueher.length ? `${frueher.length} ${frueher.length === 1 ? name : `× ${name}`} vorhanden` : `noch kein ${name} vorhanden`, "", !frueher.length)}
|
||||
${zeile("vorlage", "Vorlage", vorlagen.length ? vorlagen.slice(0, 3).map((v) => esc(v.betreff || v.nummer)).join(", ") : "noch keine; im Dokument unter Vorgaben „Als Vorlage anbieten“", "", !vorlagen.length)}
|
||||
<p class="dok-fuss">Das Menü zeigt nur, was zum Stand des Projekts passt.</p>`;
|
||||
m.dataset.art = art;
|
||||
};
|
||||
|
||||
const auswaehlen = async (titel: string, liste: Zeile[], art: Belegart) => {
|
||||
menueSchliessen();
|
||||
const id = await wahlDialog(titel, liste);
|
||||
if (id) await anlegen({ projekt_id: projekt.id, belegart: art, von_angebot_id: id });
|
||||
};
|
||||
|
||||
m.addEventListener("click", async (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLButtonElement>("button");
|
||||
if (!b || b.disabled) return;
|
||||
if (b.dataset.art) return stufe2(b.dataset.art as Belegart);
|
||||
const art = m.dataset.art as Belegart;
|
||||
const a = b.dataset.a;
|
||||
try {
|
||||
if (a === "zurueck") { m.innerHTML = stufe1(); return; }
|
||||
if (a === "blanko") { menueSchliessen(); return await anlegen({ projekt_id: projekt.id, belegart: art }); }
|
||||
if (a === "vorbeleg") { menueSchliessen(); return await anlegen({ projekt_id: projekt.id, belegart: art, vorbeleg_id: b.dataset.id }); }
|
||||
if (a === "ki") { menueSchliessen(); dokumentReiterNachAnlegen("ki"); return await anlegen({ projekt_id: projekt.id, belegart: art }); }
|
||||
if (a === "kopie") return await auswaehlen(`Kopie eines früheren Dokuments: ${BELEG[art].name}`, alle!.filter((d) => d.belegart === art), art);
|
||||
if (a === "vorlage") return await auswaehlen(`${BELEG[art].name} aus Vorlage`, alle!.filter((d) => d.ist_vorlage), art);
|
||||
if (a === "gaeb") { menueSchliessen(); return await gaebDialog(projekt, art); }
|
||||
} catch (e) {
|
||||
m.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/** Ein früheres Dokument oder eine Vorlage wählen */
|
||||
function wahlDialog(titel: string, liste: Zeile[]): Promise<string | null> {
|
||||
return new Promise((fertig) => {
|
||||
const sortiert = [...liste].sort((a, b) => String(b.datum).localeCompare(String(a.datum)));
|
||||
huelle.innerHTML = `<form class="dialog dok-wahl"><h2>${esc(titel)}</h2>
|
||||
<input type="search" class="dok-suche" placeholder="Suchen: Nummer, Betreff, Projekt" aria-label="Suchen">
|
||||
<ul class="dok-liste">${sortiert.map((d, i) => `<li><label><input type="radio" name="dok" value="${d.id}"${i === 0 ? " checked" : ""}>
|
||||
<span><b>${esc(d.nummer)}</b> ${esc(d.betreff ?? "")}<small>${esc(d.projekt_name ?? "")} · ${dat(d.datum)} · ${euro(d.netto)} · ${d.positionen} Pos.</small></span></label></li>`).join("")}</ul>
|
||||
<div class="knoepfe"><button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Kopie anlegen</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const schliessen = (id: string | null) => { huelle.hidden = true; huelle.innerHTML = ""; removeEventListener("keydown", taste); fertig(id); };
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
||||
addEventListener("keydown", taste);
|
||||
form.querySelector<HTMLInputElement>(".dok-suche")!.oninput = (ev) => {
|
||||
const q = (ev.target as HTMLInputElement).value.trim().toLowerCase();
|
||||
form.querySelectorAll<HTMLLIElement>(".dok-liste li").forEach((li) => { li.hidden = !!q && !li.textContent!.toLowerCase().includes(q); });
|
||||
};
|
||||
form.onclick = (ev) => { if ((ev.target as HTMLElement).dataset.a === "abbrechen") schliessen(null); };
|
||||
form.onsubmit = (ev) => { ev.preventDefault(); schliessen(new FormData(form).get("dok") as string | null); };
|
||||
});
|
||||
}
|
||||
|
||||
/** GAEB-Datei lesen (auch aus einem ZIP) */
|
||||
async function gaebDatei(f: File): Promise<{ dateiname: string; text: string }> {
|
||||
const b = new Uint8Array(await f.arrayBuffer());
|
||||
if (istZip(b)) {
|
||||
const e = (await entpacke(b)).find((x) => GAEB_ENDUNGEN.some((n) => x.name.toLowerCase().endsWith(n)) || x.name.toLowerCase().endsWith(".xml"));
|
||||
if (!e) throw new Error("Im ZIP steht keine GAEB-Datei.");
|
||||
return { dateiname: e.name.split("/").pop()!, text: dateiText(e.daten) };
|
||||
}
|
||||
return { dateiname: f.name, text: dateiText(b) };
|
||||
}
|
||||
|
||||
/** 3 · GAEB-Datei einlesen: Datei ziehen oder wählen, Vorschau, Kunde prüfen, dann Dokument anlegen */
|
||||
async function gaebDialog(projekt: Zeile, startArt: Belegart): Promise<void> {
|
||||
let art = startArt;
|
||||
let datei: { dateiname: string; text: string } | null = null;
|
||||
let v: Zeile | null = null;
|
||||
let fehler = "";
|
||||
const schliessen = () => { huelle.hidden = true; huelle.innerHTML = ""; removeEventListener("keydown", taste); };
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen();
|
||||
addEventListener("keydown", taste);
|
||||
|
||||
const zeichne = () => {
|
||||
const kunde = BELEG[art].gruppe === "kunde" && v?.auftraggeber;
|
||||
const kundeWahl = (): [string, string][] => [
|
||||
...(v!.kunde ? [["", `bleibt ${v!.kunde.name}`] as [string, string]] : [["", "nicht zuordnen"] as [string, string]]),
|
||||
...v!.treffer.filter((t: Zeile) => t.id !== v!.kunde?.id).map((t: Zeile): [string, string] => [t.id, `${t.name}${t.firma ? ` (${t.firma})` : ""} als Kunde`]),
|
||||
["neu", `„${v!.auftraggeber.name}“ als neuen Kontakt anlegen`],
|
||||
];
|
||||
const vorgabe = v?.kunde ? "" : v?.treffer?.[0]?.id ?? (v?.auftraggeber ? "neu" : "");
|
||||
huelle.innerHTML = `<form class="dialog gaeb-dialog"><h2>${esc(BELEG[art].name)} aus GAEB-Datei</h2>
|
||||
<label class="gaeb-ablage${datei ? " mit-datei" : ""}"><input type="file" hidden accept="${GAEB_ENDUNGEN.join(",")},.xml,.zip">
|
||||
<span>${datei ? `<b>${esc(datei.dateiname)}</b> · andere Datei wählen` : "GAEB-Datei hierher ziehen oder <u>auswählen</u>"}</span><small>X81–X86 (DA XML 3.x), P81–P86 (GAEB 2000), D81–D86 (GAEB 90), auch als ZIP</small></label>
|
||||
${v ? `<dl class="gaeb-vorschau">
|
||||
<dt>Format</dt><dd>${esc(v.format)}${v.version ? ` ${esc(v.version)}` : ""}</dd>
|
||||
<dt>Phase</dt><dd>${v.phase ? `${esc(v.phase)} ${esc(v.phase_name ?? "")}` : "nicht angegeben"}</dd>
|
||||
<dt>Inhalt</dt><dd>${v.titel} Titel · ${v.positionen} Pos.${v.mit_langtext ? ` · ${v.mit_langtext} mit Langtext` : ""}${v.mit_preis ? ` · ${v.mit_preis} mit Preis` : ""}${v.vortexte ? " · Vorbemerkungen" : ""}</dd>
|
||||
<dt>Bauvorhaben</dt><dd>${esc(v.projekt ?? v.name)}</dd>
|
||||
<dt>Auftraggeber</dt><dd>${v.auftraggeber ? `${esc(v.auftraggeber.name)}${v.auftraggeber.ort ? `, ${esc([v.auftraggeber.plz, v.auftraggeber.ort].filter(Boolean).join(" "))}` : ""}` : "nicht in der Datei"}</dd></dl>
|
||||
${kunde ? `<label for="gaeb-kunde">Kunde des Projekts</label><select id="gaeb-kunde">${optionenHtml(kundeWahl(), vorgabe)}</select>` : ""}
|
||||
${v.passt ? (v.hinweis ? `<p class="hinweis">${esc(v.hinweis)}</p>` : "") : `<div class="warnung">${esc(v.hinweis)}
|
||||
<button type="button" class="neben" data-a="wechseln" data-art="${v.vorschlag}">Als ${esc(BELEG[v.vorschlag as Belegart].name)} anlegen</button></div>`}
|
||||
<p class="hinweis">Danach öffnet sich ${art === "auftragsbestaetigung" ? "die" : "das"} ${esc(BELEG[art].name)} mit allen Positionen und Langtexten${v.mit_preis ? "; Preise aus der Datei werden feste Einheitspreise" : "; du kalkulierst nur noch"}.</p>` : ""}
|
||||
<p class="fehler">${esc(fehler)}</p>
|
||||
<div class="knoepfe"><button type="button" class="neben" data-a="abbrechen">Abbrechen</button>
|
||||
<button type="submit" class="haupt"${v ? "" : " disabled"}>${esc(BELEG[art].name)} anlegen</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const ablage = form.querySelector<HTMLLabelElement>(".gaeb-ablage")!;
|
||||
const lesen = async (f: File | undefined) => {
|
||||
if (!f) return;
|
||||
fehler = "";
|
||||
try {
|
||||
datei = await gaebDatei(f);
|
||||
v = await api<Zeile>("gaeb/vorschau", "POST", { ...datei, belegart: art, projekt_id: projekt.id });
|
||||
} catch (e) { v = null; fehler = (e as Error).message; }
|
||||
zeichne();
|
||||
};
|
||||
form.querySelector<HTMLInputElement>("input[type=file]")!.onchange = (ev) => void lesen((ev.target as HTMLInputElement).files?.[0]);
|
||||
ablage.ondragover = (ev) => { ev.preventDefault(); ablage.classList.add("drueber"); };
|
||||
ablage.ondragleave = () => ablage.classList.remove("drueber");
|
||||
ablage.ondrop = (ev) => { ev.preventDefault(); void lesen(ev.dataTransfer?.files[0]); };
|
||||
form.onclick = async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
if (t.dataset.a === "abbrechen") schliessen();
|
||||
if (t.dataset.a === "wechseln" && datei) {
|
||||
art = t.dataset.art as Belegart;
|
||||
v = await api<Zeile>("gaeb/vorschau", "POST", { ...datei, belegart: art, projekt_id: projekt.id });
|
||||
zeichne();
|
||||
}
|
||||
};
|
||||
form.onsubmit = async (ev) => {
|
||||
ev.preventDefault();
|
||||
if (!datei || !v) return;
|
||||
const k = form.querySelector<HTMLSelectElement>("#gaeb-kunde")?.value;
|
||||
const knopf = form.querySelector<HTMLButtonElement>("button[type=submit]")!;
|
||||
knopf.disabled = true;
|
||||
knopf.textContent = "Liest ein …";
|
||||
try {
|
||||
const a = await api<Zeile>("angebote/neu", "POST", { projekt_id: projekt.id, belegart: art, gaeb: { ...datei, ...(k ? { kunde: k } : {}) } });
|
||||
schliessen();
|
||||
location.hash = `angebot-${a.id}`;
|
||||
} catch (e) { fehler = (e as Error).message; zeichne(); }
|
||||
};
|
||||
};
|
||||
zeichne();
|
||||
}
|
||||
@@ -689,7 +689,7 @@ async function importSeite(): Promise<void> {
|
||||
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-ablage" data-ziel="gaeb"><input type="file" accept=".x81,.x82,.x83,.x84,.x85,.x86,.p81,.p82,.p83,.p84,.p85,.p86,.d81,.d82,.d83,.d84,.d85,.d86,.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>
|
||||
@@ -712,7 +712,7 @@ async function importSeite(): Promise<void> {
|
||||
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;
|
||||
if (!/\.([xpd]8\d|xml)$/i.test(f.name) && !f.text.includes("<GAEB") && !/#begin\[GAEB\]/i.test(f.text)) 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` : ""})`);
|
||||
}
|
||||
|
||||
@@ -700,6 +700,36 @@ tr.ausgeblendet td.auge-spalte { opacity: 1; }
|
||||
tr.leer td { color: var(--leise); text-align: center; padding: 22px; }
|
||||
.filter-menue { position: fixed; z-index: 30; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 10px; box-shadow: 0 10px 30px rgb(0 0 0 / 0.2); width: 290px; padding: 6px; font-size: 14px; }
|
||||
.filter-menue.ansichten-menue { width: 320px; }
|
||||
/* „+ Dokument“ (Henning 22.10.2026): Dokumentart, dann „erstellen aus …“ */
|
||||
.filter-menue.dok-menue { width: 320px; padding: 6px 6px 8px; }
|
||||
.dok-kopf { display: flex; align-items: center; gap: 6px; padding: 6px 8px 8px; font-weight: 600; border-bottom: 1px solid var(--linie); margin-bottom: 4px; }
|
||||
.dok-zurueck { border: 0; background: none; font-size: 20px; line-height: 1; color: var(--akzent); cursor: pointer; padding: 0 4px; }
|
||||
.dok-menue h4 { margin: 8px 8px 2px; font-size: 11.5px; font-weight: 600; letter-spacing: 0.06em; text-transform: uppercase; color: var(--leise); }
|
||||
.dok-eintrag { display: flex; align-items: center; justify-content: space-between; gap: 8px; width: 100%; padding: 8px 10px; border: 0; border-radius: 7px; background: none; color: var(--text); font: inherit; text-align: left; cursor: pointer; }
|
||||
.dok-eintrag:hover:not(:disabled) { background: var(--akzent-hell); }
|
||||
.dok-eintrag:disabled { color: var(--leise); opacity: 0.65; cursor: not-allowed; }
|
||||
.dok-eintrag > span { display: flex; flex-direction: column; min-width: 0; }
|
||||
.dok-eintrag small { font-size: 12px; color: var(--leise); }
|
||||
.dok-eintrag > small { flex: none; }
|
||||
.dok-eintrag b { color: var(--leise); font-weight: 400; }
|
||||
.dok-fuss { margin: 8px 10px 0; font-size: 12px; color: var(--leise); }
|
||||
.dok-menue .fehler { margin: 6px 10px 0; }
|
||||
.gaeb-dialog { max-width: 560px; }
|
||||
.gaeb-dialog .gaeb-ablage input { display: none; }
|
||||
.gaeb-dialog .gaeb-ablage small { display: block; }
|
||||
.gaeb-dialog .gaeb-ablage { display: flex; flex-direction: column; gap: 4px; align-items: center; justify-content: center; text-align: center; min-height: 96px; padding: 14px; border: 2px dashed var(--linie); border-radius: 10px; cursor: pointer; color: var(--text); }
|
||||
.gaeb-ablage small { color: var(--leise); font-size: 12px; }
|
||||
.gaeb-ablage.drueber, .gaeb-ablage:hover { border-color: var(--akzent); background: var(--akzent-hell); }
|
||||
.gaeb-ablage.mit-datei { min-height: 56px; }
|
||||
.gaeb-vorschau { display: grid; grid-template-columns: max-content 1fr; gap: 4px 14px; margin: 12px 0 4px; }
|
||||
.gaeb-vorschau dt { color: var(--leise); }
|
||||
.gaeb-vorschau dd { margin: 0; min-width: 0; overflow-wrap: anywhere; }
|
||||
.gaeb-dialog .warnung { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 8px 0; }
|
||||
.dok-wahl .dok-liste { list-style: none; margin: 8px 0; padding: 0; max-height: 50vh; overflow: auto; }
|
||||
.dok-wahl .dok-liste label { display: flex; gap: 8px; align-items: flex-start; padding: 6px 4px; border-bottom: 1px solid var(--linie); cursor: pointer; font-weight: 400; }
|
||||
.dok-wahl .dok-liste small { display: block; color: var(--leise); }
|
||||
.am-notiz { margin: 6px 0; font-size: 13px; }
|
||||
.am-notiz div { white-space: pre-wrap; max-height: 240px; overflow: auto; padding: 6px 0; color: var(--leise); }
|
||||
.filter-menue.blatt { left: 0; right: 0; bottom: 0; width: auto; border-radius: 14px 14px 0 0; max-height: 85vh; overflow: auto; padding: 8px max(10px, env(safe-area-inset-right, 0px)) calc(10px + env(safe-area-inset-bottom, 0px)) max(10px, env(safe-area-inset-left, 0px)); }
|
||||
.filter-menue hr { border: 0; border-top: 1px solid var(--linie); margin: 4px 0; }
|
||||
.fm-kopf { display: flex; align-items: center; justify-content: space-between; padding: 4px 6px 6px; }
|
||||
|
||||
Reference in New Issue
Block a user