Files
Betriebsf-hrungssoftware/src/domain/kalkulation.ts
Claude 45c21943bf
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
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
2026-10-22 06:55:22 +00:00

389 lines
21 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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")}`;
}