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
1156 lines
89 KiB
TypeScript
1156 lines
89 KiB
TypeScript
// 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&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 & 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>`;
|
||
}
|