Files
Betriebsf-hrungssoftware/src/web/angebote.ts
Claude 16ae77318e
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Handy-Ansicht Schritt 2 (0.25.0)
Leiste anpassbar, Mehr gruppiert, PC-Ansicht erzwingen; Listen mit Suche,
Filterblatt (mehrstufige Sortierung, Häkchen, Ansichten) und Wischen zum
Ausblenden; Projektseite mit Reitern Überblick/Ablauf/Geld/Ablage;
Terminplan als Tages-/Wochen-/Personenliste mit Warnungen und Freigabe;
Angebot am Handy (Menge/EP, freigeben, annehmen); Stammdaten nur lesen;
Stunden mit sichtbarem Pausenabzug und Verteilung auf die Einsätze.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-22 02:08:53 +00:00

1156 lines
89 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026), neue Maske nach den Bildern vom 21.10.2026: das
// Leistungsverzeichnis als Dokument wie der Ausdruck (Kopf, Einleitung, Positionen, Summe, Schlusstext); ein Klick öffnet die
// Position mit Reitern (Langtext, Aufmaß, Kalkulation, Zuschläge & Preis, Mehr). Rechts Reiter für Bausteine, Leistungen, KI, Vorgaben, Prüfung.
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
import { formatEuro, parseEuro } from "../domain/geld.js";
import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME, umgebungVon } from "../domain/kalkulation.js";
import { benenneUm, zahlDeutsch } from "../domain/formel.js";
import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js";
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
import 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, istHandy, lies, merke, optionenHtml, seite } from "./ui.js";
import { liste } from "./liste.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 MARKE: Record<string, string> = { entwurf: "grau", versendet: "offen", angenommen: "gut", abgelehnt: "schlecht" };
const prozentText = (n: number | null | undefined) => (n == null ? "–" : `${String(n).replace(".", ",")} %`);
const stdText = (h: number) => `${String(Math.round(h * 100) / 100).replace(".", ",")} Std.`;
/** Cent mit Nachkommastellen (je Einheit), auf den Cent gerundet angezeigt */
const euroGenau = (c: number) => formatEuro(Math.round(c));
/** Betrag ohne €-Zeichen für enge Tabellenspalten, deren Kopf schon „€“ oder „EK“ sagt */
const betrag = (c: number) => euroGenau(c).replace(/\s*\u20ac$/u, "");
export function angebotMarke(a: Zeile): string {
const abgelaufen = a.status === "versendet" && a.bindefrist && a.bindefrist < heute();
return `<span class="marke ${abgelaufen ? "schlecht" : MARKE[a.status] ?? "grau"}">${abgelaufen ? "Bindefrist abgelaufen" : esc(ANGEBOT_STATUS[a.status] ?? a.status)}</span>`;
}
/** Neues Angebot (oder neue Version) anlegen und öffnen */
export async function neuesAngebot(projektId: string, vonAngebot?: string): Promise<void> {
const a = await api<Zeile>("angebote/neu", "POST", { projekt_id: projektId, ...(vonAngebot ? { von_angebot_id: vonAngebot } : {}) });
location.hash = `angebot-${a.id}`;
}
/** 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>';
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>`;
}
// ---------- Liste aller Angebote ----------
export async function angeboteSeite(): Promise<void> {
const [zeilen, projekte] = await Promise.all([api<Zeile[]>("angebote-liste"), api<Zeile[]>("projekte")]);
const neu = async () => {
const offen = projekte.filter((p) => !["abgeschlossen", "gewaehrleistung"].includes(p.status))
.sort((a, b) => Number(["anfrage", "angebot"].includes(b.status)) - Number(["anfrage", "angebot"].includes(a.status)) || String(b.nummer).localeCompare(String(a.nummer)));
if (!offen.length) { hinweis.text = "Lege zuerst unter Projekte eine Anfrage an; das Angebot gehört zu einem Projekt."; return angeboteSeite(); }
const e = await dialog("Neues Angebot", [{ name: "projekt_id", titel: "Für Projekt", art: "auswahl", pflicht: true,
optionen: offen.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`]), hilfe: "Neue Anfragen legst du unter Projekte an." }], { projekt_id: offen[0]!.id }, false);
if (e?.aktion === "speichern") await neuesAngebot(e.daten.projekt_id);
};
seite("Angebote", { text: "Neues Angebot", aktion: () => void neu() });
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#projekte">Projekte</a>');
const rang = Object.fromEntries(Object.keys(ANGEBOT_STATUS).map((k, i) => [k, i]));
inhalt.appendChild(liste({
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: "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 },
{ id: "bindefrist", titel: "Bindefrist", art: "datum", wert: (a) => dat(a.bindefrist), sortWert: (a) => a.bindefrist, klasse: "optional" },
{ id: "status", titel: "Status", text: (a) => ANGEBOT_STATUS[a.status] ?? a.status, wert: angebotMarke, sortWert: (a) => rang[a.status] ?? 9 },
{ id: "netto", titel: "Netto", art: "zahl", wert: (a) => euro(a.netto), sortWert: (a) => a.netto, klasse: "zahl" },
],
zeilen, klick: (a) => (location.hash = `angebot-${a.id}`),
fuss: (s) => {
const offen = s.filter((a) => a.status === "versendet");
return `<p>Offen (versendet): <strong>${euro(offen.reduce((t, a) => t + a.netto, 0))}</strong> in ${offen.length} ${offen.length === 1 ? "Angebot" : "Angeboten"}</p>`;
},
}));
}
// ---------- Angebot bearbeiten (neue Maske, Bilder 1 bis 5 vom 21.10.2026) ----------
/** Reiter einer offenen Position (Henning, 21.10.2026: „kann ich zwischen den Reitern wechseln?“) */
type Tab = "langtext" | "aufmass" | "kalk" | "preis" | "mehr";
const TABS: Tab[] = ["langtext", "aufmass", "kalk", "preis", "mehr"];
interface Zustand {
angebot: string;
/** offene Zeile (Position mit Reitern, Titel oder Text zum Bearbeiten) */
aktiv: string | null;
/** zuletzt offene Zeile: darunter wird eingefügt, auch nach „Fertig“ */
ziel: string | null;
/** aufgeklappte Gruppen langer Kostenzeilen „<id>:<kostenart>“ */
auf: Set<string>;
/** Seitenleiste: immer nur ein Panel */
reiter: "bausteine" | "leistungen" | "ki" | "vorgaben" | "pruefung";
/** im Reiter Leistungen: Leistungen, Mengenvorlagen oder Material */
katalog: "leistungen" | "mengen" | "material";
suche: string;
/** Reiter Leistungen: Ordner-Filter */
ordner: string;
/** 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 })[] };
/** Stand der offenen Position beim Öffnen, für „Abbrechen“ */
vorher: { position: Zeile; kosten: Zeile[] } | null;
}
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 };
return zustand;
};
/** Die Position merkt sich ihren zuletzt offenen Reiter (in diesem Browser) */
const TAB_SCHLUESSEL = "angebot-position-reiter";
function gemerkteTabs(): Record<string, Tab> {
try { return JSON.parse(lies(TAB_SCHLUESSEL) ?? "{}") as Record<string, Tab>; } catch { return {}; }
}
function tabVon(p: Zeile): Tab {
const t = gemerkteTabs()[p.id];
if (t && TABS.includes(t)) return t;
return p.mit_kalkulation ? "kalk" : p.mit_aufmass ? "aufmass" : "langtext";
}
function merkeTab(pid: string, t: Tab): void {
const alle = gemerkteTabs();
delete alle[pid];
alle[pid] = t;
const schluessel = Object.keys(alle);
for (const k of schluessel.slice(0, Math.max(0, schluessel.length - 300))) delete alle[k];
merke(TAB_SCHLUESSEL, JSON.stringify(alle));
}
export const angebotSeite = (id: string) => editor(id, null);
/** Großes Mengenblatt einer Position (Bilder 3 und 4) */
export async function mengenblattSeite(positionId: string): Promise<void> {
const p = await api<Zeile>(`angebot-positionen/${positionId}`);
zustandFuer(p.angebot_id).aktiv = positionId;
return editor(p.angebot_id, positionId);
}
/** OZ aus der Reihenfolge: Titel 01, Positionen 01.0001 (eigene OZ aus einem Import geht vor); Textzeilen ohne OZ */
function ordnung(d: Zeile) {
const oz: Record<string, string> = {};
const gruppen: { titel: Zeile | null; positionen: Zeile[] }[] = [];
const ohne = d.positionen.filter((p: Zeile) => !p.titel_id);
if (ohne.length || !d.titel.length) gruppen.push({ titel: null, positionen: ohne });
d.titel.forEach((t: Zeile, i: number) => {
oz[t.id] = t.oz || String(i + 1).padStart(2, "0");
gruppen.push({ titel: t, positionen: d.positionen.filter((p: Zeile) => p.titel_id === t.id) });
});
for (const g of gruppen) {
let n = 0;
for (const p of g.positionen) {
if (p.textzeile) { oz[p.id] = ""; continue; }
n++;
oz[p.id] = p.oz || (g.titel ? `${oz[g.titel.id]}.${String(n).padStart(4, "0")}` : String(n).padStart(2, "0"));
}
}
return { oz, gruppen };
}
async function editor(id: string, gross: string | null): Promise<void> {
const z = zustandFuer(id);
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");
inhalt.replaceChildren(wurzel);
const zeichne = () => {
// Stand der eben geöffneten Position für „Abbrechen“ festhalten
const offen = z.aktiv ? d.positionen.find((x: Zeile) => x.id === z.aktiv && !x.textzeile) : null;
if (!offen) z.vorher = null;
else if (z.vorher?.position.id !== offen.id) z.vorher = { position: structuredClone(offen), kosten: structuredClone(d.kosten.filter((k: Zeile) => k.position_id === offen.id)) };
if (z.aktiv) z.ziel = z.aktiv;
// Fokus und gerade Getipptes über den Neuaufbau retten (gespeichert wird beim Verlassen eines Feldes)
const fokus = document.activeElement as HTMLInputElement | null;
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) : istHandy() ? handyHtml(d, meldung) : html(d, z, vorlagen, meldung, leistungen);
if (k) {
const neu = wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`);
if (neu) {
if (getippt !== null) neu.value = getippt;
neu.focus();
if (auswahl) try { neu.setSelectionRange(auswahl[0]!, auswahl[1] ?? null); } catch { /* Auswahlfeld */ }
}
}
};
const neuLaden = async (m = "") => {
d = await api<Zeile>(`angebote/${id}/voll`);
meldung = m;
zeichne();
};
const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); };
const pos = (pid: string) => d.positionen.find((x: Zeile) => x.id === pid) as Zeile | undefined;
const reihe = (titelId: string | null) => d.positionen.filter((p: Zeile) => (p.titel_id ?? null) === titelId);
const kostenVon = (pid: string) => d.kosten.filter((x: Zeile) => x.position_id === pid) as Zeile[];
/** Mengenblatt einer Position ändern: Blatt und neue Menge zusammen speichern */
const blattSpeichern = async (pid: string, aendern: (b: Blatt) => string[] | boolean) => {
const p = pos(pid)!;
const b = alsBlatt(structuredClone(p.aufmass ?? leeresBlatt()));
const umbenannt = aendern(b);
if (umbenannt === false) return;
const menge = werteBlatt(b, umgebungVon(d.saetze)).menge;
await api(`angebot-positionen/${pid}`, "PATCH", { aufmass: b, ...(menge !== null ? { menge } : {}) });
// ein umbenanntes Kürzel auch im Bezug der Kostenzeilen
if (Array.isArray(umbenannt) && umbenannt.length === 2) {
for (const k of kostenVon(pid)) {
const neu = k.bezug ? benenneUm(k.bezug, umbenannt[0]!, umbenannt[1]!) : k.bezug;
if (neu !== k.bezug) await api(`angebot-kosten/${k.id}`, "PATCH", { bezug: neu });
}
}
};
const speichern = async (el: HTMLInputElement) => {
const [pfad, zid, ...rest] = el.dataset.k!.split(":") as [string, string, ...string[]];
const feld = rest.join(":");
if (pfad === "blatt") return blattSpeichern(zid, (b) => setze(b, feld, el.value));
const typ = el.dataset.typ ?? "text";
const roh = el.value.trim();
let wert: unknown;
if (typ === "bool") wert = el.checked;
else if (typ === "euro") wert = roh ? parseEuro(roh) : null;
else if (typ === "zahl") wert = roh ? zahlAus(roh) : el.dataset.leer === "null" ? null : 0;
else wert = roh || (el.dataset.leer === "pflicht" ? undefined : null);
if (wert === undefined) { el.value = el.defaultValue; throw new Error("Das Feld darf nicht leer sein."); }
if (pfad === "verkauf") {
// Zuschlag je Kostenart der Position (Bild 2, „Verkauf und Zuschläge“): gilt für alle Zeilen dieser Art
for (const k of kostenVon(zid).filter((x) => x.kostenart === feld)) await api(`angebot-kosten/${k.id}`, "PATCH", { zuschlag_prozent: wert });
return;
}
if (pfad === "saetze") {
// Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben
const s: Zeile = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, kilometersatz: d.saetze.kilometersatz, stand: d.angebot.saetze?.stand ?? heute() };
if (zid === "km") s.kilometersatz = wert ?? 0;
else s[zid][feld] = wert ?? 0;
return api(`angebote/${id}`, "PATCH", { saetze: s });
}
let body: Zeile = { [feld]: wert };
if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null };
if (pfad === "angebot-kosten" && feld === "kostenart") {
const kz = d.kosten.find((x: Zeile) => x.id === zid);
body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? "geselle" : null,
...(wert === "lohn" ? { einheit: "h" } : wert === "fahrt" ? { einheit: "km" } : ["h", "km"].includes(kz?.einheit) ? { einheit: null } : {}) };
}
return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body);
};
const verschieben = async (pfad: string, liste: Zeile[], zid: string, richtung: number) => {
const i = liste.findIndex((x) => x.id === zid), j = i + richtung;
if (i < 0 || j < 0 || j >= liste.length) return;
const neu = [...liste];
[neu[i], neu[j]] = [neu[j]!, neu[i]!];
for (const [n, x] of neu.entries()) if (Number(x.reihenfolge) !== n) await api(`${pfad}/${x.id}`, "PATCH", { reihenfolge: n });
};
/** Baustein, Musterposition oder Mengenvorlage unter der markierten Zeile einfügen */
const einfuegen = async (was: string, nachId: string | null, vorlageId?: string, inPosition?: string) => {
if (was === "vorlage") {
const v = vorlagen.find((x) => String(x.id) === vorlageId);
if (!v) return;
if (inPosition) {
const b = alsBlatt(pos(inPosition)?.aufmass);
if ((b.werte.length || b.listen.length) && !(await bestaetigen(`Das Mengenblatt hat schon ${b.vorlage ? `die Vorlage „${b.vorlage.name}“` : "Eingaben"}. Durch „${v.name}“ ersetzen? Die Aufmaßzeilen bleiben.`))) return;
}
const eingaben = await eingabenAbfragen(v);
if (!eingaben) return;
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was, vorlage_id: v.id, nach_id: nachId, ...(inPosition ? { position_id: inPosition } : {}), eingaben });
z.aktiv = r.id;
if (inPosition) merkeTab(r.id, "aufmass");
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;
await neuLaden();
const ziel = was === "titel" ? `angebot-titel:${r.id}:bezeichnung` : `angebot-positionen:${r.id}:kurztext`;
wurzel.querySelector<HTMLInputElement>(`[data-k="${ziel}"]`)?.select();
};
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", "Leistung mit Texten und Kalkulation"], ["mengen", "nur Mengenvorlage"]] },
{ name: "name", titel: "Name", pflicht: true },
{ 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, 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();
};
const kopieren = async (pid: string) => {
const p = pos(pid)!;
const n = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was: p.textzeile ? "text" : "position", nach_id: pid });
await api(`angebot-positionen/${n.id}`, "PATCH", { kurztext: p.kurztext, langtext: p.langtext, menge: Number(p.menge), einheit: p.einheit, art: p.art,
ep_fest: p.ep_fest == null ? null : Number(p.ep_fest), mit_kalkulation: p.mit_kalkulation, mit_aufmass: p.mit_aufmass, aufmass: p.aufmass, markiert: p.markiert });
for (const k of kostenVon(pid)) {
await api("angebot-kosten", "POST", { position_id: n.id, kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, menge: Number(k.menge), einheit: k.einheit,
ek: k.ek == null ? null : Number(k.ek), faktor: Number(k.faktor), faktor_grund: k.faktor_grund, zuschlag_prozent: k.zuschlag_prozent == null ? null : Number(k.zuschlag_prozent),
bezug: k.bezug, personen: Number(k.personen), aktiv: k.aktiv, aus_vorlage: k.aus_vorlage, reihenfolge: k.reihenfolge });
}
z.aktiv = n.id;
return neuLaden();
};
/** Aufmaß, Kalkulation und Markierung einer Position ein- und ausschalten */
const schalter = async (pid: string, was: string) => {
const p = pos(pid)!, r = d.ergebnis.positionen[pid];
if (was === "aufmass") {
if (p.mit_aufmass) await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: false, menge: r.menge });
else {
// ohne Mengenblatt: erste Aufmaßzeile mit der bisherigen Menge, damit nichts verloren geht
const b = alsBlatt(p.aufmass);
if (!b.werte.length && !b.listen.length && !b.zeilen.length) b.zeilen.push({ text: "", formel: zahlText(p.menge) });
await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: true, aufmass: b });
merkeTab(pid, "aufmass");
}
return neuLaden();
}
if (was === "kalkulation") {
// aus: der Preis bleibt als fester Preis stehen; an: der Preis kommt wieder aus den Kostenzeilen
if (p.mit_kalkulation) await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: false, ep_fest: r.ep });
else {
await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: true, ep_fest: null });
merkeTab(pid, "kalk");
}
return neuLaden();
}
if (was === "markiert") { await api(`angebot-positionen/${pid}`, "PATCH", { markiert: !p.markiert }); return neuLaden(); }
};
/** „Abbrechen“: Position und Kostenzeilen auf den Stand beim Öffnen zurücksetzen */
const FELDER_P = ["kurztext", "langtext", "menge", "einheit", "art", "grundposition_id", "ep_fest", "mit_kalkulation", "mit_aufmass", "aufmass", "markiert"];
const FELDER_K = ["kostenart", "lohnart", "beschreibung", "menge", "einheit", "ek", "faktor", "faktor_grund", "zuschlag_prozent", "bezug", "personen", "aktiv", "aus_vorlage", "reihenfolge"];
const zahlOderNull = (v: unknown) => (v == null ? null : Number(v));
const auswahlP = (p: Zeile) => ({ ...Object.fromEntries(FELDER_P.map((f) => [f, p[f] ?? null])), menge: Number(p.menge), ep_fest: zahlOderNull(p.ep_fest) });
const auswahlK = (k: Zeile) => ({ ...Object.fromEntries(FELDER_K.map((f) => [f, k[f] ?? null])), menge: Number(k.menge), ek: zahlOderNull(k.ek), faktor: Number(k.faktor),
zuschlag_prozent: zahlOderNull(k.zuschlag_prozent), personen: Number(k.personen ?? 1), reihenfolge: Number(k.reihenfolge) });
const abbrechen = async () => {
const v = z.vorher, jetzt = v && pos(v.position.id);
z.aktiv = null;
if (!v || !jetzt) return zeichne();
const pAlt = auswahlP(v.position);
const geaendertP = JSON.stringify(pAlt) !== JSON.stringify(auswahlP(jetzt));
const kAlt = v.kosten.map(auswahlK), kJetzt = kostenVon(jetzt.id);
const geaendertK = JSON.stringify(kAlt) !== JSON.stringify(kJetzt.map(auswahlK));
if (geaendertP) await api(`angebot-positionen/${jetzt.id}`, "PATCH", pAlt);
if (geaendertK) {
for (const k of kJetzt) await api(`angebot-kosten/${k.id}`, "DELETE");
for (const k of kAlt) await api("angebot-kosten", "POST", { position_id: jetzt.id, ...k });
}
return neuLaden(geaendertP || geaendertK ? `Änderungen an ${ordnung(d).oz[jetzt.id] ?? "der Position"} verworfen.` : "");
};
zeichne();
wurzel.addEventListener("change", async (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.dataset?.k) return;
try { await speichern(el); await neuLaden(); } catch (e) { fehler(e); }
});
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, 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;
// Enter speichert ein Eingabefeld und springt in die Zeile darunter (wie in Excel)
if (ev.key !== "Enter" || el.tagName !== "INPUT" || !el.dataset.k) return;
ev.preventDefault();
const felder = [...wurzel.querySelectorAll<HTMLInputElement>(`input[data-spalte="${el.dataset.spalte}"]`)];
const weiter = felder[felder.indexOf(el) + 1];
if (weiter && el.dataset.spalte) weiter.focus(); else el.blur();
});
// Bausteine und Vorlagen aus der Seitenleiste in die Liste ziehen
wurzel.addEventListener("dragstart", (ev) => {
const q = (ev.target as HTMLElement).closest<HTMLElement>("[data-zieh]");
if (q) ev.dataTransfer?.setData("text/plain", q.dataset.zieh!);
});
wurzel.addEventListener("dragover", (ev) => {
const ziel = (ev.target as HTMLElement).closest<HTMLElement>("[data-zeile], .am-lv");
if (!ziel || !ev.dataTransfer?.types.includes("text/plain")) return;
ev.preventDefault();
wurzel.querySelectorAll(".am-ziel").forEach((x) => x.classList.remove("am-ziel"));
ziel.classList.add("am-ziel");
});
wurzel.addEventListener("dragleave", (ev) => (ev.target as HTMLElement).closest?.(".am-ziel")?.classList.remove("am-ziel"));
wurzel.addEventListener("drop", async (ev) => {
const was = ev.dataTransfer?.getData("text/plain");
wurzel.querySelectorAll(".am-ziel").forEach((x) => x.classList.remove("am-ziel"));
if (!was) return;
ev.preventDefault();
const zeile = (ev.target as HTMLElement).closest<HTMLElement>("[data-zeile]")?.dataset.zeile ?? null;
try {
if (was.startsWith("vorlage:")) await einfuegen("vorlage", zeile, was.slice(8));
else await einfuegen(was, zeile);
} catch (e) { fehler(e); }
});
wurzel.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]");
if (!b) return;
const a = b.dataset.a!, zid = b.dataset.id ?? "";
// Menü der Zeile nach der Wahl schließen
b.closest("details.am-menue")?.removeAttribute("open");
try {
// Handy: Titel auf- und zuklappen, Position antippen = Menge und Einheitspreis ändern
if (a === "h-titel") { HANDY_ZU.has(zid) ? HANDY_ZU.delete(zid) : HANDY_ZU.add(zid); return zeichne(); }
if (a === "h-pos") return await handyPosition(zid);
if (a === "aktiv") {
if (z.aktiv === zid) return;
z.aktiv = zid;
zeichne();
// in das angeklickte Feld springen (Menge, Einheit oder Kurztext)
const f = (ev.target as HTMLElement).closest<HTMLElement>("[data-fokus]")?.dataset.fokus ?? "kurztext";
const ziel = wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-positionen:${zid}:${f}"]`) ?? wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-titel:${zid}:bezeichnung"]`)
?? wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-positionen:${zid}:kurztext"]`);
ziel?.focus();
return;
}
if (a.startsWith("b-")) {
const pid = b.dataset.b!.split(":")[1]!;
return await blattSpeichern(pid, (x) => blattAktion(x, a, b.dataset)).then(() => neuLaden());
}
if (a === "chip") return await schalter(zid, b.dataset.was!);
if (a === "tab") { merkeTab(zid, b.dataset.was as Tab); return zeichne(); }
if (a === "kosten-auf") { const k = `${zid}:${b.dataset.was}`; z.auf.has(k) ? z.auf.delete(k) : z.auf.add(k); return zeichne(); }
if (a === "fertig") { z.aktiv = null; return zeichne(); }
if (a === "abbrechen") return await abbrechen();
if (a === "reiter" || a === "katalog") {
z.reiter = a === "katalog" ? "leistungen" : b.dataset.was as Zustand["reiter"];
if (a === "katalog") z.katalog = b.dataset.was as Zustand["katalog"];
zeichne();
const leiste = wurzel.querySelector<HTMLElement>(".am-leiste");
leiste?.scrollIntoView({ block: "nearest" });
leiste?.querySelector<HTMLInputElement>("input.suche")?.focus({ preventScroll: true });
return;
}
if (a === "neu") return await einfuegen(b.dataset.was!, z.aktiv ?? z.ziel);
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 ?? z.ziel;
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.auf.add(`${p.id}:material`);
merkeTab(p.id, "kalk");
return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`);
}
if (a === "vorlage") return await einfuegen("vorlage", z.aktiv ?? z.ziel, zid, b.dataset.in);
if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; }
if (a === "als-vorlage") return await alsVorlage(zid);
if (a === "kosten-neu") {
const art = b.dataset.art!;
const p = pos(zid)!;
const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null;
const fahrt = art === "fahrt";
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1,
beschreibung: fahrt ? "Fahrt zur Baustelle" : null,
bezug: fahrt ? null : blatt?.menge?.trim() || null, einheit: art === "lohn" ? "h" : fahrt ? "km" : p.einheit ?? null, reihenfolge: kostenVon(zid).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) });
z.auf.add(`${zid}:${art}`);
await neuLaden();
wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-kosten:${k.id}:beschreibung"]`)?.focus();
return;
}
if (a === "kosten-weg") { await api(`angebot-kosten/${zid}`, "DELETE"); return neuLaden(); }
if (a === "position-weg") {
const p = pos(zid)!;
if (!(await bestaetigen(p.textzeile ? "Textzeile löschen?" : "Position mit Mengenblatt und Kostenzeilen löschen?"))) return;
await api(`angebot-positionen/${zid}`, "DELETE");
if (z.aktiv === zid) z.aktiv = null;
if (z.ziel === zid) z.ziel = null;
return neuLaden();
}
if (a === "titel-weg") {
const n = reihe(zid).length;
if (!(await bestaetigen(n ? `Titel mit ${n} ${n === 1 ? "Zeile" : "Zeilen"} löschen?` : "Titel löschen?"))) return;
await api(`angebot-titel/${zid}`, "DELETE");
return neuLaden();
}
if (a === "position-kopie") return await kopieren(zid);
if (a === "position-hoch" || a === "position-runter") {
const p = pos(zid)!;
await verschieben("angebot-positionen", reihe(p.titel_id ?? null), zid, a === "position-hoch" ? -1 : 1);
return neuLaden();
}
if (a === "titel-hoch" || a === "titel-runter") { await verschieben("angebot-titel", d.titel, zid, a === "titel-hoch" ? -1 : 1); return neuLaden(); }
if (a === "pruefung") {
const pid = b.dataset.pos;
if (pid) {
if (gross) { location.hash = `angebot-${id}`; z.aktiv = pid; return; }
z.aktiv = pid; zeichne(); wurzel.querySelector(`[data-zeile="${pid}"]`)?.scrollIntoView({ block: "center" });
}
return;
}
if (a === "versenden") return await versenden(false);
if (a === "bearbeiten") { await api(`angebote/${id}/bearbeiten`, "POST", {}); return neuLaden("Das Angebot ist wieder im Entwurf. Der versendete Stand bleibt gespeichert."); }
if (a === "ablehnen") {
if (!(await bestaetigen("Angebot als abgelehnt markieren?"))) return;
await api(`angebote/${id}/ablehnen`, "POST", {});
return neuLaden();
}
if (a === "annehmen") return await annehmen();
if (a === "version") {
if (!(await bestaetigen("Neue Version als Kopie dieses Angebots anlegen?"))) return;
return await neuesAngebot(d.angebot.projekt_id, id);
}
if (a === "loeschen") {
if (!(await bestaetigen(`${BELEGART[d.angebot.belegart]} ${d.angebot.nummer} löschen?`))) return;
await api(`angebote/${id}`, "DELETE");
location.hash = `projekt-${d.angebot.projekt_id}-dokumente`;
return;
}
} catch (e) { fehler(e); }
});
async function handyPosition(pid: string): Promise<void> {
const p = pos(pid)!, r = d.ergebnis.positionen[pid];
if (d.angebot.status !== "entwurf") return;
const felder: Feld[] = [
...(p.mit_aufmass ? [] : [{ name: "menge", titel: `Menge (${p.einheit})`, art: "zahl" } as Feld]),
{ name: "ep_fest", titel: `Einheitspreis je ${p.einheit}`, art: "euro",
hilfe: p.mit_kalkulation ? `Aus der Kalkulation ${euro(r.ep)}. Leer lassen, um den kalkulierten Preis zu nehmen.` : undefined },
];
const e = await dialog(`${p.kurztext}`, felder, { menge: Number(p.menge), ep_fest: p.ep_fest == null ? null : Number(p.ep_fest) }, false);
if (e?.aktion !== "speichern") return;
const body: Zeile = { ep_fest: e.daten.ep_fest ?? null };
if (!p.mit_aufmass) body.menge = e.daten.menge ?? 0;
await api(`angebot-positionen/${pid}`, "PATCH", body);
return neuLaden();
}
// A14: Versandprüfung; mit Fehlern nur nach ausdrücklichem „trotzdem“
async function versenden(trotzdem: boolean): Promise<void> {
const r = await api<Zeile>(`angebote/${id}/versenden`, "POST", { trotzdem });
if (r.versendet) return neuLaden(`Als versendet markiert am ${dat(heute())}. Kalkulation und Preise sind jetzt festgeschrieben.`);
const fehlerListe = r.pruefung.filter((p: Zeile) => p.stufe === "fehler");
huelle.innerHTML = `<div class="dialog"><h2>Vor dem Versand bitte prüfen</h2>
<ul class="pruefung">${r.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${esc(p.text)}</li>`).join("")}</ul>
<p class="hinweis">${fehlerListe.length} ${fehlerListe.length === 1 ? "Punkt verhindert" : "Punkte verhindern"} den Versand. Du kannst trotzdem versenden, wenn das so gewollt ist.</p>
<div class="knoepfe"><button class="neben" data-p="trotzdem">Trotzdem versenden</button><button class="haupt" data-p="zurueck">Zurück zum Angebot</button></div></div>`;
huelle.hidden = false;
const wahl = await new Promise<string>((fertig) => huelle.querySelector(".dialog")!.addEventListener("click", (ev) => {
const p = (ev.target as HTMLElement).dataset.p;
if (p) fertig(p);
}));
huelle.hidden = true;
huelle.innerHTML = "";
if (wahl === "trotzdem") return versenden(true);
}
// A4: aus dem Angebot wird der Auftrag
async function annehmen(): Promise<void> {
const felder: Feld[] = [
{ name: "start", titel: "Ausführung ab", art: "datum", hilfe: d.ergebnis.stunden ? `Aus jedem Titel wird ein Abschnitt im Terminplan; die Dauer ergibt sich aus den ${stdText(d.ergebnis.stunden)}.` : "Aus jedem Titel wird ein Abschnitt im Terminplan." },
{ name: "personen", titel: "Personen auf der Baustelle", art: "zahl" },
];
const e = await dialog(`${BELEGART[d.angebot.belegart]} ${d.angebot.nummer} annehmen`, felder, { start: plusTage(heute(), 14), personen: 2 }, false);
if (e?.aktion !== "speichern") return;
const r = await api<Zeile>(`angebote/${id}/annehmen`, "POST", { start: e.daten.start ?? undefined, personen: e.daten.personen ?? 2 });
hinweis.gut = true;
hinweis.text = `Auftrag ${r.nummer}: Auftragswert ${euro(r.umsatz)} netto${r.abschnitte ? `, ${r.abschnitte} ${r.abschnitte === 1 ? "Abschnitt" : "Abschnitte"} im Terminplan` : ", der vorhandene Terminplan bleibt"}. Der Zahlungsplan entsteht aus Auftragswert und Terminen.`;
location.hash = `projekt-${r.projekt_id}`;
}
}
// ---------- Handy (Henning „Ok“, 21.10.2026): ansehen, Menge und EP ändern, freigeben, senden, annehmen ----------
const HANDY_ZU = new Set<string>();
function handyHtml(d: Zeile, meldung: string): string {
const a = d.angebot, e = d.ergebnis;
const frei = a.status === "entwurf";
const { oz, gruppen } = ordnung(d);
const zeile = (p: Zeile) => {
if (p.textzeile) return `<li class="ah-text">${esc(p.kurztext)}</li>`;
const r = e.positionen[p.id];
const blatt = p.mit_aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(d.saetze)) : null;
const hinweise = d.pruefung.filter((x: Zeile) => x.position_id === p.id);
return `<li><button class="ah-pos${r.zaehlt ? "" : " zaehlt-nicht"}" data-a="h-pos" data-id="${p.id}"${frei ? "" : " disabled"}>
<span><b>${esc(oz[p.id])} ${esc(blatt ? textMitWerten(p.kurztext, blatt) : p.kurztext)}</b><span class="unter">${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)} × ${euro(r.ep)}${p.art !== "normal" && (POSITIONSART_NAME as Record<string, string>)[p.art] ? ` · ${esc((POSITIONSART_NAME as Record<string, string>)[p.art])}` : ""}
${hinweise.map((x: Zeile) => `<span class="marke ${x.stufe === "fehler" ? "schlecht" : "offen"}">${esc(x.text)}</span>`).join("")}</span></span>
<span class="z">${r.zaehlt ? euro(r.gb) : `(${euro(r.gb)})`}</span></button></li>`;
};
const lv = gruppen.map((g) => {
if (!g.titel) return `<ul class="ah-liste">${g.positionen.map(zeile).join("")}</ul>`;
const zu = HANDY_ZU.has(g.titel.id);
return `<button class="ah-titel" data-a="h-titel" data-id="${g.titel.id}" aria-expanded="${!zu}"><span>${zu ? "▸" : "▾"} ${esc(oz[g.titel.id])} ${esc(g.titel.bezeichnung)}</span><b>${euro(e.titel[g.titel.id])}</b></button>
${zu ? "" : `<ul class="ah-liste">${g.positionen.map(zeile).join("")}</ul>`}`;
}).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 = {
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] ?? "";
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>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
<p class="hinweis ah-banner">Am Handy: ansehen, Mengen und Preise ändern, freigeben. Kalkulation und Vorlagen bearbeiten am PC.</p>
<section class="karte ah-lv">${lv || '<p class="hinweis leer">Noch keine Positionen.</p>'}</section>
<section class="karte stand-zahlen"><div><small>Netto</small><b>${euro(e.netto)}</b></div><div><small>Brutto</small><b>${euro(e.brutto)}</b></div>
<div><small>Überschuss</small><b class="${e.kosten ? (e.netto - e.kosten >= 0 ? "gut" : "schlecht") : ""}">${e.kosten ? prozentText(e.ueberschuss_prozent) : "–"}</b></div></section>
<section class="karte ah-pruefung${fehler ? " schlecht" : ""}"><b>Prüfung:</b> ${n ? `${n} ${n === 1 ? "Hinweis" : "Hinweise"}` : "in Ordnung"}${a.bindefrist ? ` · Bindefrist bis ${dat(a.bindefrist)}` : ""}
${allgemein.length ? `<ul class="pruefung">${allgemein.map((p: Zeile) => `<li class="${p.stufe}">${esc(p.text)}</li>`).join("")}</ul>` : ""}</section>
<div class="ah-knoepfe">${knoepfe}</div></div>`;
}
// ---------- Darstellung (Dokumentansicht wie das spätere PDF, Henning 21.10.2026) ----------
type Feldoptionen = { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string; nurLesen?: boolean };
const feldBau = (frei: boolean) => (k: string, wert: unknown, o: Feldoptionen = {}) =>
`<input data-k="${k}"${o.typ ? ` data-typ="${o.typ}"` : ""}${o.leer ? ` data-leer="${o.leer}"` : ""}${o.spalte ? ` data-spalte="${o.spalte}"` : ""} value="${esc(wert)}"
${o.typ === "euro" || o.typ === "zahl" ? 'inputmode="decimal"' : ""} class="${o.klasse ?? ""}"${o.titel ? ` aria-label="${esc(o.titel)}" title="${esc(o.titel)}"` : ""}${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.liste ? ` list="${o.liste}"` : ""}${frei ? "" : " disabled"}>`;
const auswahlBau = (frei: boolean) => (k: string, optionen: [string, string][], wert: string, titel: string) =>
`<select data-k="${k}" aria-label="${esc(titel)}"${frei ? "" : " disabled"}>${optionenHtml(optionen, wert)}</select>`;
const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false));
const wgp = (s: Zeile) => s.wagnis + s.gewinn + s.ausfall;
/** Fließtext wie im Ausdruck: Feld ohne Rahmen, wächst mit dem Inhalt */
const fliesstext = (k: string, wert: string | null | undefined, platz: string, frei: boolean, titel: string) =>
`<textarea class="am-fliess" data-k="${k}" rows="${Math.max(2, String(wert ?? "").split("\n").length + 1)}" placeholder="${esc(platz)}" aria-label="${esc(titel)}"${frei ? "" : " disabled"}>${esc(wert ?? "")}</textarea>`;
const ZEILEN_NAME: Record<string, string> = { lohn: "Lohnzeilen", material: "Materialzeilen", geraet: "Gerätezeilen", fahrt: "Fahrtzeilen", subunternehmer: "Subunternehmerzeilen", sonstiges: "sonstige Zeilen" };
/** ab so vielen Zeilen einer Kostenart werden die übrigen eingeklappt */
const GRUPPE_AB = 4, GRUPPE_SICHTBAR = 2;
/** Kostenzeilen einer Position: Bezug × Ansatz × Personen = Menge der ganzen Position. Lange Gruppen einer Kostenart sind eingeklappt. */
function kostenTabelle(d: Zeile, p: Zeile, frei: boolean, auf?: Set<string>): string {
const feld = feldBau(frei), auswahl = auswahlBau(frei);
const s = d.saetze, r = d.ergebnis.positionen[p.id];
const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id) as Zeile[];
const menge = r.menge;
let lohnStd = 0, summe = 0;
const erg = (i: number) => r.kostenzeilen[i] ?? { kosten: 0, menge_gesamt: 0, aktiv: true, fehler: null };
// je Kostenart: welche Zeilen bleiben sichtbar, wo steht die Klappzeile
const versteckt = new Set<number>(), klappNach = new Map<number, string>(), zuNach = new Map<number, string>();
if (auf) {
for (const art of KOSTENARTEN) {
const idx = zeilen.flatMap((k, i) => (k.kostenart === art ? [i] : []));
if (idx.length < GRUPPE_AB) continue;
if (auf.has(`${p.id}:${art}`)) { zuNach.set(idx.at(-1)!, art); continue; }
const rest = idx.slice(GRUPPE_SICHTBAR).filter((i) => !erg(i).fehler);
if (rest.length < 2) continue;
rest.forEach((i) => versteckt.add(i));
klappNach.set(idx.filter((i) => !versteckt.has(i)).at(-1)!, art);
}
}
const klappZeile = (art: string, offen: boolean) => {
if (offen) return `<tr class="am-klapp"><td colspan="11"><button class="verweis" data-a="kosten-auf" data-id="${p.id}" data-was="${art}">▴ ${ZEILEN_NAME[art]} einklappen</button></td></tr>`;
const teil = [...versteckt].filter((i) => zeilen[i]!.kostenart === art);
const std = teil.reduce((t, i) => t + (art === "lohn" && erg(i).aktiv ? erg(i).menge_gesamt : 0), 0);
const eur = teil.reduce((t, i) => t + (erg(i).aktiv ? erg(i).kosten * menge : 0), 0);
const namen = teil.map((i) => zeilen[i]!.beschreibung).filter(Boolean).slice(0, 3).join(", ");
return `<tr class="am-klapp"><td colspan="11"><button class="verweis" data-a="kosten-auf" data-id="${p.id}" data-was="${art}">▸ ${teil.length} weitere ${ZEILEN_NAME[art]}${namen ? ` (${esc(namen)}${teil.length > 3 ? " …" : ""})` : ""}</button>
<span class="hinweis-k">${std ? `${stdText(std)} · ` : ""}${euroGenau(eur)}</span></td></tr>`;
};
const rumpf = zeilen.map((k: Zeile, i: number) => {
const z = erg(i);
const lohn = k.kostenart === "lohn", fahrt = k.kostenart === "fahrt", mitPers = lohn || fahrt;
if (lohn && z.aktiv) lohnStd += z.menge_gesamt;
if (z.aktiv) summe += z.kosten * menge;
const nach = klappNach.has(i) ? klappZeile(klappNach.get(i)!, false) : zuNach.has(i) ? klappZeile(zuNach.get(i)!, true) : "";
if (versteckt.has(i)) return nach;
// Fahrt: 2 × Strecke × Einsatztage × Fahrzeuge (Henning, 21.10.2026)
const fahrtText = fahrt && !z.fehler ? `<span class="kz-rechnung">2 × ${esc(k.bezug ?? "")} km × ${zahlText(k.menge)} ${Number(k.menge) === 1 ? "Tag" : "Tage"}${Number(k.personen ?? 1) !== 1 ? ` × ${zahlText(k.personen)} Fahrzeuge` : ""}</span>` : "";
return `<tr class="kz-${k.kostenart}${z.aktiv ? "" : " aus"}"><td>${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")}</td>
<td>${feld(`angebot-kosten:${k.id}:beschreibung`, k.beschreibung ?? "", { klasse: "w-bez", titel: "Bezeichnung", platz: lohn ? "Tätigkeit" : fahrt ? "Fahrt zur Baustelle" : "z. B. KVH 6/12" })}${fahrtText}</td>
<td>${feld(`angebot-kosten:${k.id}:bezug`, k.bezug ?? "", { klasse: `am-formel w-bezug${z.fehler ? " mit-fehler" : ""}`, titel: fahrt ? "Strecke einfach in km" : "Bezug (Kürzel aus dem Mengenblatt, leer = je Einheit)", platz: fahrt ? "km einfach" : `je ${p.einheit}`, liste: "am-kuerzel" })}${z.fehler ? `<span class="am-fehler">${esc(z.fehler)}</span>` : ""}</td>
<td>${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-ansatz am-eingabe", titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", platz: fahrt ? "Tage" : "", spalte: `km-${p.id}` })}</td>
<td>${mitPers ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: fahrt ? "Fahrzeuge" : "Personen" }) : ""}</td>
<td class="zahl"><b>${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}</b>${lohn ? " h" : fahrt ? " km" : ""}</td>
<td>${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : fahrt ? "" : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })}</td>
<td>${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-ek", leer: "null", titel: fahrt ? "Kosten je km" : "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00", spalte: `ke-${p.id}` })}</td>
<td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })}</td>
<td class="zahl">${betrag(z.kosten * menge)}</td>
<td class="kz-aus"><input type="checkbox" data-k="angebot-kosten:${k.id}:aktiv" data-typ="bool"${z.aktiv ? " checked" : ""} title="notwendig" aria-label="notwendig"${frei ? "" : " disabled"}>${frei ? `<button class="weg" data-a="kosten-weg" data-id="${k.id}" title="Kostenzeile löschen" aria-label="Kostenzeile löschen">×</button>` : ""}</td></tr>${nach}`;
}).join("");
if (!frei && !zeilen.length) return '<p class="hinweis">Keine Kostenzeilen.</p>';
return `<div class="kosten-rolle"><table class="kosten-tabelle am-t"><thead><tr><th>Art</th><th>Bezeichnung</th><th>Bezug</th><th class="zahl">Ansatz</th><th class="zahl">Pers.</th><th class="zahl">Menge</th><th>Lohnart / Einh.</th><th class="zahl">EK</th><th class="zahl">Faktor</th><th class="zahl">EK gesamt</th><th title="notwendig: abgewählte Zeilen zählen nicht">✓</th></tr></thead>
<tbody>${rumpf}<tr class="summe"><td colspan="5">Kosten gesamt${menge > 0 ? ` (${euro(r.kosten_je_einheit)} je ${esc(p.einheit)})` : ""}</td><td class="zahl">${lohnStd ? `${zahlDeutsch(lohnStd, "h")} h` : ""}</td><td colspan="3"></td><td class="zahl">${betrag(summe)}</td><td></td></tr></tbody></table></div>
${frei ? `<div class="knopfreihe">${KOSTENARTEN.map((x) => `<button class="neben klein" data-a="kosten-neu" data-art="${x}" data-id="${p.id}">+ ${KOSTENART_NAME[x]}</button>`).join("")}
${auf ? '<button class="neben klein" data-a="katalog" data-was="material">+ aus Stammdaten</button>' : ""}</div>` : ""}
<p class="hinweis-k">Menge = Bezug × Ansatz × Personen. Der Bezug ist ein Kürzel aus dem Aufmaß (z. B. HL); leer heißt je ${esc(p.einheit)}. Fahrt: Bezug = Strecke einfach, Ansatz = Einsatztage, Pers. = Fahrzeuge. Abgewählte Zeilen (✓) zählen nicht.</p>`;
}
/** „Verkauf und Zuschläge“ je Kostenart der Position, mit „Preis anpassen“ (A21) */
function verkaufTabelle(d: Zeile, p: Zeile, frei: boolean): string {
const feld = feldBau(frei);
const s = d.saetze, r = d.ergebnis.positionen[p.id];
const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id) as Zeile[];
const arten = KOSTENARTEN.filter((x) => zeilen.some((k) => k.kostenart === x));
let ekS = 0, zuS = 0, wgS = 0, vkS = 0;
const rumpf = arten.map((x) => {
let ek = 0, zu = 0;
zeilen.forEach((k, i) => { if (k.kostenart === x) { const z = r.kostenzeilen[i]!; ek += z.kosten * r.menge; zu += z.kosten * r.menge * z.zuschlag / 100; } });
const wg = (ek + zu) * wgp(s) / 100, vk = ek + zu + wg;
ekS += ek; zuS += zu; wgS += wg; vkS += vk;
const eigene = [...new Set(zeilen.filter((k) => k.kostenart === x).map((k) => (k.zuschlag_prozent == null ? "" : String(Number(k.zuschlag_prozent)))))];
const wert = eigene.length === 1 ? zahlText(eigene[0]) : "";
return `<tr><td><span class="art ${x}">${KOSTENART_NAME[x]}</span></td><td class="zahl">${euroGenau(ek)}</td>
<td class="zahl"><span class="mit-einheit">${feld(`verkauf:${p.id}:${x}`, wert, { typ: "zahl", klasse: "zahl w-kurz", leer: "null", titel: `Zuschlag ${KOSTENART_NAME[x]} in Prozent`, platz: eigene.length > 1 ? "gemischt" : zahlText(s.zuschlaege[x]) })} %</span></td>
<td class="zahl">${euroGenau(zu)}</td><td class="zahl">${prozentText(wgp(s))}</td><td class="zahl">${euroGenau(vk)}</td></tr>`;
}).join("");
const fest = p.ep_fest != null;
return `<div class="kosten-rolle"><table class="am-t"><thead><tr><th>Kostenart</th><th class="zahl">EK gesamt</th><th class="zahl">Zuschlag</th><th class="zahl">Zuschlag €</th><th class="zahl">Wagnis + Gewinn + Ausfall</th><th class="zahl">VK gesamt</th></tr></thead>
<tbody>${rumpf || '<tr><td colspan="6" class="hinweis">Noch keine Kostenzeile.</td></tr>'}<tr class="summe"><td>Summe</td><td class="zahl">${euroGenau(ekS)}</td><td></td><td class="zahl">${euroGenau(zuS)}</td><td class="zahl">${euroGenau(wgS)}</td><td class="zahl">${euroGenau(vkS)}</td></tr></tbody></table></div>
<div class="knopfreihe am-ep-zeile"><span>Einheitspreis kalkuliert <b>${euro(r.ep_kalkuliert)}</b> je ${esc(p.einheit)}${fest ? `, angepasst auf <b>${euro(r.ep)}</b>` : ""}; Gesamt ${zahlDeutsch(r.menge, p.einheit)} × ${euro(r.ep)} = <b>${euro(r.gb)}</b></span>
<label class="am-anpassen">Preis anpassen auf ${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einheitspreis anpassen", platz: "– €" })}</label></div>
<p class="hinweis-k">Leeres Zuschlagsfeld: Vorgabe des Angebots. Wagnis, Gewinn und Ausfall stellst du rechts im Reiter Vorgaben ein.</p>`;
}
/** Reiter Aufmaß in der offenen Position */
function aufmassAbschnitt(d: Zeile, p: Zeile, frei: boolean): string {
const b = alsBlatt(p.aufmass);
const a = werteBlatt(b, umgebungVon(d.saetze));
return `${blattHtml(b, a, { k: `blatt:${p.id}:`, frei, modus: "inline", einheit: p.einheit })}
<div class="knopfreihe">${frei ? `<button class="neben klein" data-a="b-zeile-neu" data-b="blatt:${p.id}:">+ Zeile</button>
<button class="neben klein am-betont" data-a="katalog" data-was="mengen">${b.vorlage ? "Vorlage wechseln →" : "Vorlage einfügen →"}</button>` : ""}
<button class="neben klein" data-a="gross" data-id="${p.id}">Mengenblatt groß öffnen</button>
<span class="hinweis-k">Jede Zeile darf rechnen (+ − * / Klammern, cos, wurzel …). Mit einer Vorlage kommen Kürzel und Bauteillisten dazu.</span></div>`;
}
/** Ergebniszeile unter den Reitern: Kosten → mit Zuschlägen und W&G → EP → Überschuss */
function ergebnisZeile(p: Zeile, r: Zeile): string {
const je = `je ${esc(p.einheit)}`;
if (!p.mit_kalkulation) return `Ohne Kalkulation: EP <b>${euro(r.ep)} ${je}</b> × ${zahlDeutsch(r.menge, p.einheit)} = <b>${euro(r.gb)}</b>`;
const ueber = r.kosten_gesamt > 0 ? Math.round(((r.gb - r.kosten_gesamt) / r.kosten_gesamt) * 1000) / 10 : null;
return `Kosten <b>${euro(r.kosten_gesamt)}</b>${r.stunden ? ` · ${stdText(r.stunden)}` : ""}
<span class="pfeil">→</span> mit Zuschlägen und W&amp;G <b>${euro(Math.round(r.ep_kalkuliert * r.menge))}</b>
<span class="pfeil">→</span> EP <b>${euro(r.ep)} ${je}</b>${p.ep_fest != null ? ' <span class="marke-q kalk">angepasst</span>' : ""}${ueber !== null ? ` · Überschuss ${prozentText(ueber)}` : ""}`;
}
/** Die offene Position: Reiter Langtext | Aufmaß | Kalkulation | Zuschläge & Preis | Mehr, Wechsel jederzeit */
function offenePosition(d: Zeile, oz: Record<string, string>, p: Zeile, frei: boolean): string {
const feld = feldBau(frei), auswahl = auswahlBau(frei);
const r = d.ergebnis.positionen[p.id];
const tab = tabVon(p);
const knopf = (t: Tab, text: string, badge = "") => `<button role="tab" class="${tab === t ? "an" : ""}" aria-selected="${tab === t}" data-a="tab" data-id="${p.id}" data-was="${t}">${text}${badge ? ` <small>${badge}</small>` : ""}</button>`;
const aus = '<small class="aus">aus</small>';
let panel = "";
if (tab === "langtext") {
panel = `<textarea data-k="angebot-positionen:${p.id}:langtext" rows="${Math.max(4, String(p.langtext ?? "").split("\n").length + 1)}" aria-label="Langtext" placeholder="Ausführliche Beschreibung für den Kunden, z. B. Material, Güte, Ausführung"${frei ? "" : " disabled"}>${esc(p.langtext ?? "")}</textarea>
${p.langtext && /\{[\p{L}_]/u.test(p.langtext) ? '<p class="hinweis-k">{Kürzel} wird mit dem Wert aus dem Aufmaß ersetzt.</p>' : ""}`;
} else if (tab === "aufmass") {
panel = p.mit_aufmass
? `${r.aufmass_fehler ? `<p class="am-fehler">${esc(r.aufmass_fehler)}</p>` : ""}${aufmassAbschnitt(d, p, frei)}
${frei ? `<p class="hinweis-k"><button class="verweis" data-a="chip" data-was="aufmass" data-id="${p.id}">Aufmaß ausschalten</button>, die Menge bleibt dann fest stehen.</p>` : ""}`
: `<p class="hinweis">Die Menge steht oben direkt in der Zeile. Mit Aufmaß rechnest du sie aus Maßen, Formeln oder einer Mengenvorlage, und die Kalkulation rechnet mit.</p>
${frei ? `<button class="neben" data-a="chip" data-was="aufmass" data-id="${p.id}">Aufmaß einschalten</button>` : ""}`;
} else if (tab === "kalk") {
panel = p.mit_kalkulation
? `${kostenTabelle(d, p, frei, zustand?.auf ?? new Set())}
${frei ? `<p class="hinweis-k"><button class="verweis" data-a="chip" data-was="kalkulation" data-id="${p.id}">Kalkulation ausschalten</button>, der Einheitspreis bleibt dann fest stehen.</p>` : ""}`
: `<p class="hinweis">Der Einheitspreis steht oben direkt in der Zeile. Mit Kalkulation entsteht er aus Lohn, Material, Gerät, Fahrt und Sub mit deinen Zuschlägen.</p>
${frei ? `<button class="neben" data-a="chip" data-was="kalkulation" data-id="${p.id}">Kalkulation einschalten</button>` : ""}`;
} else if (tab === "preis") {
panel = p.mit_kalkulation ? verkaufTabelle(d, p, frei)
: `<label class="am-anpassen">Einheitspreis ${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einheitspreis", platz: "0,00" })} € je ${esc(p.einheit)}</label>
<p class="hinweis-k">Ohne Kalkulation gibt es keine Zuschläge; der Preis gilt so, wie er hier steht.</p>`;
} else {
const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ" && !x.textzeile);
panel = `<div class="am-mehr">
<label>Positionsart ${auswahl(`angebot-positionen:${p.id}:art`, POSITIONSARTEN.map((x) => [x, POSITIONSART_NAME[x]]), p.art ?? "normal", "Positionsart")}</label>
${p.art === "alternativ" ? `<label>Alternativ zu ${auswahl(`angebot-positionen:${p.id}:grundposition_id`, [["", "bitte wählen …"], ...grund.map((x: Zeile): [string, string] => [x.id, `${oz[x.id]} ${x.kurztext}`])], p.grundposition_id ?? "", "Grundposition")}</label>` : ""}
<label class="am-radio"><input type="checkbox" data-k="angebot-positionen:${p.id}:markiert" data-typ="bool"${p.markiert ? " checked" : ""}${frei ? "" : " disabled"}> Zeile farbig markieren (nur für dich, nicht im Ausdruck)</label>
<p class="hinweis-k">Alternativ- und Eventualpositionen stehen kursiv mit der Summe in Klammern und zählen nicht zur Angebotssumme. Bilder in Positionen kommen mit dem PDF-Ausdruck.</p>
${frei ? `<div class="knopfreihe"><button class="neben klein" data-a="position-kopie" data-id="${p.id}">Kopieren</button><button class="neben klein gefahr" data-a="position-weg" data-id="${p.id}">Position löschen</button></div>` : ""}</div>`;
}
return `<div class="am-ed">
<div class="am-etabs" role="tablist" aria-label="Position bearbeiten">${knopf("langtext", "Langtext", p.langtext ? "✓" : "")}
${knopf("aufmass", "Aufmaß", p.mit_aufmass ? `${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}` : "")}${p.mit_aufmass ? "" : aus}
${knopf("kalk", "Kalkulation", p.mit_kalkulation ? euroGenau(r.kosten_gesamt) : "")}${p.mit_kalkulation ? "" : aus}
${knopf("preis", "Zuschläge &amp; Preis")}${knopf("mehr", "Mehr")}</div>
<div class="am-epanel" role="tabpanel">${panel}</div>
<div class="am-erg">${ergebnisZeile(p, r)}</div>
<div class="am-efuss"><span class="hinweis-k">Alles wird sofort gespeichert.</span>
${frei ? `<button class="neben" data-a="als-vorlage" data-id="${p.id}">Als Leistung speichern</button><button class="neben" data-a="abbrechen" title="Änderungen an dieser Position seit dem Öffnen verwerfen">Abbrechen</button>` : ""}
<button class="haupt" data-a="fertig">Fertig</button></div></div>`;
}
const menue = (eintraege: [string, string, string, boolean?][]) => `<details class="am-menue"><summary class="punkte" aria-label="Weitere Aktionen" title="Weitere Aktionen">⋮</summary>
<div class="am-menue-liste">${eintraege.map(([a, idw, text, aus]) => `<button data-a="${a}" data-id="${idw}"${aus ? " disabled" : ""}${a.endsWith("weg") ? ' class="gefahr"' : ""}>${text}</button>`).join("")}</div></details>`;
/** Kleine Marker hinter dem Kurztext statt Schaltern unter jeder Zeile */
function marker(p: Zeile, r: Zeile): string {
const m: string[] = [];
if (p.art === "alternativ") m.push('<span class="mk art">Alternativ</span>');
else if (p.art === "eventual" || p.art === "eventual_summe") m.push(`<span class="mk art">${p.art === "eventual" ? "Eventual" : "Eventual, einkalk."}</span>`);
if (p.mit_aufmass) m.push(`<span class="mk${r.aufmass_fehler ? " fehler" : ""}">Aufmaß</span>`);
if (p.mit_kalkulation) m.push(`<span class="mk">${p.ep_fest != null ? "Kalk. angepasst" : "Kalk."}</span>`);
if (p.langtext) m.push('<span class="mk">Langtext</span>');
return m.join("");
}
function zeilenHtml(d: Zeile, z: Zustand, oz: Record<string, string>, p: Zeile, liste: Zeile[], j: number, frei: boolean): string {
const feld = feldBau(frei);
const r = d.ergebnis.positionen[p.id];
const aktiv = z.aktiv === p.id;
const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler");
const knoepfe = frei ? menue([["position-hoch", p.id, "Nach oben", j === 0], ["position-runter", p.id, "Nach unten", j === liste.length - 1], ["position-kopie", p.id, "Kopieren"],
...(p.textzeile ? [] : [["als-vorlage", p.id, "Als Leistung speichern"] as [string, string, string]]), ["position-weg", p.id, "Löschen"]]) : "";
const klassen = `${aktiv ? " aktiv" : ""}${!aktiv && z.ziel === p.id ? " ziel" : ""}`;
if (p.textzeile) {
return `<div class="am-zeile am-textzeile${klassen}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}"><div class="pos"></div>
<div class="am-text-voll">${aktiv ? `<textarea data-k="angebot-positionen:${p.id}:kurztext" data-leer="pflicht" rows="${Math.max(2, String(p.kurztext).split("\n").length + 1)}" aria-label="Text"${frei ? "" : " disabled"}>${esc(p.kurztext)}</textarea>`
: `<div class="am-lese" data-fokus="kurztext">${esc(p.kurztext)}</div>`}</div><div class="punkte-zelle">${knoepfe}</div></div>`;
}
const blatt = p.mit_aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(d.saetze)) : null;
const ersetzt = blatt ? textMitWerten(p.kurztext, blatt) : p.kurztext;
const zaehlt = r.zaehlt;
const gb = zaehlt ? euro(r.gb) : `(${euro(r.gb)})`;
const ep = formatEuro(r.ep, false);
const kopf = `<div class="am-zeile pos-zeile${klassen}${zaehlt ? "" : " zaehlt-nicht"}${p.markiert ? " markiert" : ""}${fehler ? " mit-fehler" : ""}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}">
<div class="pos">${esc(oz[p.id])}</div>`;
if (!aktiv) {
const unter = p.art === "alternativ" && p.grundposition_id && oz[p.grundposition_id] ? `Alternativ zu ${esc(oz[p.grundposition_id])}` : "";
return `${kopf}<div class="z" data-fokus="menge">${zahlDeutsch(r.menge, p.einheit)}</div><div data-fokus="einheit">${esc(p.einheit)}</div>
<div class="am-text" data-fokus="kurztext">${esc(ersetzt)}${marker(p, r)}${unter ? `<div class="m-unter">${unter}</div>` : ""}</div>
<div class="z">${ep}</div><div class="z gb">${gb}</div><div class="punkte-zelle">${knoepfe}</div></div>`;
}
const menge = p.mit_aufmass
? `<input class="zahl aus" value="${esc(zahlDeutsch(r.menge, p.einheit))}" readonly tabindex="-1" aria-label="Menge aus dem Aufmaß" title="kommt aus dem Aufmaß">`
: feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" });
const epFeld = p.mit_kalkulation ? `<div class="z am-ep-t" title="aus der Kalkulation">${ep}</div>`
: `<div>${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl", leer: "null", titel: "Einheitspreis", platz: "0,00", spalte: "ep" })}</div>`;
return `${kopf}<div>${menge}</div>
<div>${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", titel: "Einheit", liste: "einheiten", spalte: "einheit" })}</div>
<div class="am-text">${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${ersetzt !== p.kurztext ? `<div class="m-unter">= ${esc(ersetzt)}</div>` : ""}</div>
${epFeld}<div class="z gb">${gb}</div><div class="punkte-zelle">${knoepfe}</div></div>
${offenePosition(d, oz, p, frei)}`;
}
/** Leistungen, Mengenvorlagen oder Material für den Reiter Leistungen der Seitenleiste */
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 (gross || z.katalog === "mengen") return vorlagenListeHtml(vorlagen, { art: "mengen", suche: z.suche, ziel: aktivePos, frei });
if (z.katalog === "material") return materialListe(z, !!aktivePos && frei);
return leistungenListe(z, leistungen, frei);
}
/** 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 `<p class="hinweis-k">Beschreibe die Arbeiten. Claude schlägt passende Leistungen vor, nur aus deinen Leistungen in den Stammdaten.</p>
<textarea data-ki-text rows="4" placeholder="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>` : ""}`;
}
/** Vorgaben dieses Angebots: Sätze, Zuschläge, W&G, Mengen */
function vorgabenHtml(d: Zeile, frei: boolean): string {
const a = d.angebot, s = d.saetze;
const feld = feldBau(frei);
return `<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("")}
<span class="t">Wagnis und Gewinn</span>
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
<label>Gewinn<span class="mit-einheit">${feld("angebote:x:gewinn_prozent", zahlText(a.gewinn_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
<label>Ausfall<span class="mit-einheit">${feld("angebote:x:ausfall_prozent", zahlText(a.ausfall_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
<label title="Vorschlag für die Kostenart Fahrt">Fahrt je km<span class="mit-einheit">${feld("saetze:km:satz", euroFeld(s.kilometersatz ?? 50), { typ: "euro", klasse: "zahl w-euro" })}</span></label>
<span class="t">Mengen</span>
<label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
<label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div>
<p class="hinweis-k">Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.</p>`;
}
const pruefungListe = (d: Zeile) => (d.pruefung.length
? `<ul class="pruefung">${d.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${p.position_id ? `<button class="verweis" data-a="pruefung" data-pos="${p.position_id}">${esc(p.text)}</button>` : esc(p.text)}</li>`).join("")}</ul>`
: '<p class="hinweis">Keine Platzhalter, alle Positionen mit Menge, Einheit und Preis.</p>');
/** Rechte Leiste: Bausteine | Leistungen | KI | Vorgaben | Prüfung, immer nur ein Panel */
function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], leistungen: Zeile[]): string {
const a = d.angebot, e = d.ergebnis;
const frei = a.status === "entwurf";
const auswahl = auswahlBau(frei);
const ka = e.kostenarten;
const staende = (a.staende ?? []) as Zeile[];
const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv && !p.textzeile) : null;
const { oz } = ordnung(d);
const reiter = z.reiter;
const knopf = (r: Zustand["reiter"], zeichen: string, text: string) => `<button role="tab" class="${reiter === r ? "an" : ""}" aria-selected="${reiter === r}" data-a="reiter" data-was="${r}"><b aria-hidden="true">${zeichen}</b>${text}</button>`;
const baustein = (was: string, text: string) => `<div class="baustein"${frei ? ` draggable="true" data-zieh="${was}"` : ""}><span class="g" aria-hidden="true">⋮⋮</span>${text}${frei ? `<button class="plus" data-a="neu" data-was="${was}" aria-label="${text} einfügen" title="Unter der markierten Zeile einfügen">+</button>` : ""}</div>`;
const kat = (k: Zustand["katalog"], text: string) => `<button class="chip-knopf${z.katalog === k ? " an" : ""}" data-a="katalog" data-was="${k}" aria-pressed="${z.katalog === k}">${text}</button>`;
let panel: string;
if (reiter === "bausteine") {
panel = 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 <button class="verweis" data-a="reiter" data-was="leistungen">Leistungen</button>.</p>`
: '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>';
} else if (reiter === "leistungen") {
const suche = z.katalog === "material"
? `<input class="suche" type="search" data-mat-suche value="${esc(z.matSuche)}" placeholder="Artikel suchen …" aria-label="Artikel suchen">`
: z.katalog === "mengen"
? `<input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Mengenvorlage suchen">`
: `<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>`;
const fuss = z.katalog === "material"
? `${aktivePos ? `+ legt den Artikel als Materialzeile in die Kalkulation von ${esc(oz[aktivePos.id])}, mit dem EK von heute.` : "Öffne eine Position, dann kommt der Artikel als Materialzeile in ihre Kalkulation."} <a href="#stammdaten-material">Materialstamm</a>`
: z.katalog === "mengen"
? `${aktivePos ? `+ fügt die Vorlage ins Aufmaß von ${esc(oz[aktivePos.id])} ein.` : "Öffne eine Position, dann kommt die Vorlage in ihr Aufmaß. Sonst entsteht eine neue Position."} <a href="#stammdaten-mengen">Alle Mengenvorlagen</a>`
: `Ziehen oder + fügt unter der markierten Zeile ein, mit Texten, Kalkulation und Aufmaß. <a href="#stammdaten">Alle Leistungen</a>`;
panel = `<div class="am-kat-wahl" role="group" aria-label="Was suchen">${kat("leistungen", "Leistungen")}${kat("mengen", "Mengenvorlagen")}${kat("material", "Material")}</div>
${suche}<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false, leistungen)}</div><p class="hinweis-k">${fuss}</p>`;
} else if (reiter === "ki") {
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>
${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>
${([...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>
<dl class="am-kennzahlen">${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 (§ 35a)</dt><dd>${euro(e.arbeitskosten_brutto)}</dd>` : ""}</dl>
${staende.length ? `<h3 class="am-h">Festgeschriebene Stände</h3><ul class="staende">${staende.map((x) => `<li>${x.anlass === "auftrag" ? "Auftrag" : "Versand"} am ${dat(String(x.am).slice(0, 10))}: ${euro(x.netto)} netto${x.von ? ` <small class="hinweis">${esc(x.von)}</small>` : ""}</li>`).join("")}</ul>` : ""}`;
} else {
panel = pruefungListe(d);
}
const n = d.pruefung.length;
return `<aside class="karte am-leiste">
<div class="am-ltabs" role="tablist" aria-label="Seitenleiste">${knopf("bausteine", "+", "Bausteine")}${knopf("leistungen", "⌕", "Leistungen")}${knopf("ki", "✦", "KI")}${knopf("vorgaben", "⚙", "Vorgaben")}${knopf("pruefung", "!", `Prüfung${n ? ` (${n})` : ""}`)}</div>
<div class="am-lpanel" role="tabpanel">${panel}</div></aside>`;
}
/** Seitenleiste beim großen Mengenblatt: Summen der Position, Mengenvorlagen, Vorgaben */
function grossLeiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], pid: string): string {
const frei = d.angebot.status === "entwurf";
return `<section class="karte am-leiste"><h3>Mengenvorlagen</h3><input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Suchen">
<div class="am-katalog-liste">${vorlagenListeHtml(vorlagen, { art: "mengen", suche: z.suche, ziel: pid, frei })}</div>
<p class="hinweis-k">+ fügt die Vorlage in dieses Mengenblatt ein. <a href="#stammdaten-mengen">Alle Mengenvorlagen</a></p></section>
<section class="karte"><details class="am-vorgaben" open><summary><h3>Vorgaben dieses Angebots</h3></summary>${vorgabenHtml(d, frei)}</details></section>`;
}
/** Summen als feste Leiste unten */
function summenLeiste(d: Zeile): string {
const e = d.ergebnis;
const fehler = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length, n = d.pruefung.length;
const ueber = e.netto - e.kosten;
return `<div class="am-summenleiste" role="status" aria-label="Summen">
<div><span>Netto</span><b>${euro(e.netto)}</b></div><div><span>Brutto</span><b>${euro(e.brutto)}</b></div>
<div><span>Stunden</span><b>${stdText(e.stunden)}</b></div><div><span>Kosten</span><b>${euro(e.kosten)}</b></div>
<div class="${e.kosten ? (ueber >= 0 ? "gut" : "schlecht") : ""}"><span>Überschuss</span><b>${e.kosten ? `${euro(ueber)} · ${prozentText(e.ueberschuss_prozent)}` : "–"}</b></div>
<button class="am-pruef${fehler ? " schlecht" : ""}" data-a="reiter" data-was="pruefung"><span>Prüfung</span><b>${n ? `${n} ${n === 1 ? "Hinweis" : "Hinweise"}` : "in Ordnung"}</b></button></div>`;
}
/** Kopfleiste mit Zurück, Nummer, Status und Knöpfen */
function titelleiste(d: Zeile, meldung: string): string {
const a = d.angebot;
const knoepfe = {
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] ?? "";
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>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}`;
}
/** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */
function briefkopf(d: Zeile, z: Zustand): string {
const a = d.angebot;
const frei = a.status === "entwurf";
const feld = feldBau(frei);
const ort = [a.baustelle_strasse, [a.baustelle_plz, a.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
const empf = a.bauherr_name ? `<b>${esc(a.bauherr_name)}</b>${a.bauherr_firma ? `<br>${esc(a.bauherr_firma)}` : ""}` : '<span class="fehler">kein Bauherr eingetragen</span>';
const festText = frei ? "" : `<p class="hinweis am-fest">Festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}.</p>`;
// solange eine Position offen ist, nur eine Zeile
if (z.aktiv && d.positionen.some((p: Zeile) => p.id === z.aktiv && !p.textzeile)) {
return `${festText}<button class="am-kopf-zu" data-a="fertig" title="Position schließen und Kopf zeigen">▸ Kopf: ${esc(a.bauherr_name ?? "ohne Empfänger")} · ${esc(a.betreff || a.projekt_name)} · ${dat(a.datum)}</button>`;
}
return `${festText}<div class="am-brief">
<div class="am-f am-empf"><span class="l">Empfänger</span><div class="am-box">${empf}</div><a class="hinweis-k" href="#projekt-${a.projekt_id}">im Projekt ändern</a></div>
<div class="am-f am-daten"><label><span class="l">Datum</span><input type="date" data-k="angebote:x:datum" data-leer="pflicht" value="${esc(a.datum)}"${frei ? "" : " disabled"}></label>
<label><span class="l">Gültig bis (Bindefrist)</span><input type="date" data-k="angebote:x:bindefrist" value="${esc(a.bindefrist ?? "")}"${frei ? "" : " disabled"}></label></div>
<label class="am-f"><span class="l">Betreff</span>${feld("angebote:x:betreff", a.betreff ?? "", { platz: `z. B. ${a.projekt_name}`, titel: "Betreff" })}</label>
<div class="am-f"><span class="l">Leistungsort</span><div class="am-box">${ort ? esc(ort) : '<span class="hinweis">Baustelle im Projekt eintragen</span>'}</div></div></div>
${fliesstext("angebote:x:kopftext", a.kopftext, "Einleitung, z. B. Sehr geehrte Damen und Herren, vielen Dank für Ihre Anfrage …", frei, "Einleitung")}`;
}
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, leistungen: Zeile[]): string {
const a = d.angebot, e = d.ergebnis;
const frei = a.status === "entwurf";
const feld = feldBau(frei);
const { oz, gruppen } = ordnung(d);
const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv) : null;
const lv = gruppen.map((g, gi) => {
if (!g.titel) return g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("");
const t = g.titel, offen = z.aktiv === t.id;
return `<div class="am-zeile titel${offen ? " aktiv" : ""}${!offen && z.ziel === t.id ? " ziel" : ""}" data-zeile="${t.id}" data-a="aktiv" data-id="${t.id}">
<div class="pos">${esc(oz[t.id])}</div><div class="bez">${offen ? feld(`angebot-titel:${t.id}:bezeichnung`, t.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" }) : `<span class="am-lese">${esc(t.bezeichnung)}</span>`}</div>
<div class="z gb">${euro(e.titel[t.id])}</div>
<div class="punkte-zelle">${frei ? menue([["titel-hoch", t.id, "Nach oben", gi === (gruppen[0]!.titel ? 0 : 1)], ["titel-runter", t.id, "Nach unten", gi === gruppen.length - 1], ["titel-weg", t.id, "Löschen"]]) : ""}</div></div>
${g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("")}`;
}).join("");
const satz = d.ust_satz ?? 19;
return `${datenlisten(aktivePos?.mit_aufmass ? alsBlatt(aktivePos.aufmass) : null)}${titelleiste(d, meldung)}
<div class="angebot-raster am-raster">
<section class="karte am-blatt">
${briefkopf(d, z)}
<div class="am-lv">
<div class="am-zeile kopfzeile"><div>Pos.</div><div class="z">Menge</div><div>Einh.</div><div>Beschreibung</div><div class="z">EP</div><div class="z">Gesamt</div><div></div></div>
${lv}
${d.positionen.length || d.titel.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="katalog" data-was="leistungen">+ aus Stammdaten</button>
${z.aktiv ?? z.ziel ? '<span class="hinweis-k">kommt unter die markierte Zeile</span>' : ""}</div>` : ""}
</div>
<div class="am-summe"><div><span>Nettosumme</span><b>${euro(e.netto)}</b></div><div><span>zzgl. ${String(satz).replace(".", ",")} % USt</span><span>${euro(e.ust)}</span></div>
<div class="b"><span>Bruttosumme</span><span>${euro(e.brutto)}</span></div></div>
${fliesstext("angebote:x:schlusstext", a.schlusstext, "Schlusstext, z. B. Zahlungsbedingungen und Grüße. {bindefrist} wird durch das Datum ersetzt.", frei, "Schlusstext")}
</section>
${seitenleiste(d, z, vorlagen, leistungen)}
</div>
${summenLeiste(d)}`;
}
/** Großes Mengenblatt (Bilder 3 und 4): alle Eingaben, Formeln und Listen, darunter die Zeitansätze */
function mengenblattHtml(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string, pid: string): string {
const p = d.positionen.find((x: Zeile) => x.id === pid);
if (!p) return `<p class="fehler">Diese Position gibt es nicht mehr.</p><p><a href="#angebot-${d.angebot.id}">Zum Angebot</a></p>`;
const frei = d.angebot.status === "entwurf";
const { oz } = ordnung(d);
const r = d.ergebnis.positionen[pid];
const b = alsBlatt(p.aufmass);
const a = werteBlatt(b, umgebungVon(d.saetze));
return `${datenlisten(b)}
<div class="kopf am-kopf"><a class="neben zurueck" href="#angebot-${d.angebot.id}" aria-label="Zurück zum Angebot">←</a>
<h1>Mengenermittlung <span class="nummer">${esc(oz[pid])} ${esc(p.kurztext)}</span></h1>
<span class="kopf-knoepfe">${frei ? `<button class="neben" data-a="als-vorlage" data-id="${pid}">Als Vorlage speichern</button>` : ""}<a class="knopf haupt" href="#angebot-${d.angebot.id}">Fertig</a></span></div>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
${p.mit_aufmass ? "" : `<div class="warnung">Bei dieser Position ist „Aufmaß“ aus; die Menge wird von Hand eingetragen. ${frei ? '<button class="neben klein" data-a="chip" data-was="aufmass" data-id="' + pid + '">Aufmaß einschalten</button>' : ""}</div>`}
<div class="angebot-raster am-raster"><div class="am-haupt">
<section class="karte"><div class="knopfreihe am-oben">${frei ? `<span class="hinweis-k">${b.vorlage ? `Eingefügt: <b>${esc(b.vorlage.name)}</b>. Rechts eine andere Vorlage wählen, um sie zu ersetzen.` : "Rechts eine Vorlage wählen, oder Eingaben und Formeln selbst anlegen."}</span>` : ""}</div>
${blattHtml(b, a, { k: `blatt:${pid}:`, frei, modus: "gross", einheit: p.einheit })}</section>
<section class="karte"><h3 class="am-h">Zeitansätze und Material <span class="hinweis-k">verknüpft mit dem Mengenblatt</span></h3>
${p.mit_kalkulation ? kostenTabelle(d, p, frei) : `<p class="hinweis">Bei dieser Position ist „Kalkulation“ aus. ${frei ? `<button class="neben klein" data-a="chip" data-was="kalkulation" data-id="${pid}">Kalkulation einschalten</button>` : ""}</p>`}</section>
</div>
<div class="am-seite-gross">
<section class="karte summen"><dl><dt>Menge der Position</dt><dd><b>${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}</b></dd>
<dt>Einheitspreis</dt><dd>${euro(r.ep)}</dd><dt>Gesamt</dt><dd>${euro(r.gb)}</dd>${r.stunden ? `<dt>Stunden</dt><dd>${stdText(r.stunden)}</dd>` : ""}</dl></section>
${grossLeiste(d, z, vorlagen, pid)}
</div></div>`;
}