diff --git a/CHANGELOG.md b/CHANGELOG.md index 6c15f7e..f7ccfd5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,17 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.16.0 + +- Stufe 3a, erste Lieferung: Angebote mit Kalkulation im Programm. Auf der Projektseite unter Dokumente „+ Angebot“, außerdem eine Liste aller Angebote (Projekte → Angebote) mit Filtern wie überall. Das erste Angebot bekommt die Nummer des Projekts (A-26-…), weitere die nächste freie. +- Leistungsverzeichnis direkt in der Tabelle: Titel und Positionen mit Kurztext, Langtext, Menge und Einheit; OZ ergibt sich aus der Reihenfolge (01.0001). Positionsarten Normal, Alternativ (zu einer Grundposition), Eventual (ohne Gesamtbetrag) und Eventual einkalkuliert; fester Einheitspreis für Positionen ohne Kalkulation. Positionen lassen sich kopieren und verschieben. Enter springt wie in Excel in die Zeile darunter. +- Je Position Kostenzeilen für Lohn (Planer, Geselle, Helfer), Material, Gerät und Sonstiges: Menge je Einheit, EK, Faktor (z. B. Verschnitt) und Zuschlag. Verkauf = Kosten × Zuschlag × (Wagnis + Gewinn + Zahlungsausfall). Der Einheitspreis wird auf den Cent gerundet, der Gesamtbetrag ist Menge × EP, damit gibt es keine Rundungsdifferenzen. +- Rechts die Summen (Netto, USt, Brutto, Stunden, Kosten, möglicher Überschuss, Verkauf je Lohnstunde, Arbeitskosten für § 35a) und die Kalkulation je Kostenart. Wagnis, Gewinn und Ausfall stehen je Angebot (Standard je 5 %). Stundensätze und Zuschläge werden beim Anlegen festgeschrieben; die Vorgaben stehen unter Daten → „Angebotskalkulation bearbeiten“ (bis die Stundensatz-Tabelle da ist: Geselle 58,31 €, Planer 80 €, Helfer 50 €). +- Prüfung vor dem Versand: Platzhalter wie x-…-x oder ???, fehlende Menge oder Preis, Einheiten nach DIN 18334 (lfm → m, Stk. → St), Bindefrist, fehlender Bauherr. Mit Fehlern nur nach „Trotzdem versenden“. +- „Als versendet markieren“ schreibt Kalkulation und Preise fest; „Wieder bearbeiten“ holt den Entwurf zurück, der versendete Stand bleibt gespeichert. Bindefrist standardmäßig 4 Wochen; 5 Tage vor Ablauf erscheint auf der Übersicht eine Warnung zum Nachfassen, auch im Outlook-Kalender. +- „Annehmen“ macht aus dem Projekt den Auftrag (A- wird P-Nummer), Auftragswert = Summe der angenommenen Angebote, geplante Material- und Gerätekosten für die Liquidität. Hat das Projekt noch keinen Terminplan, wird aus jedem Titel ein Abschnitt mit Vorgang, die Dauer aus den kalkulierten Stunden. Der Zahlungsplan entsteht wie gewohnt von selbst. +- Noch nicht dabei (nächste Lieferungen): Leistungskatalog und Übernahme alter Angebote, Mengenblatt mit Formeln, Angebot als PDF, Kostenvoranschlag, Auftragsbestätigung und Lieferschein. + ## 0.15.1 - Pausenabzug (M3) zieht jetzt standardmäßig immer voll ab: 6:10 anwesend ergibt 5:40 statt 6:00 (Henning, 20.10.2026). Umstellbar unter Einstellungen; schon gespeicherte Tage bleiben, wie sie sind. diff --git a/demo/kern.ts b/demo/kern.ts index cefd1d1..de7480a 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -15,6 +15,7 @@ import m010 from "../src/server/migrations/010_dauer_aus_besetzung.sql"; import m011 from "../src/server/migrations/011_ansichten.sql"; import m012 from "../src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql"; import m013 from "../src/server/migrations/013_kolonnen_subunternehmer.sql"; +import m014 from "../src/server/migrations/014_angebote.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -25,6 +26,7 @@ const MIGRATIONEN: [string, string][] = [ ["011_ansichten.sql", m011], ["012_zahlungen_aufgaben_im_terminplan.sql", m012], ["013_kolonnen_subunternehmer.sql", m013], + ["014_angebote.sql", m014], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index 1fe4cb2..93bc3c0 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.15.1", + "version": "0.16.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/kalkulation.ts b/src/domain/kalkulation.ts new file mode 100644 index 0000000..5d88230 --- /dev/null +++ b/src/domain/kalkulation.ts @@ -0,0 +1,294 @@ +// Angebotskalkulation (Stufe 3a, A2, A19, A28, A32, A37): je Position Kostenzeilen für Lohn, Material, Gerät und +// Sonstiges. Kosten je Einheit = Menge × EK × Faktor; Verkauf = Kosten × (1 + Zuschlag) × (1 + Wagnis + Gewinn + +// Zahlungsausfall). Der Einheitspreis wird auf den Cent gerundet, Gesamt = Menge × EP, Netto = Summe der Positionen, +// die zählen. So gibt es keine Rundungsabweichung wie in Plancraft: Zuschlag in € = Verkauf − Kosten. +import type { Cent } from "./geld.js"; +import { prozentVon } from "./geld.js"; + +export const KOSTENARTEN = ["lohn", "material", "geraet", "sonstiges"] as const; +export type Kostenart = (typeof KOSTENARTEN)[number]; +export const KOSTENART_NAME: Record = { + lohn: "Lohn", material: "Material", geraet: "Gerät", sonstiges: "Sonstiges", ohne: "ohne Kalkulation", +}; +export const LOHNARTEN = ["planer", "geselle", "helfer"] as const; +export type Lohnart = (typeof LOHNARTEN)[number]; +export const LOHNART_NAME: Record = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; + +// A28: Alternativ- und Eventualpositionen stehen mit Preis da, zählen aber nicht; „eventual_summe“ ist einkalkuliert +export const POSITIONSARTEN = ["normal", "alternativ", "eventual", "eventual_summe"] as const; +export type Positionsart = (typeof POSITIONSARTEN)[number]; +export const POSITIONSART_NAME: Record = { + normal: "Normal", alternativ: "Alternativ", eventual: "Eventual", eventual_summe: "Eventual, einkalkuliert", +}; +export const zaehlt = (art: Positionsart | string | null | undefined) => !art || art === "normal" || art === "eventual_summe"; + +// VOB/C ATV DIN 18334, Abschnitt 0.5 (Henning, 19.10.2026): einheitliche Schreibweise +export const EINHEITEN = ["m", "m²", "m³", "St", "kg", "t", "h", "psch"] as const; +const SCHREIBWEISE: Record = { + lfm: "m", lfdm: "m", "m1": "m", m2: "m²", qm: "m²", m3: "m³", cbm: "m³", stk: "St", "stk.": "St", stck: "St", "st.": "St", stück: "St", + std: "h", "std.": "h", stunde: "h", stunden: "h", psch: "psch", "psch.": "psch", pauschal: "psch", pausch: "psch", +}; +/** Richtige Schreibweise einer Einheit, oder undefined, wenn sie unbekannt ist */ +export function einheitRichtig(e: string): string | undefined { + const t = e.trim(); + if ((EINHEITEN as readonly string[]).includes(t)) return t; + return SCHREIBWEISE[t.toLowerCase()]; +} + +export interface Saetze { + /** EK-Stundensätze in Cent je Lohnart, beim Anlegen des Angebots festgeschrieben (A36) */ + stundensaetze: Record; + /** Standardzuschläge in % je Kostenart */ + zuschlaege: Record; + wagnis: number; + gewinn: number; + ausfall: number; +} + +export interface KKosten { + id?: string; + position_id: string; + kostenart: Kostenart; + lohnart?: Lohnart | null; + beschreibung?: string | null; + /** je Einheit der Position, bei Lohn in Stunden */ + menge: number | string; + einheit?: string | null; + /** Cent je Einheit der Kostenzeile; bei Lohn ohne Wert gilt der Stundensatz der Lohnart */ + ek?: number | string | null; + faktor?: number | string | null; + zuschlag_prozent?: number | string | null; + reihenfolge?: number; +} + +export interface KPosition { + id: string; + titel_id?: string | null; + oz?: string | null; + kurztext: string; + menge: number | string; + einheit: string; + art?: Positionsart | null; + /** fester Einheitspreis in Cent (Position ohne Kalkulation oder „Preis anpassen“) */ + ep_fest?: number | string | null; + reihenfolge?: number; +} + +export interface KTitel { + id: string; + oz?: string | null; + bezeichnung: string; + reihenfolge?: number; +} + +export interface PositionErgebnis { + id: string; + /** Einheitspreis in Cent */ + ep: Cent; + /** Gesamtbetrag in Cent (zählt nur bei normal und eventual_summe) */ + gb: Cent; + /** Einheitspreis aus der Kalkulation, auch wenn ein fester Preis gilt */ + ep_kalkuliert: Cent; + kosten_je_einheit: Cent; + /** Stunden je Einheit und gesamt */ + std_je_einheit: number; + stunden: number; + zaehlt: boolean; + /** Verkauf je Kostenart (Cent je Einheit, ungerundet) für die Kalkulationsübersicht */ + vk_je_einheit: Record; + kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number }[]; +} + +export interface KostenartSumme { + kosten: Cent; + verkauf: Cent; + zuschlag: Cent; + /** Zuschlag in % der Kosten (null ohne Kosten) */ + prozent: number | null; +} + +export interface AngebotErgebnis { + positionen: Record; + titel: Record; + netto: Cent; + ust: Cent; + brutto: Cent; + stunden: number; + kosten: Cent; + /** „möglicher Überschuss“ wie in Plancraft: (Netto − Kosten) / Kosten */ + ueberschuss_prozent: number | null; + kostenarten: Record; + /** Verkaufswert je Lohnstunde */ + stundensatz_verkauf: Cent | null; + /** § 35a EStG (A34): Arbeits- und Maschinenkosten brutto, für Privatkunden */ + arbeitskosten_brutto: Cent; +} + +const zahl = (v: number | string | null | undefined, sonst = 0) => (v === null || v === undefined || v === "" ? sonst : Number(v)); + +/** Kaufmännisch auf ganze Cent; kleine Gleitkommafehler (2,675 → 267,49999…) werden vorher ausgeglichen */ +export function rundeCent(x: number): Cent { + const a = Math.abs(x); + const r = Math.floor(a + 0.5 + 1e-7); + return x < 0 ? -r : r; +} + +/** Ein Betrag nach Gewichten aufgeteilt, Rest nach größtem Bruchteil (Summe stimmt auf den Cent) */ +export function verteile(betrag: Cent, gewichte: number[]): Cent[] { + const summe = gewichte.reduce((s, g) => s + g, 0); + if (!(summe > 0)) return gewichte.map(() => 0); + const roh = gewichte.map((g) => (betrag * g) / summe); + const teile = roh.map((r) => Math.floor(r + 1e-9)); + let rest = betrag - teile.reduce((s, t) => s + t, 0); + const reihenfolge = roh.map((r, i) => [r - Math.floor(r + 1e-9), i] as const).sort((a, b) => b[0] - a[0]); + for (let k = 0; rest > 0 && k < reihenfolge.length; k++, rest--) teile[reihenfolge[k]![1]]! += 1; + return teile; +} + +/** EK einer Kostenzeile in Cent je ihrer Einheit */ +export function ekVon(k: KKosten, s: Saetze): number { + if (k.ek !== null && k.ek !== undefined && k.ek !== "") return Number(k.ek); + return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? 0 : 0; +} + +export function zuschlagVon(k: KKosten, s: Saetze): number { + return k.zuschlag_prozent === null || k.zuschlag_prozent === undefined || k.zuschlag_prozent === "" ? s.zuschlaege[k.kostenart] ?? 0 : Number(k.zuschlag_prozent); +} + +export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis { + const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100; + const vk = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record; + let kostenSumme = 0, std = 0; + const zeilen = []; + for (const k of kosten) { + const ek = ekVon(k, s); + const z = zuschlagVon(k, s); + const kz = zahl(k.menge) * ek * zahl(k.faktor, 1); + const v = kz * (1 + z / 100) * wg; + kostenSumme += kz; + vk[k.kostenart] += v; + if (k.kostenart === "lohn") std += zahl(k.menge); + zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z }); + } + const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0)); + const ep = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : epKalk; + const menge = zahl(p.menge); + const z = zaehlt(p.art); + return { + id: p.id, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme), + std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: z, vk_je_einheit: vk, kostenzeilen: zeilen, + }; +} + +export function berechneAngebot( + a: { ust_satz?: number }, + titel: KTitel[], positionen: KPosition[], kosten: KKosten[], s: Saetze, +): AngebotErgebnis { + const jePosition = new Map(); + for (const k of [...kosten].sort((x, y) => (x.reihenfolge ?? 0) - (y.reihenfolge ?? 0))) { + jePosition.set(k.position_id, [...(jePosition.get(k.position_id) ?? []), k]); + } + const erg: Record = {}; + const titelSumme: Record = Object.fromEntries(titel.map((t) => [t.id, 0])); + const arten = { lohn: [0, 0], material: [0, 0], geraet: [0, 0], sonstiges: [0, 0], ohne: [0, 0] } as Record; + let netto = 0, stunden = 0; + for (const p of positionen) { + const r = berechnePosition(p, jePosition.get(p.id) ?? [], s); + erg[p.id] = r; + if (!r.zaehlt) continue; + netto += r.gb; + stunden += r.stunden; + if (p.titel_id && p.titel_id in titelSumme) titelSumme[p.titel_id]! += r.gb; + // Kosten und Verkauf je Kostenart: der Gesamtbetrag der Position wird nach den Verkaufswerten aufgeteilt + const menge = zahl(p.menge); + for (const k of jePosition.get(p.id) ?? []) { + arten[k.kostenart][0] += menge * zahl(k.menge) * ekVon(k, s) * zahl(k.faktor, 1); + } + const gewichte = KOSTENARTEN.map((x) => r.vk_je_einheit[x]); + if (gewichte.some((g) => g > 0)) verteile(r.gb, gewichte).forEach((t, i) => (arten[KOSTENARTEN[i]!][1] += t)); + else arten.ohne[1] += r.gb; + } + const kostenarten = {} as Record; + let kostenGesamt = 0; + for (const [art, [k, v]] of Object.entries(arten) as [Kostenart | "ohne", [number, Cent]][]) { + const kc = rundeCent(k); + kostenGesamt += kc; + kostenarten[art] = { kosten: kc, verkauf: v, zuschlag: v - kc, prozent: kc > 0 ? Math.round(((v - kc) / kc) * 10000) / 100 : null }; + } + const satz = a.ust_satz ?? 19; + const ust = prozentVon(netto, satz); + const arbeit = kostenarten.lohn.verkauf + kostenarten.geraet.verkauf; + return { + positionen: erg, titel: titelSumme, netto, ust, brutto: netto + ust, stunden: Math.round(stunden * 100) / 100, kosten: kostenGesamt, + ueberschuss_prozent: kostenGesamt > 0 ? Math.round(((netto - kostenGesamt) / kostenGesamt) * 1000) / 10 : null, + kostenarten, + stundensatz_verkauf: stunden > 0 ? rundeCent(kostenarten.lohn.verkauf / stunden) : null, + arbeitskosten_brutto: arbeit + prozentVon(arbeit, satz), + }; +} + +export interface Pruefpunkt { + /** fehler: so nicht versenden; hinweis: bitte ansehen */ + stufe: "fehler" | "hinweis"; + text: string; + position_id?: string; +} + +const PLATZHALTER = [/\bx-[^\s]*-x\b/i, /\?\?\?/, /\bxxx+\b/i, /\[\s*\]/, /<\s*bitte[^>]*>/i, /\.\.\.\s*$/]; + +/** A14 Versandprüfung: Platzhalter, Preise, Einheiten, Bindefrist */ +export function pruefeAngebot( + a: { datum: string; bindefrist?: string | null; kopftext?: string | null; schlusstext?: string | null; betreff?: string | null; empfaenger?: boolean }, + titel: KTitel[], positionen: KPosition[], kosten: KKosten[], e: AngebotErgebnis, langtexte: Record = {}, +): Pruefpunkt[] { + const p: Pruefpunkt[] = []; + const name = (x: KPosition) => `${x.oz ? `${x.oz} ` : ""}${x.kurztext}`; + if (!positionen.length) p.push({ stufe: "fehler", text: "Das Angebot hat noch keine Position." }); + if (a.empfaenger === false) p.push({ stufe: "fehler", text: "Beim Projekt ist kein Bauherr als Empfänger eingetragen." }); + if (a.bindefrist && a.bindefrist < a.datum) p.push({ stufe: "fehler", text: "Die Bindefrist liegt vor dem Angebotsdatum." }); + for (const [feld, text] of [["Betreff", a.betreff], ["Einleitung", a.kopftext], ["Schlusstext", a.schlusstext]] as const) { + if (text && PLATZHALTER.some((r) => r.test(text))) p.push({ stufe: "fehler", text: `Im ${feld} steht noch ein Platzhalter.` }); + } + for (const t of titel) { + if (/^neuer titel$/i.test(t.bezeichnung.trim())) p.push({ stufe: "fehler", text: "Ein Titel heißt noch „Neuer Titel“." }); + if (!positionen.some((x) => x.titel_id === t.id)) p.push({ stufe: "hinweis", text: `Titel „${t.bezeichnung}“ hat keine Position.` }); + } + const ids = new Set(positionen.map((x) => x.id)); + for (const x of positionen) { + const r = e.positionen[x.id]; + if (/^neue position$/i.test(x.kurztext.trim())) p.push({ stufe: "fehler", text: `Position ${name(x)}: Der Kurztext fehlt noch.`, position_id: x.id }); + else if (PLATZHALTER.some((re) => re.test(x.kurztext) || re.test(langtexte[x.id] ?? ""))) { + p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Text steht noch ein Platzhalter.`, position_id: x.id }); + } + if (!(zahl(x.menge) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, position_id: x.id }); + if (r && r.ep <= 0) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keinen Preis.`, position_id: x.id }); + const richtig = einheitRichtig(x.einheit); + if (!richtig) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ gibt es nach DIN 18334 nicht.`, position_id: x.id }); + else if (richtig !== x.einheit) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ bitte als „${richtig}“ schreiben.`, position_id: x.id }); + if (r && x.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) { + p.push({ stufe: "hinweis", text: `Position ${name(x)}: Der feste Preis liegt unter den Kosten.`, position_id: x.id }); + } + if (x.art === "alternativ" && !(x as { grundposition_id?: string | null }).grundposition_id) { + p.push({ stufe: "hinweis", text: `Alternativposition ${name(x)} ist keiner Grundposition zugeordnet.`, position_id: x.id }); + } + } + for (const k of kosten) { + if (!ids.has(k.position_id)) continue; + if (k.kostenart !== "lohn" && !(ekVon(k, { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: { lohn: 0, material: 0, geraet: 0, sonstiges: 0 }, wagnis: 0, gewinn: 0, ausfall: 0 }) > 0)) { + const x = positionen.find((y) => y.id === k.position_id)!; + p.push({ stufe: "hinweis", text: `Position ${name(x)}: ${KOSTENART_NAME[k.kostenart]} „${k.beschreibung || "ohne Text"}“ hat keinen Preis.`, position_id: x.id }); + } + } + return p; +} + +/** Nächste freie Angebotsnummer im Jahr, Format A-26-121 (wie in Plancraft) */ +export function naechsteNummer(vorhanden: string[], jahr: number): string { + const jj = String(jahr % 100).padStart(2, "0"); + let max = 0; + for (const n of vorhanden) { + const m = /^[AP]-(\d{2})-(\d{1,4})/.exec(n.trim()); + if (m && m[1] === jj) max = Math.max(max, Number(m[2])); + } + return `A-${jj}-${String(max + 1).padStart(3, "0")}`; +} diff --git a/src/domain/uebersicht.ts b/src/domain/uebersicht.ts index c4896d6..e801108 100644 --- a/src/domain/uebersicht.ts +++ b/src/domain/uebersicht.ts @@ -78,7 +78,7 @@ export function einsatzMatrix(vorgaenge: UeVorgang[], besetzungen: UeBesetzung[] } export interface Warnung { - art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung"; + art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung" | "angebot"; text: string; /** Sprungziel in der App, z. B. "terminplan" */ ziel: string; diff --git a/src/server/angebote.ts b/src/server/angebote.ts new file mode 100644 index 0000000..25d7440 --- /dev/null +++ b/src/server/angebote.ts @@ -0,0 +1,277 @@ +// Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation. Anlegen mit festgeschriebenen Sätzen (A36), +// Versandprüfung (A14), Kalkulationsstand beim Versand und bei Auftrag (A19), „Angebot annehmen“ macht aus dem +// Projekt den Auftrag mit Abschnitten, Vorgängen und Zahlungsplan (A4, P9). +import type { FastifyInstance, FastifyRequest } from "fastify"; +import { z } from "zod"; +import { type Client, type Pool, transaktion } from "./db.js"; +import type { Einstellungen } from "./einstellungen.js"; +import { mitNeuplanung } from "./terminplan.js"; +import { werName } from "./anmeldung.js"; +import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot } from "../domain/kalkulation.js"; +import { plusTage } from "../domain/datum.js"; +import { naechsterArbeitstag } from "../domain/kalender.js"; + +const IdParam = z.object({ id: z.uuid() }); +const heute = () => new Date().toISOString().slice(0, 10); + +export const ANGEBOT_TEILE = new Set(["angebot", "angebot_titel", "angebot_position", "angebot_kosten"]); + +export class AngebotFehler extends Error { + statusCode = 409; +} + +/** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */ +export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze { + const s = (a.saetze ?? {}) as Partial>; + return { + stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) }, + zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) }, + wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent), + }; +} + +export async function ladeAngebot(c: Pick, id: string, e: Einstellungen) { + const angebot = (await c.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, p.bauherr_id, p.status as projekt_status, + k.name as bauherr_name, k.firma as bauherr_firma + from angebot a join projekt p on p.id = a.projekt_id left join kontakt k on k.id = p.bauherr_id where a.id = $1`, [id])).rows[0]; + if (!angebot) return null; + const [t, p, k] = await Promise.all([ + c.query("select * from angebot_titel where angebot_id = $1 order by reihenfolge, angelegt_am", [id]), + c.query("select * from angebot_position where angebot_id = $1 order by reihenfolge, angelegt_am", [id]), + c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1 order by k.reihenfolge, k.angelegt_am", [id]), + ]); + const saetze = saetzeVon(angebot, e); + const titel = t.rows as KTitel[], positionen = p.rows as (KPosition & { langtext?: string | null })[], kosten = k.rows as KKosten[]; + const ergebnis = berechneAngebot({ ust_satz: e.ust.satz }, titel, positionen, kosten, saetze); + return { angebot, titel, positionen, kosten, saetze, ergebnis }; +} + +function pruefung(x: NonNullable>>) { + return pruefeAngebot({ ...x.angebot, empfaenger: !!x.angebot.bauherr_id }, x.titel, x.positionen, x.kosten, x.ergebnis, + Object.fromEntries(x.positionen.map((p) => [p.id, p.langtext]))); +} + +/** A19: Kalkulation unveränderlich ablegen */ +function stand(x: NonNullable>>, anlass: "versand" | "auftrag", wer: string) { + return { + anlass, am: new Date().toISOString(), von: wer, saetze: x.saetze, + netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, kosten: x.ergebnis.kosten, + kostenarten: x.ergebnis.kostenarten, titel: x.titel, positionen: x.positionen.map((p) => ({ ...p, ergebnis: x.ergebnis.positionen[p.id] })), + kosten_zeilen: x.kosten, + }; +} + +/** Bearbeiten geht nur im Entwurf; danach gilt der festgeschriebene Stand (A19) */ +export async function pruefeBearbeitbar(c: Client, tabelle: string, id: string | undefined, daten: Record): Promise { + if (!ANGEBOT_TEILE.has(tabelle)) return; + const ids: string[] = []; + const angebotVon = async (sql: string, wert: unknown) => { + if (typeof wert === "string") { + const r = (await c.query(sql, [wert])).rows[0]; + if (r) ids.push(r.angebot_id); + } + }; + if (tabelle === "angebot") { + if (!id) return; + // nur die Notiz bleibt nach dem Versand änderbar + if (Object.keys(daten).every((k) => k === "notiz" || daten[k] === undefined)) return; + ids.push(id); + } else if (tabelle === "angebot_titel") { + if (id) await angebotVon("select angebot_id from angebot_titel where id = $1", id); + await angebotVon("select id as angebot_id from angebot where id = $1", daten.angebot_id); + } else if (tabelle === "angebot_position") { + if (id) await angebotVon("select angebot_id from angebot_position where id = $1", id); + await angebotVon("select id as angebot_id from angebot where id = $1", daten.angebot_id); + } else { + if (id) await angebotVon("select p.angebot_id from angebot_kosten k join angebot_position p on p.id = k.position_id where k.id = $1", id); + await angebotVon("select angebot_id from angebot_position where id = $1", daten.position_id); + } + for (const a of ids) { + const s = (await c.query("select status, nummer from angebot where id = $1", [a])).rows[0]; + if (s && s.status !== "entwurf") { + throw new AngebotFehler(`Angebot ${s.nummer} ist ${s.status === "versendet" ? "versendet" : s.status}. Zum Ändern zuerst „Wieder bearbeiten“ wählen.`); + } + } +} + +const NeuSchema = z.object({ + projekt_id: z.uuid(), + belegart: z.enum(["angebot", "kostenvoranschlag"]).default("angebot"), + // Kopie eines anderen Angebots (neue Version, Vorlage aus einem früheren Angebot) + von_angebot_id: z.uuid().optional(), +}); + +async function kopiereInhalt(c: Client, von: string, nach: string): Promise { + const titelNeu = new Map(); + for (const t of (await c.query("select * from angebot_titel where angebot_id = $1 order by reihenfolge", [von])).rows) { + const n = (await c.query("insert into angebot_titel (angebot_id, oz, bezeichnung, reihenfolge) values ($1, $2, $3, $4) returning id", [nach, t.oz, t.bezeichnung, t.reihenfolge])).rows[0]; + titelNeu.set(t.id, n.id); + } + const posNeu = new Map(); + const positionen = (await c.query("select * from angebot_position where angebot_id = $1 order by reihenfolge", [von])).rows; + for (const p of positionen) { + const n = (await c.query(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, reihenfolge) + values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) returning id`, + [nach, p.titel_id ? titelNeu.get(p.titel_id) : null, p.oz, p.kurztext, p.langtext, p.menge, p.einheit, p.art, p.ep_fest, p.reihenfolge])).rows[0]; + posNeu.set(p.id, n.id); + } + for (const p of positionen) { + if (p.grundposition_id && posNeu.has(p.grundposition_id)) await c.query("update angebot_position set grundposition_id = $2 where id = $1", [posNeu.get(p.id), posNeu.get(p.grundposition_id)]); + } + const kosten = (await c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1", [von])).rows; + for (const k of kosten) { + await c.query(`insert into angebot_kosten (position_id, kostenart, lohnart, beschreibung, menge, einheit, ek, faktor, faktor_grund, zuschlag_prozent, reihenfolge) + values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, + [posNeu.get(k.position_id), k.kostenart, k.lohnart, k.beschreibung, k.menge, k.einheit, k.ek, k.faktor, k.faktor_grund, k.zuschlag_prozent, k.reihenfolge]); + } +} + +export function registriereAngebote( + app: FastifyInstance, pool: Pool, einstellungen: () => Promise, + nachProjekt: (p: Record, wer: string) => Promise>, +): void { + const wer = (req: FastifyRequest) => werName(req); + + // Liste aller Angebote mit Summen, für die Seite Angebote und die Dokumente eines Projekts + app.get("/api/angebote-liste", async (req) => { + const q = z.object({ projekt_id: z.uuid().optional() }).parse(req.query); + const e = await einstellungen(); + const r = await pool.query(`select a.id from angebot a ${q.projekt_id ? "where a.projekt_id = $1" : ""} order by a.datum desc, a.nummer desc`, q.projekt_id ? [q.projekt_id] : []); + const liste = []; + for (const { id } of r.rows) { + const x = (await ladeAngebot(pool, id, e))!; + const { staende: _s, saetze: _t, kopftext: _k, schlusstext: _l, ...kopf } = x.angebot; + liste.push({ ...kopf, netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, positionen: x.positionen.length }); + } + return liste; + }); + + app.post("/api/angebote/neu", async (req, reply) => { + const q = NeuSchema.parse(req.body); + const e = await einstellungen(); + const a = await transaktion(pool, wer(req), async (c) => { + const p = (await c.query("select id, nummer, status from projekt where id = $1", [q.projekt_id])).rows[0]; + if (!p) return null; + const nummern = (await c.query("select nummer from angebot union all select nummer from projekt")).rows.map((r) => r.nummer as string); + const belegt = new Set((await c.query("select nummer from angebot")).rows.map((r) => r.nummer as string)); + // das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie + const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear()); + const k = e.kalkulation; + const datum = heute(); + const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined; + const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze) + values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`, + [q.projekt_id, nummer, vorlage?.belegart ?? q.belegart, datum, k.bindefristWochen ? plusTage(datum, 7 * k.bindefristWochen) : null, + vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext, + vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall, + // A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen + { stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, stand: datum }])).rows[0]; + if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id); + if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]); + return neu; + }); + if (!a) return reply.status(404).send({ fehler: "Projekt nicht gefunden" }); + return reply.status(201).send(a); + }); + + app.get("/api/angebote/:id/voll", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const x = await ladeAngebot(pool, id, await einstellungen()); + if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return { ...x, pruefung: pruefung(x) }; + }); + + // A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“ + app.post("/api/angebote/:id/versenden", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const q = z.object({ trotzdem: z.boolean().default(false), datum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.body ?? {}); + const e = await einstellungen(); + const r = await transaktion(pool, wer(req), async (c) => { + const x = await ladeAngebot(c, id, e); + if (!x) return null; + if (x.angebot.status !== "entwurf") throw new AngebotFehler("Das Angebot ist nicht mehr im Entwurf."); + const p = pruefung(x); + if (p.some((f) => f.stufe === "fehler") && !q.trotzdem) return { pruefung: p, versendet: false }; + const am = q.datum ?? heute(); + await c.query("update angebot set status = 'versendet', versendet_am = $2, staende = staende || $3::jsonb where id = $1", + [id, am, JSON.stringify([stand(x, "versand", wer(req))])]); + if (["anfrage"].includes(x.angebot.projekt_status)) await c.query("update projekt set status = 'angebot' where id = $1", [x.angebot.projekt_id]); + return { pruefung: p, versendet: true }; + }); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + return r; + }); + + // Zurück in den Entwurf, z. B. nach Rückfrage des Kunden; der versendete Stand bleibt in den Ständen erhalten + app.post("/api/angebote/:id/bearbeiten", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const r = await transaktion(pool, wer(req), async (c) => + (await c.query("update angebot set status = 'entwurf', entschieden_am = null where id = $1 and status in ('versendet', 'abgelehnt') returning *", [id])).rows[0]); + return r ?? reply.status(409).send({ fehler: "Nur ein versendetes oder abgelehntes Angebot lässt sich wieder bearbeiten." }); + }); + + app.post("/api/angebote/:id/ablehnen", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const r = await transaktion(pool, wer(req), async (c) => + (await c.query("update angebot set status = 'abgelehnt', entschieden_am = $2 where id = $1 and status in ('entwurf', 'versendet') returning *", [id, heute()])).rows[0]); + return r ?? reply.status(409).send({ fehler: "Dieses Angebot lässt sich nicht als abgelehnt markieren." }); + }); + + // A4: Angebot annehmen → Auftrag. Titel werden Abschnitte mit je einem Vorgang (Stunden aus der Kalkulation), + // der Auftragswert ist die Summe der angenommenen Angebote, der Zahlungsplan entsteht nach P9 von selbst. + app.post("/api/angebote/:id/annehmen", async (req, reply) => { + const { id } = IdParam.parse(req.params); + const q = z.object({ start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), personen: z.number().positive().max(20).default(2) }).parse(req.body ?? {}); + const e = await einstellungen(); + const woche = { tage: e.arbeitstage }; + const r = await transaktion(pool, wer(req), async (c) => (await mitNeuplanung(c, woche, async () => { + const x = await ladeAngebot(c, id, e); + if (!x) return null; + if (!["entwurf", "versendet"].includes(x.angebot.status)) throw new AngebotFehler("Das Angebot ist schon angenommen oder abgelehnt."); + if (!x.positionen.length) throw new AngebotFehler("Das Angebot hat noch keine Position."); + await c.query("update angebot set status = 'angenommen', entschieden_am = $2, versendet_am = coalesce(versendet_am, $2), staende = staende || $3::jsonb where id = $1", + [id, heute(), JSON.stringify([stand(x, "auftrag", wer(req))])]); + const pid = x.angebot.projekt_id as string; + const p = (await c.query("select * from projekt where id = $1", [pid])).rows[0]; + // Auftragswert: alle angenommenen Angebote des Projekts (ein zweites Angebot kann ein Nachtrag sein) + const summe = (await c.query("select id from angebot where projekt_id = $1 and status = 'angenommen'", [pid])).rows; + let umsatz = 0; + for (const s of summe) umsatz += s.id === id ? x.ergebnis.netto : (await ladeAngebot(c, s.id, e))!.ergebnis.netto; + const nummer = /^A-/.test(p.nummer) && !(await c.query("select 1 from projekt where nummer = $1", [p.nummer.replace(/^A-/, "P-")])).rowCount + ? p.nummer.replace(/^A-/, "P-") : p.nummer; + const status = ["anfrage", "angebot"].includes(p.status) ? "auftrag" : p.status; + // geplante Kosten für die Liquidität, nur wenn noch keine eingetragen sind + const leer = !Number(p.material_kosten) && !Number(p.fremd_kosten) && !Number(p.sonstige_kosten); + const ka = x.ergebnis.kostenarten; + await c.query(`update projekt set umsatz_netto = $2, status = $3, nummer = $4, + material_kosten = case when $5 then $6 else material_kosten end, sonstige_kosten = case when $5 then $7 else sonstige_kosten end, + soll_stunden = coalesce(soll_stunden, 0) + $8 where id = $1`, + [pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.kosten, x.ergebnis.stunden]); + // Abschnitte nur, wenn das Projekt noch keinen Terminplan hat + const abschnitte = (await c.query("select count(*)::int as n from abschnitt where projekt_id = $1", [pid])).rows[0].n; + let neu = 0; + if (!abschnitte) { + const gruppen = x.titel.length + ? x.titel.map((t) => ({ name: t.bezeichnung, stunden: x.positionen.filter((p) => p.titel_id === t.id).reduce((s, p) => s + (x.ergebnis.positionen[p.id]!.zaehlt ? x.ergebnis.positionen[p.id]!.stunden : 0), 0) })) + : [{ name: "Ausführung", stunden: x.ergebnis.stunden }]; + let start = q.start ? naechsterArbeitstag(q.start, woche) : naechsterArbeitstag(plusTage(heute(), 14), woche); + let vorher: string | null = null; + for (const [i, g] of gruppen.entries()) { + const ab = (await c.query("insert into abschnitt (projekt_id, name, reihenfolge) values ($1, $2, $3) returning id", [pid, g.name, i])).rows[0]; + const stunden = Math.round(g.stunden * 100) / 100; + const dauer = Math.max(1, Math.ceil(stunden / (e.stundenProTag * q.personen))); + const v: { id: string } = (await c.query("insert into vorgang (abschnitt_id, name, start, dauer, stunden, personen, reihenfolge) values ($1, $2, $3, $4, $5, $6, 0) returning id", + [ab.id, g.name, start, dauer, stunden > 0 ? stunden : null, q.personen])).rows[0]; + if (vorher) await c.query("insert into vorgang_vorgaenger (vorgang_id, vorgaenger_id, art) values ($1, $2, 'EA')", [v.id, vorher]); + vorher = v.id; + start = naechsterArbeitstag(plusTage(start, 1), woche); + neu++; + } + } + return { projekt_id: pid, nummer, umsatz, abschnitte: neu }; + }, [], e.stundenProTag, e.aufgabenVorlage)).ergebnis); + if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" }); + const p = (await pool.query("select * from projekt where id = $1", [r.projekt_id])).rows[0]; + return { ...r, projekt: await nachProjekt(p, wer(req)) }; + }); +} diff --git a/src/server/app.ts b/src/server/app.ts index b1ead4e..70fcff4 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -25,6 +25,7 @@ import { registrierePersonal } from "./personal.js"; import { registriereZeiten } from "./zeiten.js"; import { registriereUrlaub, zeitraumText } from "./urlaub.js"; import { vorlageAnwenden } from "./vorlage.js"; +import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js"; import { type BezugArt, bezugsTage } from "../domain/bezug.js"; import { formatDatum, plusTage } from "../domain/datum.js"; @@ -91,6 +92,8 @@ export async function baueApp(o: Optionen): Promise { } } + registriereAngebote(app, pool, ladeEinstellungen, mitOrdner); + app.post("/api/projekte/:id/ordner", async (req, reply) => { const { id } = IdParam.parse(req.params); const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0]; @@ -217,6 +220,7 @@ export async function baueApp(o: Optionen): Promise { if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); const row = await transaktion(pool, benutzer(req), async (c) => { if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string }); + await pruefeBearbeitbar(c, t.name, undefined, daten); await versatzAusDatum(c, t.name, daten); const spalten = felder.filter((f) => daten[f] !== undefined); return geplant(c, t.name, async () => @@ -241,6 +245,7 @@ export async function baueApp(o: Optionen): Promise { if (t.name === "kosten" && daten.netto !== undefined && daten.automatisch === undefined) daten.automatisch = false; if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); const row = await transaktion(pool, benutzer(req), async (c) => { + await pruefeBearbeitbar(c, t.name, id, daten); await versatzAusDatum(c, t.name, daten, id); const spalten = felder.filter((f) => daten[f] !== undefined); if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) { @@ -260,8 +265,14 @@ export async function baueApp(o: Optionen): Promise { app.delete(`/api/${t.pfad}/:id`, async (req, reply) => { const { id } = IdParam.parse(req.params); - const n = await transaktion(pool, benutzer(req), async (c) => - geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id))); + const n = await transaktion(pool, benutzer(req), async (c) => { + // ein angenommenes Angebot ist das Soll der Nachkalkulation (A19) und bleibt + if (t.name === "angebot" && (await c.query("select 1 from angebot where id = $1 and status = 'angenommen'", [id])).rowCount) { + throw new AngebotFehler("Ein angenommenes Angebot lässt sich nicht löschen."); + } + await pruefeBearbeitbar(c, t.name === "angebot" ? "" : t.name, id, {}); + return geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id)); + }); return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" }); }); } @@ -351,6 +362,15 @@ export async function baueApp(o: Optionen): Promise { : !bis && eingeplant.has(s.id) ? `${s.name} ist eingeplant, aber ohne Freistellungsbescheinigung (§ 48b)` : ""; if (text) u.warnungen.push({ art: "freistellung", ziel: `subunternehmer-${s.id}`, text }); } + // A35: Bindefrist eines versendeten Angebots läuft bald ab + const bis = plusTage(heute, e.kalkulation.erinnerungTage); + const angebote = await pool.query(`select a.id, a.nummer, a.bindefrist, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id + where a.status = 'versendet' and a.bindefrist is not null and a.bindefrist <= $1 order by a.bindefrist`, [bis]); + for (const a of angebote.rows) { + u.warnungen.push({ art: "angebot", ziel: `angebot-${a.id}`, + text: a.bindefrist < heute ? `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) ist seit ${formatDatum(a.bindefrist)} abgelaufen` + : `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) endet am ${formatDatum(a.bindefrist)}, nachfassen?` }); + } return u; }); diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index f65520e..2e9a481 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -50,6 +50,25 @@ export const EinstellungenSchema = z.object({ // geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden kalenderToken: z.string().min(20).nullable().default(null), aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE), + // Stufe 3a: Vorgaben der Angebotskalkulation. Stundensätze (EK, Cent) gelten, bis Hennings Stundensatz-Excel da ist + kalkulation: z + .object({ + stundensaetze: z + .object({ planer: z.number().int().min(0).default(8000), geselle: z.number().int().min(0).default(5831), helfer: z.number().int().min(0).default(5000) }) + .prefault({}), + zuschlaege: z + .object({ lohn: z.number().min(0).max(500).default(20), material: z.number().min(0).max(500).default(5), geraet: z.number().min(0).max(500).default(10), sonstiges: z.number().min(0).max(500).default(10) }) + .prefault({}), + wagnis: z.number().min(0).max(50).default(5), + gewinn: z.number().min(0).max(50).default(5), + ausfall: z.number().min(0).max(50).default(5), + bindefristWochen: z.number().int().min(0).max(52).default(4), + // A35: so viele Tage vor Ablauf der Bindefrist erscheint die Erinnerung auf der Startseite + erinnerungTage: z.number().int().min(0).max(60).default(5), + kopftext: z.string().max(5000).default("vielen Dank für Ihre Anfrage. Gern bieten wir Ihnen die folgenden Leistungen an:"), + schlusstext: z.string().max(5000).default("An dieses Angebot halten wir uns bis zum {bindefrist} gebunden. Wir freuen uns auf Ihren Auftrag."), + }) + .prefault({}), }); export type Einstellungen = z.infer; diff --git a/src/server/kalender.ts b/src/server/kalender.ts index 8f3d740..875a46a 100644 --- a/src/server/kalender.ts +++ b/src/server/kalender.ts @@ -54,8 +54,17 @@ export async function baustellenKalender(pool: Pool, woche: Arbeitswoche): Promi export async function aufgabenKalender(pool: Pool): Promise { const r = await pool.query(`select a.id, a.text, a.faellig_am, a.geaendert_am, p.nummer from aufgabe a left join projekt p on p.id = a.projekt_id where a.erledigt_am is null and a.faellig_am is not null`); - return kalender("Aufgaben", r.rows.map((a) => ({ - uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am, - titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am, - }))); + // A35: Ende der Bindefrist offener Angebote als Termin (Outlook classic gleicht keine Aufgaben ab, E15) + const b = await pool.query(`select a.id, a.nummer, a.bindefrist, a.geaendert_am, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id + where a.status = 'versendet' and a.bindefrist is not null`); + return kalender("Aufgaben", [ + ...r.rows.map((a) => ({ + uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am, + titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am, + })), + ...b.rows.map((a) => ({ + uid: `bindefrist-${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.bindefrist, bis: a.bindefrist, + titel: `Bindefrist Angebot ${a.nummer} (${a.bezeichnung})`, geaendert: a.geaendert_am, + })), + ]); } diff --git a/src/server/migrations/014_angebote.sql b/src/server/migrations/014_angebote.sql new file mode 100644 index 0000000..c9ffd83 --- /dev/null +++ b/src/server/migrations/014_angebote.sql @@ -0,0 +1,97 @@ +-- Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation im Programm statt in Plancraft. +-- Ein Projekt kann mehrere Angebote haben; „Angebot annehmen“ macht daraus den Auftrag (A4). + +create table angebot ( + id uuid primary key default gen_random_uuid(), + projekt_id uuid not null references projekt (id) on delete cascade, + nummer text not null unique, + -- A7: Kostenvoranschlag aus derselben Kalkulation, als „unverbindlich“ gekennzeichnet + belegart text not null default 'angebot' check (belegart in ('angebot', 'kostenvoranschlag')), + status text not null default 'entwurf' check (status in ('entwurf', 'versendet', 'angenommen', 'abgelehnt')), + datum date not null default current_date, + -- A35: Standard 4 Wochen ab Angebotsdatum + bindefrist date, + betreff text, + kopftext text, + schlusstext text, + -- A37: Wagnis, Gewinn und Zahlungsausfall je Angebot, zusätzlich zu den Zuschlägen je Kostenart + wagnis_prozent numeric(6, 2) not null default 5, + gewinn_prozent numeric(6, 2) not null default 5, + ausfall_prozent numeric(6, 2) not null default 5, + -- A36: Stundensätze (Cent je Lohnart) und Standardzuschläge beim Anlegen festgeschrieben + saetze jsonb not null default '{}', + -- A19: festgeschriebene Kalkulationsstände (beim Versand und bei Auftrag), neueste zuletzt + staende jsonb not null default '[]', + versendet_am date, + entschieden_am date, + notiz text, + reihenfolge integer not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create index angebot_projekt on angebot (projekt_id); +create trigger angebot_protokoll before insert or update or delete on angebot + for each row execute function stempel_und_protokoll(); + +create table angebot_titel ( + id uuid primary key default gen_random_uuid(), + angebot_id uuid not null references angebot (id) on delete cascade, + oz text, + bezeichnung text not null, + reihenfolge integer not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create index angebot_titel_angebot on angebot_titel (angebot_id); +create trigger angebot_titel_protokoll before insert or update or delete on angebot_titel + for each row execute function stempel_und_protokoll(); + +create table angebot_position ( + id uuid primary key default gen_random_uuid(), + angebot_id uuid not null references angebot (id) on delete cascade, + titel_id uuid references angebot_titel (id) on delete cascade, + oz text, + kurztext text not null, + langtext text, + menge numeric(14, 4) not null default 1, + einheit text not null default 'St', + -- A28: normal, alternativ (zu einer Grundposition), eventual (ohne Gesamtbetrag), eventual_summe (einkalkuliert) + art text not null default 'normal' check (art in ('normal', 'alternativ', 'eventual', 'eventual_summe')), + grundposition_id uuid references angebot_position (id) on delete set null deferrable initially deferred, + -- fester Einheitspreis in Cent: Position ohne Kalkulation oder „Preis anpassen“ (A21) + ep_fest bigint check (ep_fest >= 0), + reihenfolge integer not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create index angebot_position_angebot on angebot_position (angebot_id); +create trigger angebot_position_protokoll before insert or update or delete on angebot_position + for each row execute function stempel_und_protokoll(); + +-- A2, A32, A33: Kostenzeilen je Einheit der Position +create table angebot_kosten ( + id uuid primary key default gen_random_uuid(), + position_id uuid not null references angebot_position (id) on delete cascade, + kostenart text not null check (kostenart in ('lohn', 'material', 'geraet', 'sonstiges')), + lohnart text check (lohnart in ('planer', 'geselle', 'helfer')), + beschreibung text, + -- je Einheit der Position; bei Lohn Stunden + menge numeric(14, 4) not null default 1, + einheit text, + -- Cent je Einheit der Kostenzeile; bei Lohn leer = Stundensatz der Lohnart + ek bigint check (ek >= 0), + faktor numeric(8, 4) not null default 1 check (faktor > 0), + faktor_grund text, + -- leer = Standardzuschlag der Kostenart + zuschlag_prozent numeric(7, 2), + reihenfolge integer not null default 0, + angelegt_am timestamptz not null default now(), + geaendert_am timestamptz not null default now(), + geaendert_von text not null default 'system' +); +create index angebot_kosten_position on angebot_kosten (position_id); +create trigger angebot_kosten_protokoll before insert or update or delete on angebot_kosten + for each row execute function stempel_und_protokoll(); diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index dfcea6c..60c44d8 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -98,6 +98,79 @@ export const TABELLEN: Tabelle[] = [ notiz: optText, }), }, + // Stufe 3a: Angebote mit Kalkulation (A2, A19, A28, A32, A37); Status und Stände nur über eigene Routen + { + name: "angebot", + pfad: "angebote", + sortierung: "projekt_id, datum, nummer", + schema: z.object({ + projekt_id: id, + nummer: text, + belegart: z.enum(["angebot", "kostenvoranschlag"]).optional(), + datum: datum.optional(), + bindefrist: datum.nullable().optional(), + betreff: optText, + kopftext: optText, + schlusstext: optText, + wagnis_prozent: z.number().min(0).max(50).optional(), + gewinn_prozent: z.number().min(0).max(50).optional(), + ausfall_prozent: z.number().min(0).max(50).optional(), + saetze: z.object({ + stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(), + zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(), + stand: datum.optional(), + }).optional(), + notiz: optText, + reihenfolge: z.number().int().optional(), + }), + }, + { + name: "angebot_titel", + pfad: "angebot-titel", + sortierung: "angebot_id, reihenfolge", + schema: z.object({ + angebot_id: id, + oz: optText, + bezeichnung: text, + reihenfolge: z.number().int().optional(), + }), + }, + { + name: "angebot_position", + pfad: "angebot-positionen", + sortierung: "angebot_id, reihenfolge", + schema: z.object({ + angebot_id: id, + titel_id: id.nullable().optional(), + oz: optText, + kurztext: text, + langtext: optText, + menge: z.number().min(0).max(1e9).optional(), + einheit: text.optional(), + art: z.enum(["normal", "alternativ", "eventual", "eventual_summe"]).optional(), + grundposition_id: id.nullable().optional(), + ep_fest: cent.min(0).nullable().optional(), + reihenfolge: z.number().int().optional(), + }), + }, + { + name: "angebot_kosten", + pfad: "angebot-kosten", + sortierung: "position_id, reihenfolge", + schema: z.object({ + position_id: id, + kostenart: z.enum(["lohn", "material", "geraet", "sonstiges"]), + lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(), + beschreibung: optText, + menge: z.number().min(0).max(1e9).optional(), + einheit: optText, + ek: cent.min(0).nullable().optional(), + faktor: z.number().positive().max(100).optional(), + faktor_grund: optText, + zuschlag_prozent: z.number().min(0).max(500).nullable().optional(), + reihenfolge: z.number().int().optional(), + }), + }, { name: "abschnitt", pfad: "abschnitte", diff --git a/src/web/angebote.ts b/src/web/angebote.ts new file mode 100644 index 0000000..d6a041d --- /dev/null +++ b/src/web/angebote.ts @@ -0,0 +1,421 @@ +// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026). Das Leistungsverzeichnis wird direkt in der Tabelle +// bearbeitet: Titel, Positionen, darunter je Position die Kostenzeilen (Lohn, Material, Gerät, Sonstiges). +// 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 } from "../domain/kalkulation.js"; +import { plusTage } from "../domain/datum.js"; +import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, optionenHtml, seite } from "./ui.js"; +import { liste } from "./liste.js"; + +export const ANGEBOT_STATUS: Record = { entwurf: "Entwurf", versendet: "Versendet", angenommen: "Angenommen", abgelehnt: "Abgelehnt" }; +const BELEGART: Record = { angebot: "Angebot", kostenvoranschlag: "Kostenvoranschlag" }; +const MARKE: Record = { entwurf: "grau", versendet: "offen", angenommen: "gut", abgelehnt: "schlecht" }; + +const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ",")); +const zahlAus = (t: string) => { const n = Number(t.trim().replace(/\./g, "").replace(",", ".")); if (!Number.isFinite(n)) throw new Error(`„${t}“ ist keine Zahl`); return n; }; +const 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)); + +export function angebotMarke(a: Zeile): string { + const abgelaufen = a.status === "versendet" && a.bindefrist && a.bindefrist < heute(); + return `${abgelaufen ? "Bindefrist abgelaufen" : esc(ANGEBOT_STATUS[a.status] ?? a.status)}`; +} + +/** Neues Angebot (oder neue Version) anlegen und öffnen */ +export async function neuesAngebot(projektId: string, vonAngebot?: string): Promise { + const a = await api("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 '

