Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz), Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau (80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten. Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage bei neuer Version. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
389 lines
21 KiB
TypeScript
389 lines
21 KiB
TypeScript
// 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";
|
||
import { type Auswertung, type Blatt, alsBlatt, fehlendePlatzhalter, werteBlatt } from "./mengenblatt.js";
|
||
|
||
// Subunternehmer eigene Kostenart mit eigenem Zuschlag (Bild 2 vom 21.10.2026); Fahrt für Fahrt- und Transportkosten:
|
||
// 2 × Strecke × Einsatztage × Fahrzeuge in km, EK je km (Henning, 21.10.2026)
|
||
export const KOSTENARTEN = ["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"] as const;
|
||
export type Kostenart = (typeof KOSTENARTEN)[number];
|
||
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
|
||
lohn: "Lohn", material: "Material", geraet: "Gerät", fahrt: "Fahrt", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
|
||
};
|
||
// Lohnarten ohne Stundensatz-Tabellen; mit Tabellen (M17) sind es deren Schlüssel und der Mittellohn
|
||
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
|
||
export type Lohnart = string;
|
||
export const LOHNART_NAME: Record<string, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer", chef: "Chef", mittellohn: "Mittellohn" };
|
||
/** Lohnarten, die ein Angebot kennt: aus den festgeschriebenen Stundensatz-Tabellen oder die drei festen */
|
||
export function lohnartenVon(s: Pick<Saetze, "lohnarten" | "stundensaetze">): { id: string; name: string }[] {
|
||
if (s.lohnarten?.length) return s.lohnarten;
|
||
return Object.keys(s.stundensaetze).map((id) => ({ id, name: LOHNART_NAME[id] ?? id }));
|
||
}
|
||
/** Auswahl für eine Lohnzeile; eine Lohnart, die das Angebot nicht kennt, bleibt sichtbar */
|
||
export function lohnartOptionen(liste: { id: string; name: string }[], aktuell: string | null | undefined): [string, string][] {
|
||
const o = liste.map((x): [string, string] => [x.id, x.name]);
|
||
if (aktuell && !o.some(([id]) => id === aktuell)) o.push([aktuell, LOHNART_NAME[aktuell] ?? aktuell]);
|
||
return o;
|
||
}
|
||
/** Lohnarten für Vorlagen ohne Angebot: Mittellohn und die üblichen Tabellen */
|
||
export const VORLAGE_LOHNARTEN = ["mittellohn", "chef", "planer", "geselle", "helfer"].map((id) => ({ id, name: LOHNART_NAME[id]! }));
|
||
/** Lohnart neuer Lohnzeilen: Mittellohn, wenn das Angebot einen hat, sonst Geselle */
|
||
export const standardLohnart = (s: Pick<Saetze, "stundensaetze">) => (s.stundensaetze.mittellohn != null ? "mittellohn" : "geselle");
|
||
|
||
// 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<Positionsart, string> = {
|
||
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<string, string> = {
|
||
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<string, Cent>;
|
||
/** Lohnarten mit Namen aus den Stundensatz-Tabellen (M17), Mittellohn zuerst */
|
||
lohnarten?: { id: string; name: string }[];
|
||
/** Version der Stundensätze, aus der die Sätze stammen */
|
||
stundensatz_version?: { id: string; name: string; gilt_ab: string } | null;
|
||
/** Standardzuschläge in % je Kostenart */
|
||
zuschlaege: Record<Kostenart, number>;
|
||
wagnis: number;
|
||
gewinn: number;
|
||
ausfall: number;
|
||
/** Vorgaben für Mengenblätter: Verschnitt in %, Öffnungen werden ab dieser Fläche (m²) abgezogen (E28) */
|
||
mengen?: { verschnitt: number; oeffnung_ab: number };
|
||
/** EK je gefahrenem km in Cent, Vorschlag für Fahrtkosten */
|
||
kilometersatz?: Cent;
|
||
}
|
||
|
||
/** feste Größen, die jedes Mengenblatt kennt */
|
||
export function umgebungVon(s: Pick<Saetze, "mengen">): Record<string, number> {
|
||
return { VERSCHNITT: (s.mengen?.verschnitt ?? 10) / 100, ÖFFNUNG_AB: s.mengen?.oeffnung_ab ?? 2.5 };
|
||
}
|
||
|
||
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;
|
||
/** Kürzel oder Formel aus dem Mengenblatt; leer = Menge der Position, „menge“ ist dann je Einheit */
|
||
bezug?: string | null;
|
||
personen?: number | string | null;
|
||
/** abgewählt („nicht notwendig“): bleibt sichtbar, zählt nicht */
|
||
aktiv?: boolean | 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;
|
||
/** aus: fester Preis (ep_fest); an: Preis aus den Kostenzeilen, ep_fest ist dann „Preis anpassen“ */
|
||
mit_kalkulation?: boolean | null;
|
||
/** an: die Menge kommt aus dem Mengenblatt */
|
||
mit_aufmass?: boolean | null;
|
||
aufmass?: Blatt | null;
|
||
/** reine Textzeile im Leistungsverzeichnis, ohne Menge und Preis */
|
||
textzeile?: boolean | null;
|
||
reihenfolge?: number;
|
||
}
|
||
|
||
export interface KTitel {
|
||
id: string;
|
||
oz?: string | null;
|
||
bezeichnung: string;
|
||
reihenfolge?: number;
|
||
}
|
||
|
||
export interface PositionErgebnis {
|
||
id: string;
|
||
/** Menge, mit der gerechnet wird: aus dem Mengenblatt, wenn Aufmaß an ist */
|
||
menge: number;
|
||
/** Fehler im Mengenblatt (dann zählt die eingetragene Menge) */
|
||
aufmass_fehler: string | null;
|
||
/** 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;
|
||
/** Kosten der ganzen Position (ungerundet je Einheit × Menge, dann auf Cent) */
|
||
kosten_gesamt: 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<Kostenart, number>;
|
||
/** je Kostenzeile, in der Reihenfolge der Zeilen: Kosten und Verkauf je Einheit, Menge für die ganze Position */
|
||
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number; menge_gesamt: number; aktiv: boolean; fehler: string | null }[];
|
||
}
|
||
|
||
export interface KostenartSumme {
|
||
kosten: Cent;
|
||
verkauf: Cent;
|
||
zuschlag: Cent;
|
||
/** Zuschlag in % der Kosten (null ohne Kosten) */
|
||
prozent: number | null;
|
||
}
|
||
|
||
export interface AngebotErgebnis {
|
||
positionen: Record<string, PositionErgebnis>;
|
||
titel: Record<string, Cent>;
|
||
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<Kostenart | "ohne", KostenartSumme>;
|
||
/** 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);
|
||
if (k.kostenart === "fahrt") return s.kilometersatz ?? 50;
|
||
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? s.stundensaetze.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);
|
||
}
|
||
|
||
const leereArten = () => Object.fromEntries(KOSTENARTEN.map((a) => [a, 0])) as Record<Kostenart, number>;
|
||
|
||
/** Mengenblatt einer Position ausrechnen (nur wenn Aufmaß an ist) */
|
||
export function aufmassVon(p: Pick<KPosition, "mit_aufmass" | "aufmass">, s: Pick<Saetze, "mengen">): Auswertung | null {
|
||
return p.mit_aufmass && p.aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(s)) : null;
|
||
}
|
||
|
||
export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis {
|
||
const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100;
|
||
const vk = leereArten();
|
||
let kostenSumme = 0, std = 0;
|
||
const zeilen = [];
|
||
const blatt = aufmassVon(p, s);
|
||
const aufmassFehler = blatt ? (Object.values(blatt.fehler)[0] ?? (blatt.menge === null ? "keine Menge" : null)) : null;
|
||
const menge = p.textzeile ? 0 : blatt && blatt.menge !== null && !blatt.fehler.menge ? blatt.menge : zahl(p.menge);
|
||
const kalk = p.mit_kalkulation !== false && !p.textzeile;
|
||
for (const k of kosten) {
|
||
const ek = ekVon(k, s);
|
||
const z = zuschlagVon(k, s);
|
||
const personen = zahl(k.personen, 1);
|
||
// Menge je Einheit der Position; mit Bezug: Bezug × Ansatz × Personen für die ganze Position
|
||
let jeEinheit = zahl(k.menge) * personen, gesamt = jeEinheit * menge, fehler: string | null = null;
|
||
if (k.kostenart === "fahrt") {
|
||
// Fahrt: Bezug = Strecke einfach in km, Ansatz = Einsatztage, Personen = Fahrzeuge; hin und zurück
|
||
try {
|
||
if (!k.bezug || !k.bezug.trim()) throw new Error("Strecke in km fehlt");
|
||
const umg = blatt ?? werteBlatt({ werte: [], listen: [], zeilen: [] }, umgebungVon(s));
|
||
gesamt = 2 * umg.rechne(k.bezug) * zahl(k.menge) * personen;
|
||
jeEinheit = menge > 0 ? gesamt / menge : 0;
|
||
} catch (e) { fehler = (e as Error).message; gesamt = 0; jeEinheit = 0; }
|
||
} else if (k.bezug && k.bezug.trim()) {
|
||
try {
|
||
const umg = blatt ?? werteBlatt({ werte: [], listen: [], zeilen: [] }, umgebungVon(s));
|
||
const bezug = /^\s*menge\s*$/i.test(k.bezug) ? menge : umg.rechne(k.bezug.replace(/\bMENGE\b/g, String(menge)));
|
||
gesamt = bezug * zahl(k.menge) * personen;
|
||
jeEinheit = menge > 0 ? gesamt / menge : 0;
|
||
} catch (e) { fehler = (e as Error).message; gesamt = 0; jeEinheit = 0; }
|
||
}
|
||
const aktiv = k.aktiv !== false;
|
||
const kz = aktiv ? jeEinheit * ek * zahl(k.faktor, 1) : 0;
|
||
const v = kz * (1 + z / 100) * wg;
|
||
if (kalk) {
|
||
kostenSumme += kz;
|
||
vk[k.kostenart] += v;
|
||
if (k.kostenart === "lohn" && aktiv) std += jeEinheit;
|
||
}
|
||
zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z, menge_gesamt: Math.round(gesamt * 10000) / 10000, aktiv, fehler });
|
||
}
|
||
const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0));
|
||
const fest = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : null;
|
||
const ep = p.textzeile ? 0 : kalk ? fest ?? epKalk : fest ?? 0;
|
||
return {
|
||
id: p.id, menge, aufmass_fehler: aufmassFehler, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme), kosten_gesamt: rundeCent(kostenSumme * menge),
|
||
std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: !p.textzeile && zaehlt(p.art), 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<string, KKosten[]>();
|
||
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<string, PositionErgebnis> = {};
|
||
const titelSumme: Record<string, Cent> = Object.fromEntries(titel.map((t) => [t.id, 0]));
|
||
const arten = Object.fromEntries([...KOSTENARTEN, "ohne"].map((a) => [a, [0, 0]])) as Record<Kostenart | "ohne", [number, Cent]>;
|
||
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
|
||
if (p.mit_kalkulation !== false) {
|
||
(jePosition.get(p.id) ?? []).forEach((k, i) => (arten[k.kostenart][0] += r.menge * (r.kostenzeilen[i]?.kosten ?? 0)));
|
||
}
|
||
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<Kostenart | "ohne", KostenartSumme>;
|
||
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<string, string | null | undefined> = {},
|
||
): 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));
|
||
const saetzeLeer = { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: leereArten(), wagnis: 0, gewinn: 0, ausfall: 0 };
|
||
for (const x of positionen) {
|
||
const r = e.positionen[x.id];
|
||
if (x.textzeile) {
|
||
if (PLATZHALTER.some((re) => re.test(x.kurztext))) p.push({ stufe: "fehler", text: `Textzeile „${x.kurztext.slice(0, 30)}“: Platzhalter im Text.`, position_id: x.id });
|
||
continue;
|
||
}
|
||
if (r?.aufmass_fehler) p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Aufmaß ist ein Fehler (${r.aufmass_fehler}).`, position_id: x.id });
|
||
const fehlend = [...fehlendePlatzhalter(x.kurztext, aufmassVon(x, { mengen: undefined })), ...fehlendePlatzhalter(langtexte[x.id], aufmassVon(x, { mengen: undefined }))];
|
||
if (fehlend.length) p.push({ stufe: "fehler", text: `Position ${name(x)}: {${fehlend[0]}} im Text gibt es im Mengenblatt nicht.`, position_id: x.id });
|
||
const kaputt = r?.kostenzeilen.find((z) => z.fehler);
|
||
if (kaputt && x.mit_kalkulation !== false) p.push({ stufe: "fehler", text: `Position ${name(x)}: Bezug einer Kostenzeile geht nicht (${kaputt.fehler}).`, position_id: 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 (!((r?.menge ?? 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.mit_kalkulation !== false && 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) || k.aktiv === false) continue;
|
||
const x = positionen.find((y) => y.id === k.position_id)!;
|
||
if (x.mit_kalkulation === false || x.textzeile) continue;
|
||
if (k.kostenart !== "lohn" && !(ekVon(k, saetzeLeer) > 0)) {
|
||
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")}`;
|
||
}
|