Noch kein Angebot. Mit „+ Angebot“ legst du eins an; die Nummer ist die des Projekts.

'; + return ``; +} + +// ---------- Liste aller Angebote ---------- + +export async function angeboteSeite(): Promise { + const [zeilen, projekte] = await Promise.all([api("angebote-liste"), api("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", 'Projekte'); + 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) => `${esc(a.nummer)}${a.belegart === "kostenvoranschlag" ? ' KVA' : ""}${esc(a.betreff || a.projekt_name)}` }, + { id: "projekt", titel: "Projekt", text: (a) => `${a.projekt_nummer} ${a.projekt_name}`, wert: (a) => `${esc(a.projekt_name)}${esc(a.projekt_nummer)}`, 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 `

Offen (versendet): ${euro(offen.reduce((t, a) => t + a.netto, 0))} in ${offen.length} ${offen.length === 1 ? "Angebot" : "Angeboten"}

`; + }, + })); +} + +// ---------- Angebot bearbeiten ---------- + +const offen = new Set(); + +export async function angebotSeite(id: string): Promise { + let d = await api(`angebote/${id}/voll`); + let meldung = ""; + // eigener Rahmen, damit die Ereignisse mit der Seite verschwinden + const wurzel = document.createElement("div"); + inhalt.replaceChildren(wurzel); + + const zeichne = () => { + // 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 = html(d, meldung); + if (k) { + const neu = wurzel.querySelector(`[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(`angebote/${id}/voll`); + meldung = m; + zeichne(); + }; + + const entwurf = () => d.angebot.status === "entwurf"; + const reihe = (titelId: string | null) => d.positionen.filter((p: Zeile) => (p.titel_id ?? null) === titelId); + const naechste = (liste: Zeile[]) => liste.reduce((m: number, x: Zeile) => Math.max(m, Number(x.reihenfolge) + 1), 0); + + const speichern = async (el: HTMLInputElement) => { + const [pfad, zid, feld] = el.dataset.k!.split(":") as [string, string, string]; + const typ = el.dataset.typ ?? "text"; + const roh = el.value.trim(); + let wert: unknown; + 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."); } + let body: Zeile = { [feld]: wert }; + if (pfad === "saetze") { + // Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben + const s = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, stand: d.angebot.saetze?.stand ?? heute() }; + (s as Zeile)[zid][feld] = wert ?? 0; + return api(`angebote/${id}`, "PATCH", { saetze: s }); + } + 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" } : kz?.einheit === "h" ? { 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 }); + }; + + zeichne(); + + const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; 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); } + }); + 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(`input[data-spalte="${el.dataset.spalte}"]`)]; + const weiter = felder[felder.indexOf(el) + 1]; + if (weiter && el.dataset.spalte) weiter.focus(); else el.blur(); + }); + wurzel.addEventListener("click", async (ev) => { + const b = (ev.target as HTMLElement).closest("[data-a]"); + if (!b) return; + const a = b.dataset.a!, zid = b.dataset.id ?? ""; + try { + if (a === "auf") { offen.has(zid) ? offen.delete(zid) : offen.add(zid); return zeichne(); } + if (a === "titel-neu") { + await api("angebot-titel", "POST", { angebot_id: id, bezeichnung: "Neuer Titel", reihenfolge: naechste(d.titel) }); + await neuLaden(); + const t = d.titel.at(-1); + if (t) wurzel.querySelector(`[data-k="angebot-titel:${t.id}:bezeichnung"]`)?.select(); + return; + } + if (a === "position-neu") { + const titelId = zid || null; + const p = await api("angebot-positionen", "POST", { angebot_id: id, titel_id: titelId, kurztext: "Neue Position", menge: 1, einheit: "St", reihenfolge: naechste(reihe(titelId)) }); + offen.add(p.id); + await neuLaden(); + wurzel.querySelector(`[data-k="angebot-positionen:${p.id}:kurztext"]`)?.select(); + return; + } + if (a === "kosten-neu") { + const art = b.dataset.art!; + const pos = d.positionen.find((x: Zeile) => x.id === zid); + const k = await api("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: 1, + einheit: art === "lohn" ? "h" : pos?.einheit ?? null, reihenfolge: naechste(d.kosten.filter((x: Zeile) => x.position_id === zid)) }); + await neuLaden(); + wurzel.querySelector(`[data-k="angebot-kosten:${k.id}:${art === "lohn" ? "menge" : "beschreibung"}"]`)?.focus(); + return; + } + if (a === "kosten-weg") { await api(`angebot-kosten/${zid}`, "DELETE"); return neuLaden(); } + if (a === "position-weg") { + if (!(await bestaetigen("Position mit ihren Kostenzeilen löschen?"))) return; + await api(`angebot-positionen/${zid}`, "DELETE"); + return neuLaden(); + } + if (a === "titel-weg") { + const n = reihe(zid).length; + if (!(await bestaetigen(n ? `Titel mit ${n} ${n === 1 ? "Position" : "Positionen"} löschen?` : "Titel löschen?"))) return; + await api(`angebot-titel/${zid}`, "DELETE"); + return neuLaden(); + } + if (a === "position-kopie") { + const p = d.positionen.find((x: Zeile) => x.id === zid)!; + const n = await api("angebot-positionen", "POST", { angebot_id: id, titel_id: p.titel_id, 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), reihenfolge: naechste(reihe(p.titel_id ?? null)) }); + for (const k of d.kosten.filter((x: Zeile) => x.position_id === zid)) { + 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), reihenfolge: k.reihenfolge }); + } + offen.add(n.id); + return neuLaden(); + } + if (a === "position-hoch" || a === "position-runter") { + const p = d.positionen.find((x: Zeile) => x.id === 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) { offen.add(pid); zeichne(); wurzel.querySelector(`[data-zeile="${pid}"]`)?.scrollIntoView({ block: "center" }); } + return; + } + if (a === "versenden") return 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 annehmen(); + if (a === "version") { + if (!(await bestaetigen("Neue Version als Kopie dieses Angebots anlegen?"))) return; + return 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); } + }); + + // A14: Versandprüfung; mit Fehlern nur nach ausdrücklichem „trotzdem“ + async function versenden(trotzdem: boolean): Promise { + const r = await api(`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 = `

Vor dem Versand bitte prüfen

+
    ${r.pruefung.map((p: Zeile) => `
  • ${esc(p.text)}
  • `).join("")}
+

${fehlerListe.length} ${fehlerListe.length === 1 ? "Punkt verhindert" : "Punkte verhindern"} den Versand. Du kannst trotzdem versenden, wenn das so gewollt ist.

+
`; + huelle.hidden = false; + const wahl = await new Promise((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 { + 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(`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}`; + } +} + +// ---------- Darstellung ---------- + +function html(d: Zeile, meldung: string): string { + const a = d.angebot, e = d.ergebnis, s = d.saetze; + const frei = a.status === "entwurf"; + const aus = frei ? "" : " disabled"; + const feld = (k: string, wert: unknown, o: { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string } = {}) => + ``; + const auswahl = (k: string, optionen: [string, string][], wert: string, titel: string) => ``; + const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false)); + + // OZ aus der Reihenfolge: Titel 01, Positionen 01.0001 (eigene OZ aus einem Import geht vor) + const oz: Record = {}; + 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) g.positionen.forEach((p, j) => (oz[p.id] = p.oz || (g.titel ? `${oz[g.titel.id]}.${String(j + 1).padStart(4, "0")}` : String(j + 1).padStart(2, "0")))); + + const kostenZeilen = (p: Zeile) => { + const r = e.positionen[p.id]; + const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id); + if (!frei && !zeilen.length) return '

Ohne Kalkulation, fester Preis.

'; + return `
+ ${zeilen.map((k: Zeile, i: number) => { + const z = r.kostenzeilen[i] ?? { kosten: 0, verkauf: 0 }; + const lohn = k.kostenart === "lohn"; + return ` + + + + + + + + `; + }).join("")} + +
ArtBezeichnungMenge je ${esc(p.einheit)}EinheitEKFaktorZuschlagKostenVerkauf
${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")}${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : ""}${feld(`angebot-kosten:${k.id}:beschreibung`, k.beschreibung ?? "", { titel: "Bezeichnung", platz: lohn ? "Tätigkeit" : "z. B. KVH 6/12" })}${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-menge", titel: "Menge", spalte: `km-${p.id}` })}${lohn ? 'h' : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-kurz", titel: "Einheit", liste: "einheiten" })}${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : "0,00", spalte: `ke-${p.id}` })}${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-kurz", titel: "Faktor" })}${feld(`angebot-kosten:${k.id}:zuschlag_prozent`, zahlText(k.zuschlag_prozent), { typ: "zahl", klasse: "zahl w-kurz", leer: "null", titel: "Zuschlag in Prozent", platz: zahlText(s.zuschlaege[k.kostenart]) })} %${euroGenau(z.kosten)}${euroGenau(z.verkauf)}${frei ? `` : ""}
${frei ? KOSTENARTEN.map((x) => ``).join(" ") : ""}${euro(r.kosten_je_einheit)}${euro(r.ep_kalkuliert)}
+

Je ${esc(p.einheit)}: Kosten ${euro(r.kosten_je_einheit)}, Einheitspreis kalkuliert ${euro(r.ep_kalkuliert)}${r.std_je_einheit ? `, ${String(r.std_je_einheit).replace(".", ",")} Std` : ""}. Verkauf = Kosten × Zuschlag × (Wagnis + Gewinn + Ausfall ${prozentText(s.wagnis + s.gewinn + s.ausfall)}).

`; + }; + + const positionZeilen = (p: Zeile, liste: Zeile[], j: number) => { + const r = e.positionen[p.id]; + const auf = offen.has(p.id); + const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler"); + const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ"); + return ` + ${esc(oz[p.id])} + ${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${p.art && p.art !== "normal" ? `${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}` : ""} + ${feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" })} + ${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", klasse: "kurz", titel: "Einheit", liste: "einheiten", spalte: "einheit" })} + ${euro(r.ep)}${p.ep_fest != null ? 'fest' : ""} + ${r.zaehlt ? euro(r.gb) : `(${euro(r.gb)})`} + ${r.stunden ? String(r.stunden).replace(".", ",") : ""} + ${auf ? `
+ ${frei || p.langtext ? `` : ""} +
+ + ${p.art === "alternativ" ? `` : ""} + + ${frei ? ` + ` : ""} +
${kostenZeilen(p)}
` : ""}`; + }; + + const lv = gruppen.map((g, gi) => `${g.titel ? `${esc(oz[g.titel.id])} + ${feld(`angebot-titel:${g.titel.id}:bezeichnung`, g.titel.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" })}${frei ? `` : ""} + ${euro(e.titel[g.titel.id])}` : ""} + ${g.positionen.map((p, j) => positionZeilen(p, g.positionen, j)).join("")} + ${frei && (g.titel || !d.titel.length) ? `` : ""}`).join(""); + + const fehlerZahl = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length; + const knoepfe = { + entwurf: ``, + versendet: ``, + abgelehnt: ``, + angenommen: "", + }[a.status as string] ?? ""; + const ka = e.kostenarten; + const staende = (a.staende ?? []) as Zeile[]; + + return `${EINHEITEN.map((x) => ` +
← +

${esc(BELEGART[a.belegart])} ${esc(a.nummer)}

${angebotMarke(a)} + ${knoepfe}${a.status !== "angenommen" ? '' : ""}
+ ${meldung ? `
${esc(meldung.replace(/^! /, ""))}
` : ""} +

${esc(a.projekt_nummer)} ${esc(a.projekt_name)}${a.bauherr_name ? ` · ${esc(a.bauherr_name)}${a.bauherr_firma ? `, ${esc(a.bauherr_firma)}` : ""}` : ' · kein Bauherr eingetragen'} + ${frei ? "" : ` · festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}`}

+
+
+
+ + + + + +
+
+ + + ${lv} +
OZLeistungMengeEinheitEPGBStd.
${frei ? '' : ""}${euro(e.netto)}
+ ${d.positionen.length ? "" : '

Lege Titel (z. B. „Dachstuhl“, „Dämmung“) und darin Positionen an. Mit ▸ öffnest du je Position die Kalkulation.

'}
+
+

{bindefrist} wird im Angebot durch das Datum ersetzt.

+
+ +
`; +} diff --git a/src/web/app.ts b/src/web/app.ts index a6b03bf..2b87bfa 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -2,7 +2,7 @@ import { kalenderwoche, terminplanSeite } from "./gantt.js"; import { type Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis, - huelle, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js"; + huelle, hinweisHtml, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js"; import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js"; import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js"; import { meinUrlaub } from "./urlaub.js"; @@ -10,6 +10,7 @@ import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, filterMenue, filterText, import { gesamtFortschritt } from "../domain/fortschritt.js"; import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js"; import { meineStunden, stundenSeite } from "./stunden.js"; +import { angebotSeite, angeboteHtml, angeboteSeite, neuesAngebot } from "./angebote.js"; // ---------- Reiter ---------- @@ -80,6 +81,7 @@ async function projekte(): Promise { location.hash = `projekt-${p.id}`; }; seite("Projekte", { text: "Neues Projekt", aktion: neu }); + inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", 'Angebote'); const [zeilen, kontaktListe] = await Promise.all([api("projekte"), api("kontakte")]); const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name])); const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i])); @@ -136,9 +138,10 @@ const stundenText = (h: number) => { const m = Math.round(h * 60); return `${Mat const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`); async function projektSeite(id: string): Promise { - const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt] = await Promise.all([ + const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt, angebote] = await Promise.all([ api(`projekte/${id}`), api("kontakte"), api("terminplan"), api("zahlungen"), api("kosten"), aufgabenDaten(), api("aufgaben"), api>("zeiten/projekte"), + api(`angebote-liste?projekt_id=${id}`), ]); const neuLaden = () => projektSeite(id); const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k])); @@ -150,7 +153,7 @@ async function projektSeite(id: string): Promise { const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id); const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p); - inhalt.innerHTML = `${hinweis.text ? `
${esc(hinweis.text)}
` : ""} + inhalt.innerHTML = `${hinweisHtml()}
←

${esc(p.bezeichnung)} (${esc(p.nummer)})

@@ -166,6 +169,7 @@ async function projektSeite(id: string): Promise {
`; hinweis.text = ""; + hinweis.gut = false; const oben = inhalt.querySelector("#p-oben")!; const unten = inhalt.querySelector("#p-unten")!; const teil = unten.querySelector("#teil")!; @@ -213,7 +217,7 @@ async function projektSeite(id: string): Promise {
Auftragswert netto
${euro(umsatz)}
Kosten geplant
${euro(kostenGesamt)}
Rohertrag
${euro(umsatz - kostenGesamt)}${umsatz ? ` (${Math.round(((umsatz - kostenGesamt) / umsatz) * 100)} %)` : ""}
Vertrag
${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}
-

Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 5. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.

+

Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 3c. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.

Einzelkosten

`; const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle)); const felder: Feld[] = [ @@ -249,7 +253,8 @@ async function projektSeite(id: string): Promise { const rechnungen = eigeneZahlungen.filter((z) => z.status !== "geplant").sort((a, b) => (a.rechnungsdatum ?? a.termin).localeCompare(b.rechnungsdatum ?? b.termin)); let abschlag = 0; const art = (z: Zeile) => (z.art === "abschlag" ? `${++abschlag}. Abschlag` : ZAHLUNGSART_TEXT[z.art] ?? z.art); - teil.innerHTML = `

Angebote

Angebote, Kostenvoranschläge und Auftragsbestätigungen schreibst du bis Stufe 5 noch in Plancraft; die PDFs liegen in der Ablage unter „01 Auftrag“.

+ knopf("+ Angebot", () => void neuesAngebot(id)); + teil.innerHTML = `

Angebote

${angeboteHtml(angebote)}

Rechnungen

${rechnungen.length ? `
    ${rechnungen.map((z) => { const ueberfaellig = z.status === "gestellt" && z.termin < heute(); return `
` : '

Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.

'}`; } else if (projektTeil === "berichte") { teil.innerHTML = `

Noch keine Berichte.

-
  • Bautagebuch mit Wetter, Personal und Fotos, am Handy (Stufe 4)
  • Regiebericht für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)
  • Abnahmeprotokoll mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung (Stufe 5)
`; +
  • Bautagebuch mit Wetter, Personal und Fotos, am Handy (Stufe 4)
  • Regiebericht für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)
  • Abnahmeprotokoll mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung
`; } else if (projektTeil === "ablage") { void zeigeAblage(); } else { @@ -707,7 +712,7 @@ async function uebersicht(): Promise { ${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}${a.kategorie ? `${esc(a.kategorie)}` : ""}`; const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `

${titel} ${liste.length}

${liste.length ? `
    ${liste.map(aufgabeLi).join("")}
` : `

${leer}

`}
`; - const SYMBOL: Record = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§" }; + const SYMBOL: Record = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§", angebot: "✉" }; const raster = document.createElement("div"); raster.className = "start"; @@ -864,6 +869,37 @@ async function daten(): Promise { daten(); }; inhalt.appendChild(knopf); + // Stufe 3a: Vorgaben für neue Angebote; ein angelegtes Angebot behält seine Sätze (A36) + const k = e.kalkulation; + const kalkFelder: Feld[] = [ + { name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" }, + { name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" }, + { name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Gilt für neue Angebote. Die genauen Sätze kommen aus deiner Stundensatz-Tabelle." }, + { name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" }, + { name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" }, + { name: "wagnis", titel: "Wagnis (%)", art: "zahl" }, { name: "gewinn", titel: "Gewinn (%)", art: "zahl" }, { name: "ausfall", titel: "Zahlungsausfall (%)", art: "zahl" }, + { name: "bindefristWochen", titel: "Bindefrist (Wochen)", art: "zahl" }, + { name: "erinnerungTage", titel: "Erinnerung vor Ablauf der Bindefrist (Tage)", art: "zahl" }, + { name: "kopftext", titel: "Einleitung", art: "langtext" }, + { name: "schlusstext", titel: "Schlusstext", art: "langtext", hilfe: "{bindefrist} wird durch das Datum ersetzt." }, + ]; + const kalkKnopf = document.createElement("button"); + kalkKnopf.className = "neben"; + kalkKnopf.textContent = "Angebotskalkulation bearbeiten"; + kalkKnopf.onclick = async () => { + const r = await dialog("Angebotskalkulation", kalkFelder, { ...k, ...k.stundensaetze, ...Object.fromEntries(Object.entries(k.zuschlaege).map(([x, v]) => [`z_${x}`, v])) }, false); + if (r?.aktion !== "speichern") return; + const d = r.daten, z = (n: string, alt: number) => (d[n] ?? alt) as number; + await api("einstellungen", "PUT", { ...e, kalkulation: { + stundensaetze: { planer: z("planer", 0), geselle: z("geselle", 0), helfer: z("helfer", 0) }, + zuschlaege: { lohn: z("z_lohn", 0), material: z("z_material", 0), geraet: z("z_geraet", 0), sonstiges: z("z_sonstiges", 0) }, + wagnis: z("wagnis", 0), gewinn: z("gewinn", 0), ausfall: z("ausfall", 0), + bindefristWochen: Math.round(z("bindefristWochen", k.bindefristWochen)), erinnerungTage: Math.round(z("erinnerungTage", k.erinnerungTage)), + kopftext: d.kopftext ?? "", schlusstext: d.schlusstext ?? "", + } }); + daten(); + }; + inhalt.append(" ", kalkKnopf); await vorlageEditor(e); } @@ -977,9 +1013,12 @@ async function zeige(): Promise { const kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1]; const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1]; const zuPersonal = mitarbeiter || personalTeil || kolonne || sub; + // Angebote (Stufe 3a) gehören zum Reiter Projekte + const angebot = /^angebot-([0-9a-f-]{36})$/.exec(id)?.[1]; + const zuProjekte = treffer || angebot || id === "angebote"; const projekt = treffer?.[1]; if (treffer?.[2]) projektTeil = treffer[2]; - const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!; + const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!; nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0])); try { await (ablage ? ablageSeite(ablage) @@ -987,7 +1026,9 @@ async function zeige(): Promise { : kolonne && reiter[0] === "personal" ? kolonneSeite(kolonne) : sub && reiter[0] === "personal" ? subunternehmerSeite(sub) : personalTeil && reiter[0] === "personal" ? personalSeite(personalTeil) - : projekt && reiter[0] === "projekte" ? projektSeite(projekt) : reiter[2]()); + : projekt && reiter[0] === "projekte" ? projektSeite(projekt) + : angebot && reiter[0] === "projekte" ? angebotSeite(angebot) + : id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]()); } catch (e) { inhalt.insertAdjacentHTML("beforeend", `

${esc((e as Error).message)}

`); } diff --git a/src/web/styles.css b/src/web/styles.css index 4f9fef4..ba12e2f 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -700,3 +700,93 @@ table.einfach td:last-child { text-align: right; white-space: nowrap; } .zeile-dazu { display: flex; gap: 8px; margin-top: 10px; flex-wrap: wrap; } .zeile-dazu select { flex: 1; min-width: 0; } .personal-raster #sub-teil { padding: 12px 16px 16px; } + +/* Angebote (Stufe 3a): Leistungsverzeichnis mit Kalkulation, Eingaben direkt in der Tabelle */ +.erfolg { background: var(--gut-bg); color: var(--gut-text); border-radius: 10px; padding: 10px 14px; margin-bottom: 12px; font-size: 14px; } +.angebot-kopf .marke { font-size: 14px; } +.kopf-knoepfe { display: flex; gap: 8px; flex-wrap: wrap; } +button.gefahr { color: var(--warn); } +button.neben.klein { padding: 3px 9px; font-size: 13px; } +button.neben:disabled { opacity: 0.4; cursor: default; } +.angebot-bezug { margin: -8px 0 14px; color: var(--leise); } +.angebot-raster { display: grid; grid-template-columns: minmax(0, 1fr) 330px; gap: 16px; align-items: start; } +.angebot-haupt, .angebot-seite { display: flex; flex-direction: column; gap: 16px; min-width: 0; } +.angebot-seite h3 { margin: 0 0 8px; font-size: 15px; display: flex; align-items: center; gap: 8px; } +.angebot-angaben { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 10px 14px; } +.angebot-angaben label, .saetze label, .position-details label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; } +.angebot-angaben .breit { grid-column: 1 / -1; } +.angebot-angaben p.hinweis { margin: 0; font-size: 13px; } +.angebot-raster input, .angebot-raster select, .angebot-raster textarea { width: 100%; min-width: 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; } +.angebot-raster input:focus, .angebot-raster select:focus, .angebot-raster textarea:focus { outline: 2px solid var(--akzent-hell); border-color: var(--akzent); } +.angebot-raster input:disabled, .angebot-raster select:disabled, .angebot-raster textarea:disabled { border-color: transparent; background: transparent; color: var(--text); opacity: 1; -webkit-text-fill-color: var(--text); } +.angebot-raster input.zahl { text-align: right; font-variant-numeric: tabular-nums; } +.angebot-raster input.kurz { width: 100%; } +.lv-karte { padding: 0; overflow: hidden; } +.lv-rolle { overflow-x: auto; } +table.lv { border: 0; border-radius: 0; min-width: 620px; table-layout: fixed; } +table.lv col.c-oz { width: 92px; } table.lv col.c-menge { width: 6.5em; } table.lv col.c-einheit { width: 5.2em; } +table.lv col.c-ep { width: 7.5em; } table.lv col.c-gb { width: 8.5em; } table.lv col.c-std { width: 4.5em; } +.kosten-rolle { overflow-x: auto; max-width: 100%; } +.angebot-raster select:disabled { appearance: none; } +table.lv th, table.lv td { padding: 6px 8px; } +table.lv td.oz { white-space: nowrap; font-variant-numeric: tabular-nums; color: var(--leise); font-size: 13px; width: 1%; } +table.lv td.text .marke { margin-top: 3px; display: inline-block; } +table.lv tr.titel td { background: var(--bg); font-weight: 600; } +table.lv tr.titel input { font-weight: 600; } +.titel-zeile { display: flex; gap: 6px; align-items: center; } +.titel-knoepfe { display: flex; gap: 4px; flex: none; } +table.lv tr.position.zaehlt-nicht td { color: var(--leise); } +table.lv tr.position.mit-fehler td.oz { box-shadow: inset 3px 0 0 var(--warn); } +table.lv tr.position.auf td { border-bottom-color: transparent; } +table.lv tr.details > td { background: var(--bg); } +table.lv tr.neu td { border-bottom: 0; padding: 8px; } +table.lv tfoot td { border-bottom: 0; } +.auf-zu { background: none; border: 0; color: var(--akzent); cursor: pointer; font: inherit; padding: 0 6px 0 0; } +button.weg { background: none; border: 0; color: var(--leise); cursor: pointer; font-size: 18px; line-height: 1; padding: 2px 6px; border-radius: 5px; } +button.weg:hover { background: var(--warnung-bg); color: var(--warn); } +.position-details { display: flex; flex-direction: column; gap: 10px; padding: 4px 0 8px; } +.details-zeile { display: flex; gap: 10px 14px; flex-wrap: wrap; align-items: flex-end; } +.details-zeile label { width: 13em; } +.details-knoepfe { display: flex; gap: 6px; margin-left: auto; flex-wrap: wrap; } +.position-details > .hinweis { margin: 0; font-size: 13px; } +table.kosten-tabelle { border-radius: 8px; width: auto; } +table.kosten-tabelle th, table.kosten-tabelle td { padding: 4px 6px; font-size: 13px; } +table.kosten-tabelle td.kz-text { display: flex; gap: 6px; } +table.kosten-tabelle td.kz-text select { width: 6.8em; flex: none; } +table.kosten-tabelle td.kz-text input { width: 12em; } +.angebot-raster input.w-menge { width: 5.5em; } +.angebot-raster input.w-euro { width: 6.5em; } +.angebot-raster input.w-kurz { width: 4.2em; } +.mit-einheit { display: inline-flex; align-items: center; gap: 4px; white-space: nowrap; color: var(--leise); } +table.kosten-tabelle tr.kz-lohn td:first-child { box-shadow: inset 3px 0 0 var(--akzent); } +table.kosten-tabelle tr.kz-material td:first-child { box-shadow: inset 3px 0 0 var(--holz); } +table.kosten-tabelle tr.kz-geraet td:first-child { box-shadow: inset 3px 0 0 var(--ein); } +table.kosten-tabelle tr.kz-sonstiges td:first-child { box-shadow: inset 3px 0 0 var(--leise); } +table.kosten-tabelle td:first-child select { width: 7.2em; } +.summen dl { display: grid; grid-template-columns: 1fr auto; gap: 6px 12px; margin: 0; } +.summen dt { color: var(--leise); } +.summen dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; } +.summen .brutto { font-weight: 700; font-size: 17px; color: var(--text); border-bottom: 1px solid var(--linie); padding-bottom: 6px; } +table.kalk-tabelle { border-radius: 8px; } +table.kalk-tabelle th, table.kalk-tabelle td { padding: 5px 7px; font-size: 13px; } +table.kalk-tabelle tfoot td { font-weight: 600; border-bottom: 0; } +.saetze { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 10px; } +.saetze label { flex: 1 1 6em; } +.saetze .mit-einheit input { width: 4.5em; } +.saetze-mehr { margin-top: 10px; font-size: 14px; } +.saetze-mehr summary { cursor: pointer; color: var(--akzent); } +.saetze-mehr .hinweis { font-size: 13px; margin: 6px 0 0; } +ul.pruefung { margin: 0; padding-left: 18px; font-size: 14px; display: flex; flex-direction: column; gap: 4px; } +ul.pruefung li.fehler { color: var(--warn); } +ul.pruefung li.hinweis { color: var(--leise); } +ul.pruefung .verweis { color: inherit; text-align: left; } +.dialog ul.pruefung { margin: 8px 0 12px; } +ul.staende { margin: 0; padding-left: 18px; font-size: 14px; } +@media (max-width: 1100px) { + .angebot-raster { grid-template-columns: 1fr; } +} +@media (max-width: 800px) { + .angebot-angaben { grid-template-columns: 1fr 1fr; } + table.lv col.c-std { width: 0; } + .kopf-knoepfe { width: 100%; } +} diff --git a/src/web/ui.ts b/src/web/ui.ts index 792c3c6..f07c5d8 100644 --- a/src/web/ui.ts +++ b/src/web/ui.ts @@ -184,12 +184,14 @@ export async function bearbeiten(pfad: string, titel: string, felder: Feld[], ze } /** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */ -export const hinweis = { text: "" }; +export const hinweis = { text: "", gut: false }; +export const hinweisHtml = () => (hinweis.text ? `
${esc(hinweis.text)}
` : ""); // Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement { - inhalt.innerHTML = `

${esc(titel)}

${hinweis.text ? `
${esc(hinweis.text)}
` : ""}`; + inhalt.innerHTML = `

${esc(titel)}

${hinweisHtml()}`; hinweis.text = ""; + hinweis.gut = false; if (knopf) { const b = document.createElement("button"); b.className = "haupt"; diff --git a/test/api.test.ts b/test/api.test.ts index 63e3487..3861168 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -989,3 +989,103 @@ describe.skipIf(!url)("Kolonnen und Subunternehmer (0.15)", () => { expect(u2.warnungen).toContainEqual(expect.objectContaining({ text: expect.stringContaining("Olaf Ohne ist seit 20.03.2027 abgelaufen") })); }); }); + +describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => { + let pool: Pool; + let app: FastifyInstance; + + beforeAll(async () => { + pool = erstellePool(url!); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); + }); + afterAll(async () => { + await app?.close(); + await pool?.end(); + }); + + const neu = async (pfad: string, body: object) => { + const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body }); + expect(r.statusCode, r.body).toBe(201); + return r.json(); + }; + const post = (pfad: string, body: object = {}) => app.inject({ method: "POST", url: `/api/${pfad}`, payload: body }); + const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json(); + + it("Angebot anlegen, kalkulieren, prüfen, versenden, annehmen: Auftrag mit Abschnitten und Zahlungsplan (A4, A14, A19, A36)", async () => { + const bauherr = await neu("kontakte", { name: "Familie Krause", rolle: "bauherr" }); + const p = await neu("projekte", { nummer: "A-26-130", bezeichnung: "Carport Krause", status: "anfrage" }); + const a = await neu("angebote/neu", { projekt_id: p.id }); + expect(a).toMatchObject({ nummer: "A-26-130", status: "entwurf", saetze: { stundensaetze: { geselle: 5831 } } }); + expect(a.bindefrist > a.datum).toBe(true); + expect((await hole(`projekte/${p.id}`)).status).toBe("angebot"); + const zweites = await neu("angebote/neu", { projekt_id: p.id }); + expect(zweites.nummer).toBe("A-26-131"); + + const t1 = await neu("angebot-titel", { angebot_id: a.id, bezeichnung: "Abbund", reihenfolge: 0 }); + const t2 = await neu("angebot-titel", { angebot_id: a.id, bezeichnung: "Montage", reihenfolge: 1 }); + const p1 = await neu("angebot-positionen", { angebot_id: a.id, titel_id: t1.id, kurztext: "Abbund KVH", menge: 100, einheit: "m" }); + await neu("angebot-kosten", { position_id: p1.id, kostenart: "lohn", lohnart: "geselle", menge: 0.2 }); + await neu("angebot-kosten", { position_id: p1.id, kostenart: "material", menge: 1, ek: 420, faktor: 1.1, beschreibung: "KVH 8/16" }); + const p2 = await neu("angebot-positionen", { angebot_id: a.id, titel_id: t2.id, kurztext: "Richten", menge: 1, einheit: "Stk." }); + await neu("angebot-kosten", { position_id: p2.id, kostenart: "lohn", lohnart: "geselle", menge: 24 }); + + const voll = await hole(`angebote/${a.id}/voll`); + expect(voll.ergebnis.stunden).toBe(44); + expect(voll.ergebnis.netto).toBe(voll.ergebnis.titel[t1.id] + voll.ergebnis.titel[t2.id]); + expect(voll.pruefung.map((x: { text: string }) => x.text)).toEqual(expect.arrayContaining([ + expect.stringContaining("kein Bauherr"), expect.stringContaining("„Stk.“ bitte als „St“"), + ])); + + // mit Fehler nur „trotzdem“; danach ist das Angebot gesperrt + expect((await post(`angebote/${a.id}/versenden`)).json()).toMatchObject({ versendet: false }); + await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { bauherr_id: bauherr.id } }); + await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${p2.id}`, payload: { einheit: "St" } }); + expect((await post(`angebote/${a.id}/versenden`)).json()).toMatchObject({ versendet: true, pruefung: [] }); + const gesperrt = await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${p1.id}`, payload: { menge: 120 } }); + expect(gesperrt.statusCode).toBe(409); + expect(gesperrt.json().fehler).toMatch(/versendet/); + expect((await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { notiz: "Kunde ruft Freitag an" } })).statusCode).toBe(200); + + // Stundensätze ändern wirkt nicht auf das bestehende Angebot (A36) + const e = await hole("einstellungen"); + await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, kalkulation: { ...e.kalkulation, stundensaetze: { ...e.kalkulation.stundensaetze, geselle: 9000 } } } }); + expect((await hole(`angebote/${a.id}/voll`)).ergebnis.netto).toBe(voll.ergebnis.netto); + + const r = await post(`angebote/${a.id}/annehmen`, { start: "2026-11-02" }); + expect(r.statusCode, r.body).toBe(200); + expect(r.json()).toMatchObject({ nummer: "P-26-130", umsatz: voll.ergebnis.netto, abschnitte: 2 }); + const proj = await hole(`projekte/${p.id}`); + expect(proj).toMatchObject({ status: "auftrag", nummer: "P-26-130", umsatz_netto: voll.ergebnis.netto, soll_stunden: 44 }); + const tp = await hole("terminplan"); + const vs = tp.vorgaenge.filter((v: { abschnitt_id: string }) => tp.abschnitte.some((x: { id: string; projekt_id: string }) => x.id === v.abschnitt_id && x.projekt_id === p.id)); + expect(vs.map((v: { name: string; stunden: number; dauer: number }) => [v.name, v.stunden, v.dauer])).toEqual([["Abbund", 20, 2], ["Montage", 24, 2]]); + expect(vs[1].start > vs[0].start).toBe(true); + const raten = (await hole("zahlungen")).filter((z: { projekt_id: string }) => z.projekt_id === p.id); + expect(raten.reduce((s: number, z: { netto: number }) => s + z.netto, 0)).toBe(voll.ergebnis.netto); + const ang = await hole(`angebote/${a.id}`); + expect(ang.staende.map((s: { anlass: string }) => s.anlass)).toEqual(["versand", "auftrag"]); + expect(ang.staende[1].netto).toBe(voll.ergebnis.netto); + expect((await app.inject({ method: "DELETE", url: `/api/angebote/${a.id}` })).statusCode).toBe(409); + expect((await post(`angebote/${a.id}/annehmen`)).statusCode).toBe(409); + }); + + it("Bindefrist: Erinnerung auf der Startseite 5 Tage vorher und Termin im Aufgaben-Kalender (A35)", async () => { + const p = await neu("projekte", { nummer: "A-26-140", bezeichnung: "Dachgaube Lüders" }); + const a = await neu("angebote/neu", { projekt_id: p.id }); + const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Gaube pauschal", menge: 1, einheit: "psch", ep_fest: 850000 }); + expect(pos.id).toBeTruthy(); + await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { bindefrist: "2026-12-10" } }); + await post(`angebote/${a.id}/versenden`, { trotzdem: true }); + expect((await hole("uebersicht?heute=2026-12-01")).warnungen.some((w: { art: string }) => w.art === "angebot")).toBe(false); + const u = await hole("uebersicht?heute=2026-12-05"); + expect(u.warnungen).toContainEqual(expect.objectContaining({ art: "angebot", ziel: `angebot-${a.id}`, text: expect.stringContaining("endet am 10.12.2026") })); + // eine Kopie als neue Version übernimmt Positionen, bekommt eine neue Nummer und die heutigen Sätze + const kopie = await neu("angebote/neu", { projekt_id: p.id, von_angebot_id: a.id }); + expect(kopie.nummer).not.toBe(a.nummer); + expect((await hole(`angebote/${kopie.id}/voll`)).ergebnis.netto).toBe(850000); + expect((await post(`angebote/${a.id}/ablehnen`)).statusCode).toBe(200); + expect((await hole("uebersicht?heute=2026-12-05")).warnungen.some((w: { art: string }) => w.art === "angebot")).toBe(false); + }); +}); diff --git a/test/kalkulation.test.ts b/test/kalkulation.test.ts new file mode 100644 index 0000000..24423ad --- /dev/null +++ b/test/kalkulation.test.ts @@ -0,0 +1,92 @@ +import { describe, it, expect } from "vitest"; +import { berechneAngebot, berechnePosition, einheitRichtig, naechsteNummer, pruefeAngebot, rundeCent, verteile, type Saetze } from "../src/domain/kalkulation.js"; + +const OHNE_WG: Saetze = { + stundensaetze: { planer: 8000, geselle: 5831, helfer: 5000 }, + zuschlaege: { lohn: 28, material: 30, geraet: 10, sonstiges: 0 }, + wagnis: 0, gewinn: 0, ausfall: 0, +}; + +describe("Angebotskalkulation (A2, A19, A28, A32, A37)", () => { + it("Verkaufs-Stundensatz wie im Plancraft-Muster A-26-112: 58,31 € + 28 % = 74,64 €", () => { + const r = berechnePosition({ id: "p", kurztext: "Stundenlohn", menge: 6.5, einheit: "h" }, + [{ position_id: "p", kostenart: "lohn", lohnart: "geselle", menge: 1 }], OHNE_WG); + expect(r.ep).toBe(7464); + expect(r.gb).toBe(48516); + expect(r.stunden).toBe(6.5); + }); + + it("Faktor je Kostenzeile und Wagnis/Gewinn zusätzlich zu den Zuschlägen", () => { + const s = { ...OHNE_WG, zuschlaege: { lohn: 20, material: 5, geraet: 10, sonstiges: 10 }, wagnis: 5, gewinn: 5, ausfall: 5 }; + // je m: 0,035 h Geselle + 1 m KVH zu 4,20 € mit Faktor 1,10 (Verschnitt) + const r = berechnePosition({ id: "p", kurztext: "Abbund KVH", menge: 100, einheit: "m" }, [ + { position_id: "p", kostenart: "lohn", lohnart: "geselle", menge: 0.035 }, + { position_id: "p", kostenart: "material", menge: 1, ek: 420, faktor: 1.1 }, + ], s); + // Lohn 0,035 × 58,31 × 1,2 × 1,15 = 2,8164; Material 4,20 × 1,1 × 1,05 × 1,15 = 5,5787 → 8,40 € + expect(r.ep).toBe(840); + expect(r.gb).toBe(84000); + expect(r.stunden).toBe(3.5); + }); + + it("Netto zählt nur Normal und Eventual einkalkuliert; Kostenarten ergeben genau das Netto", () => { + const titel = [{ id: "t1", bezeichnung: "Dach" }]; + const pos = [ + { id: "a", titel_id: "t1", kurztext: "Sparren", menge: 12.5, einheit: "m²" }, + { id: "b", titel_id: "t1", kurztext: "Anstrich", menge: 3, einheit: "m²", art: "eventual" as const }, + { id: "c", titel_id: "t1", kurztext: "Netz", menge: 1, einheit: "psch", art: "eventual_summe" as const, ep_fest: 15000 }, + ]; + const kosten = [ + { position_id: "a", kostenart: "lohn" as const, lohnart: "geselle" as const, menge: 0.4 }, + { position_id: "a", kostenart: "material" as const, menge: 1.05, ek: 1890 }, + { position_id: "b", kostenart: "material" as const, menge: 1, ek: 500 }, + ]; + const e = berechneAngebot({ ust_satz: 19 }, titel, pos, kosten, OHNE_WG); + const a = e.positionen.a!; + expect(e.positionen.b!.zaehlt).toBe(false); + expect(e.netto).toBe(a.gb + 15000); + expect(e.titel.t1).toBe(e.netto); + const summe = Object.values(e.kostenarten).reduce((s, k) => s + k.verkauf, 0); + expect(summe).toBe(e.netto); + expect(e.kostenarten.ohne.verkauf).toBe(15000); + expect(e.stunden).toBe(5); + expect(e.ust).toBe(Math.round(e.netto * 0.19)); + for (const k of Object.values(e.kostenarten)) expect(k.zuschlag).toBe(k.verkauf - k.kosten); + }); + + it("rundet kaufmännisch ohne Gleitkommafehler und verteilt centgenau", () => { + expect(rundeCent(267.4999)).toBe(267); + expect(rundeCent(267.49999999)).toBe(268); + expect(rundeCent(2.675 * 100)).toBe(268); + expect(rundeCent(-0.5)).toBe(-1); + expect(verteile(100, [1, 1, 1])).toEqual([34, 33, 33]); + expect(verteile(0, [0, 0])).toEqual([0, 0]); + }); + + it("Einheiten nach DIN 18334 und Angebotsnummern", () => { + expect(einheitRichtig("Stk.")).toBe("St"); + expect(einheitRichtig("m2")).toBe("m²"); + expect(einheitRichtig("lfm")).toBe("m"); + expect(einheitRichtig("Psch")).toBe("psch"); + expect(einheitRichtig("Fass")).toBeUndefined(); + expect(naechsteNummer(["A-26-120", "P-26-123", "A-25-300", "26-01"], 2026)).toBe("A-26-124"); + expect(naechsteNummer([], 2027)).toBe("A-27-001"); + }); + + it("Versandprüfung findet Platzhalter, fehlende Preise, Einheiten und Bindefrist (A14)", () => { + const pos = [ + { id: "a", kurztext: "Abschlag nach x-richten-x", menge: 1, einheit: "Stk." }, + { id: "b", kurztext: "Dämmung", menge: 0, einheit: "m²" }, + ]; + const e = berechneAngebot({}, [], pos, [], OHNE_WG); + const p = pruefeAngebot({ datum: "2026-09-13", bindefrist: "2026-04-10", schlusstext: "Annahmen: ???", empfaenger: false }, [], pos, [], e); + const texte = p.map((x) => x.text).join("\n"); + expect(texte).toContain("Bindefrist liegt vor dem Angebotsdatum"); + expect(texte).toContain("Schlusstext steht noch ein Platzhalter"); + expect(texte).toContain("Position Abschlag nach x-richten-x: Im Text steht noch ein Platzhalter"); + expect(texte).toContain("„Stk.“ bitte als „St“"); + expect(texte).toContain("Position Dämmung hat keine Menge"); + expect(texte).toContain("kein Bauherr"); + expect(pruefeAngebot({ datum: "2026-10-20" }, [], [], [], berechneAngebot({}, [], [], [], OHNE_WG))[0]!.text).toContain("keine Position"); + }); +});