Files
Betriebsf-hrungssoftware/src/server/angebote.ts
Claude c0dd91718e
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Projektnummern: keine doppelten, Buchstabe A/P/G/I nach Status, Aufräumen (0.40.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-26 09:10:25 +00:00

515 lines
36 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Stufe 3a (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 { projektNummer } from "../domain/nummer.js";
import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot, umgebungVon } from "../domain/kalkulation.js";
import { type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
import { hatBlatt, vorlagen } from "./leistungen-daten.js";
import { plusTage } from "../domain/datum.js";
import { naechsterArbeitstag } from "../domain/kalender.js";
import { aktuelleSaetze } from "./stundensaetze.js";
import { BELEG, BELEGARTEN, type Belegart, belegNummer, gaebPasst, gesperrt } from "../domain/belege.js";
import { type GaebLv, GAEB_PHASE, leseGaebDatei } from "../domain/gaeb.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"]);
const POSITION_SPALTEN = ["titel_id", "oz", "kurztext", "langtext", "menge", "einheit", "art", "ep_fest", "mit_kalkulation", "mit_aufmass", "aufmass", "textzeile", "markiert", "reihenfolge"];
const KOSTEN_SPALTEN = ["kostenart", "lohnart", "beschreibung", "menge", "einheit", "ek", "faktor", "faktor_grund", "zuschlag_prozent", "bezug", "personen", "aktiv", "aus_vorlage", "reihenfolge"];
const einfuegen = (tabelle: string, spalten: string[]) =>
`insert into ${tabelle} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`;
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<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen" | "kilometersatz" | "lohnarten" | "stundensatz_version">>;
return {
stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) },
...(s.lohnarten?.length ? { lohnarten: s.lohnarten } : {}),
stundensatz_version: s.stundensatz_version ?? null,
zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) },
wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent),
mengen: { verschnitt: e.kalkulation.verschnitt, oeffnung_ab: e.kalkulation.oeffnungAb, ...(s.mengen ?? {}) },
kilometersatz: s.kilometersatz ?? e.kalkulation.kilometersatz,
};
}
export async function ladeAngebot(c: Pick<Pool, "query">, 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, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort
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<Awaited<ReturnType<typeof ladeAngebot>>>) {
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<Awaited<ReturnType<typeof ladeAngebot>>>, 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<string, unknown>): Promise<void> {
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 GaebDatei = z.object({ dateiname: z.string().trim().min(1).max(200), text: z.string().min(1).max(30_000_000) });
const NeuSchema = z.object({
projekt_id: z.uuid(),
belegart: z.enum(BELEGARTEN).optional(),
// Kopie eines anderen Dokuments (neue Version, früheres Dokument, Vorlage)
von_angebot_id: z.uuid().optional(),
// Übernahme aus dem Vorgängerdokument der Belegkette (A10), mit Verweis darauf
vorbeleg_id: z.uuid().optional(),
// GAEB-Import (X81–X86, P81–P86, D81–D86); kunde: Kontakt als Kunde des Projekts eintragen, „neu“ legt ihn an
gaeb: GaebDatei.extend({ kunde: z.union([z.uuid(), z.literal("neu")]).optional() }).optional(),
});
/** GAEB-Datei lesen; Fehler als 400 */
function gaebLesen(d: { dateiname: string; text: string }): GaebLv {
try { return leseGaebDatei(d.text, d.dateiname); } catch (e) { throw Object.assign(new Error((e as Error).message), { statusCode: 400 }); }
}
/** Titel und Positionen aus GAEB ins Dokument; Preise aus .x84/.x86 werden feste Einheitspreise */
async function gaebEinfuegen(c: Client, angebotId: string, lv: GaebLv): Promise<void> {
const titel = new Map<string, string>();
for (const [i, t] of lv.titelListe.entries()) {
const n = (await c.query("insert into angebot_titel (angebot_id, oz, bezeichnung, reihenfolge) values ($1, $2, $3, $4) returning id", [angebotId, t.oz || null, t.bezeichnung.slice(0, 500), i])).rows[0];
titel.set(t.oz, n.id);
}
for (const [i, p] of lv.positionen.entries()) {
await c.query(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, mit_kalkulation, reihenfolge)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
[angebotId, p.titelOz ? titel.get(p.titelOz) ?? null : null, p.oz || null, p.kurztext, p.langtext || null, p.menge ?? 1, p.einheit || "St", p.art, p.ep, p.ep === null, i]);
}
}
async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void> {
const titelNeu = new Map<string, string>();
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<string, string>();
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(einfuegen("angebot_position", ["angebot_id", ...POSITION_SPALTEN]),
[nach, ...POSITION_SPALTEN.map((x) => (x === "titel_id" ? (p.titel_id ? titelNeu.get(p.titel_id) : null) : p[x]))])).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(einfuegen("angebot_kosten", ["position_id", ...KOSTEN_SPALTEN]), [posNeu.get(k.position_id), ...KOSTEN_SPALTEN.map((x) => k[x])]);
}
/**
* Platz für eine neue Zeile unter der markierten (A: „Ziehen oder + fügt unter der markierten Zeile ein“):
* hinter einer Position, am Anfang eines Titels oder am Ende. Die Zeilen darunter rücken eins weiter.
*/
async function platzUnter(c: Client, angebotId: string, nachId: string | null | undefined, titelId: string | null | undefined) {
const pos = nachId ? (await c.query("select titel_id, reihenfolge from angebot_position where id = $1 and angebot_id = $2", [nachId, angebotId])).rows[0] : undefined;
const titel = !pos && nachId ? (await c.query("select id from angebot_titel where id = $1 and angebot_id = $2", [nachId, angebotId])).rows[0] : undefined;
let tid: string | null, r: number;
if (pos) { tid = pos.titel_id; r = pos.reihenfolge + 1; }
else if (titel) { tid = titel.id; r = 0; }
else {
tid = titelId ?? (await c.query("select id from angebot_titel where angebot_id = $1 order by reihenfolge desc, angelegt_am desc limit 1", [angebotId])).rows[0]?.id ?? null;
r = (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_position where angebot_id = $1 and titel_id is not distinct from $2", [angebotId, tid])).rows[0].r;
}
await c.query("update angebot_position set reihenfolge = reihenfolge + 1 where angebot_id = $1 and titel_id is not distinct from $2 and reihenfolge >= $3", [angebotId, tid, r]);
return { titel_id: tid, reihenfolge: r };
}
/** Kostenzeilen aus den Zeitansätzen einer Vorlage */
async function ansaetzeEinfuegen(c: Client, positionId: string, ansaetze: Mengenvorlage["inhalt"]["ansaetze"], ab: number) {
for (const [i, z] of ansaetze.entries()) {
await c.query(einfuegen("angebot_kosten", ["position_id", "kostenart", "lohnart", "beschreibung", "bezug", "menge", "personen", "einheit", "ek", "faktor", "aktiv", "aus_vorlage", "reihenfolge"]),
[positionId, z.kostenart, z.kostenart === "lohn" ? z.lohnart ?? "geselle" : null, z.beschreibung ?? null, z.bezug ?? null, z.menge, z.personen ?? 1,
z.kostenart === "lohn" ? "h" : z.einheit ?? null, z.ek ?? null, z.faktor ?? 1, z.aktiv ?? true, true, ab + i]);
}
}
const EinfuegenSchema = z.object({
was: z.enum(["position", "text", "titel", "vorlage"]),
/** markierte Zeile (Position oder Titel), darunter kommt die neue */
nach_id: z.uuid().nullable().optional(),
titel_id: z.uuid().nullable().optional(),
vorlage_id: z.string().max(80).optional(),
/** Vorlage in diese Position einfügen statt eine neue anzulegen (Mengenblatt „Vorlage einfügen“) */
position_id: z.uuid().optional(),
/** Eingaben der Vorlage, beim Einfügen abgefragt */
eingaben: z.record(z.string().max(40), z.string().max(500)).default({}),
/** Menge statt der aus dem Mengenblatt (KI-Vorschlag) */
menge: z.number().min(0).max(1e9).optional(),
});
export function registriereAngebote(
app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>,
nachProjekt: (p: Record<string, any>, wer: string) => Promise<Record<string, unknown>>,
): 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));
const quelleId = q.vorbeleg_id ?? q.von_angebot_id;
const vorlage = quelleId ? (await c.query("select * from angebot where id = $1", [quelleId])).rows[0] : undefined;
if (quelleId && !vorlage) throw new AngebotFehler("Das Dokument, aus dem übernommen werden soll, gibt es nicht mehr.");
const art: Belegart = q.belegart ?? (q.vorbeleg_id ? "angebot" : vorlage?.belegart) ?? "angebot";
const dokumente = (await c.query("select id, nummer, belegart, status from angebot where projekt_id = $1", [p.id])).rows;
const grund = gesperrt(art, p.status, dokumente);
if (grund) throw new AngebotFehler(`${BELEG[art].name} gibt es erst ${grund.replace("ab ", "ab dem ").replace("angen.", "angenommenen")}.`);
if (q.vorbeleg_id && vorlage.projekt_id !== p.id) throw new AngebotFehler("Der Vorbeleg gehört zu einem anderen Projekt.");
const lv = q.gaeb ? gaebLesen(q.gaeb) : null;
// das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie; andere Arten haben eigene Nummernkreise (A10)
const jahr = new Date().getFullYear();
const nummer = art !== "angebot" ? belegNummer(art, nummern, jahr)
: /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, jahr);
const k = e.kalkulation;
const datum = heute();
// M17: Sätze aus den Stundensatz-Tabellen, die heute gelten; Vollkostensatz, daher Lohnzuschlag 0 % (A37, S4)
const neue = await aktuelleSaetze(c, datum);
const quelle = lv ? `${lv.format}${lv.phase ? ` Phase ${lv.phase}` : ""} · ${q.gaeb!.dateiname}` : q.vorbeleg_id ? `aus ${BELEG[vorlage.belegart as Belegart]?.name ?? "Dokument"} ${vorlage.nummer}` : null;
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze, vorbeleg_id, quelle, notiz)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) returning *`,
[q.projekt_id, nummer, art, datum, k.bindefristWochen && BELEG[art].gruppe === "kunde" && !["lieferschein", "auftragsbestaetigung"].includes(art) ? plusTage(datum, 7 * k.bindefristWochen) : null,
vorlage?.betreff ?? (lv ? (lv.projekt ?? lv.name).slice(0, 300) : 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, ...neue?.stundensaetze }, ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum },
q.vorbeleg_id ?? null, quelle, lv?.vortexte ? `Vorbemerkungen aus der GAEB-Datei:\n${lv.vortexte}`.slice(0, 100_000) : null])).rows[0];
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
if (lv) await gaebEinfuegen(c, neu.id, lv);
// Ausschreibung an Subunternehmer ohne eigene Preise (A15)
if (art === "ausschreibung" && vorlage) {
await c.query("delete from angebot_kosten where position_id in (select id from angebot_position where angebot_id = $1)", [neu.id]);
await c.query("update angebot_position set ep_fest = null where angebot_id = $1", [neu.id]);
}
// Auftraggeber aus der GAEB-Datei als Kunde des Projekts
if (lv && q.gaeb?.kunde && BELEG[art].gruppe === "kunde") {
const ag = lv.auftraggeber;
const kid = q.gaeb.kunde === "neu"
? ag ? (await c.query("insert into kontakt (name, rolle, notiz) values ($1, 'bauherr', $2) returning id",
[ag.name.slice(0, 300), [ag.strasse, [ag.plz, ag.ort].filter(Boolean).join(" ")].filter(Boolean).join(", ") || null])).rows[0].id : null
: q.gaeb.kunde;
if (kid) await c.query("update projekt set bauherr_id = $2 where id = $1", [p.id, kid]);
}
if (p.status === "anfrage" && ["angebot", "kostenvoranschlag"].includes(art)) 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);
});
// GAEB-Datei ansehen, bevor daraus ein Dokument wird: Format, Phase, Umfang, Auftraggeber und ob die Phase passt
app.post("/api/gaeb/vorschau", async (req) => {
const q = GaebDatei.extend({ belegart: z.enum(BELEGARTEN).default("angebot"), projekt_id: z.uuid() }).parse(req.body ?? {});
const lv = gaebLesen(q);
const p = (await pool.query("select p.bauherr_id, k.name from projekt p left join kontakt k on k.id = p.bauherr_id where p.id = $1", [q.projekt_id])).rows[0];
const ag = lv.auftraggeber;
const treffer = ag ? (await pool.query("select id, name, firma from kontakt where lower(name) = lower($1) or lower(firma) = lower($1) or name ilike '%' || $1 || '%' order by name limit 5", [ag.name])).rows : [];
return {
format: lv.format, version: lv.version, phase: lv.phase, phase_name: lv.phase ? GAEB_PHASE[lv.phase] ?? null : null, name: lv.name, projekt: lv.projekt,
titel: lv.titelListe.length, positionen: lv.positionen.length, mit_preis: lv.positionen.filter((x) => x.ep !== null).length,
mit_langtext: lv.positionen.filter((x) => x.langtext).length, vortexte: !!lv.vortexte,
auftraggeber: ag, treffer, kunde: p?.bauherr_id ? { id: p.bauherr_id, name: p.name } : null,
...gaebPasst(lv.phase, q.belegart),
};
});
app.get("/api/angebote/:id/voll", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const e = await einstellungen();
const x = await ladeAngebot(pool, id, e);
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" });
return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz, neue_stundensaetze: await neueSaetze(x) };
});
/** A36: gelten heute andere Stundensätze als im Entwurf festgeschrieben, fragt die Seite, ob sie übernommen werden */
async function neueSaetze(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>) {
if (x.angebot.status !== "entwurf") return null;
const neu = await aktuelleSaetze(pool, heute());
if (!neu) return null;
const alt = x.saetze.stundensaetze;
const gleich = neu.stundensatz_version.id === x.saetze.stundensatz_version?.id && Object.entries(neu.stundensaetze).every(([k, v]) => alt[k] === v);
return gleich ? null : neu;
}
// neue Stundensätze in den Entwurf übernehmen; ohne Version vorher (alte Sätze aus den Einstellungen) wird der Lohnzuschlag 0 %
app.post("/api/angebote/:id/stundensaetze", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const r = await transaktion(pool, wer(req), async (c) => {
const a = (await c.query("select status, saetze from angebot where id = $1 for update", [id])).rows[0];
if (!a) return null;
if (a.status !== "entwurf") throw new AngebotFehler("Nur Entwürfe bekommen neue Stundensätze; versendete Angebote bleiben, wie sie sind.");
const neu = await aktuelleSaetze(c, heute());
if (!neu) throw new AngebotFehler("Es gibt noch keine Stundensätze unter Personal → Stundensätze.");
const s = a.saetze ?? {};
const saetze = { ...s, stundensaetze: { ...s.stundensaetze, ...neu.stundensaetze }, lohnarten: neu.lohnarten, stundensatz_version: neu.stundensatz_version,
zuschlaege: s.stundensatz_version ? s.zuschlaege : { ...s.zuschlaege, lohn: 0 } };
await c.query("update angebot set saetze = $2 where id = $1", [id, saetze]);
return saetze;
});
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
return r;
});
// 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." });
});
app.get("/api/mengenvorlagen-alle", async () => vorlagen(pool));
// Bausteine, Musterpositionen und Mengenvorlagen ins Angebot (neue Maske 21.10.2026)
app.post("/api/angebote/:id/einfuegen", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const q = EinfuegenSchema.parse(req.body ?? {});
const e = await einstellungen();
const r = await transaktion(pool, wer(req), async (c) => {
const a = (await c.query("select * from angebot where id = $1", [id])).rows[0];
if (!a) return null;
if (a.status !== "entwurf") throw new AngebotFehler(`Angebot ${a.nummer} ist nicht mehr im Entwurf. Zum Ändern zuerst „Wieder bearbeiten“ wählen.`);
if (q.was === "titel") {
const nach = q.nach_id ? (await c.query(`select coalesce((select t.reihenfolge from angebot_titel t join angebot_position p on p.titel_id = t.id where p.id = $1),
(select reihenfolge from angebot_titel where id = $1)) as r`, [q.nach_id])).rows[0]?.r : null;
const rf = nach === null || nach === undefined ? (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_titel where angebot_id = $1", [id])).rows[0].r : nach + 1;
await c.query("update angebot_titel set reihenfolge = reihenfolge + 1 where angebot_id = $1 and reihenfolge >= $2", [id, rf]);
return (await c.query("insert into angebot_titel (angebot_id, bezeichnung, reihenfolge) values ($1, 'Neuer Titel', $2) returning id", [id, rf])).rows[0];
}
if (q.was !== "vorlage") {
const ort = await platzUnter(c, id, q.nach_id, q.titel_id);
return (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, menge, einheit, mit_kalkulation, textzeile)
values ($1, $2, $3, $4, $5, $6, false, $7) returning id`,
[id, ort.titel_id, ort.reihenfolge, q.was === "text" ? "Text" : "Neue Position", q.was === "text" ? 0 : 1, q.was === "text" ? "psch" : "St", q.was === "text"])).rows[0];
}
const v = (await vorlagen(c)).find((x) => String(x.id) === q.vorlage_id);
if (!v) throw new AngebotFehler("Diese Vorlage gibt es nicht mehr.");
const { ansaetze = [], ...inhalt } = v.inhalt;
const vorlageBlatt = alsBlatt(inhalt);
vorlageBlatt.werte = vorlageBlatt.werte.map((w) => (w.eingabe && q.eingaben[w.kz] !== undefined ? { ...w, formel: q.eingaben[w.kz]! } : w));
vorlageBlatt.vorlage = { id: String(v.id), name: v.name };
const umg = umgebungVon(saetzeVon(a, e));
if (q.position_id) {
const p = (await c.query("select * from angebot_position where id = $1 and angebot_id = $2", [q.position_id, id])).rows[0];
if (!p) return null;
const alt = alsBlatt(p.aufmass);
const blatt: Blatt = { ...vorlageBlatt, zeilen: alt.zeilen };
const menge = werteBlatt(blatt, umg).menge;
await c.query("delete from angebot_kosten where position_id = $1 and aus_vorlage", [p.id]);
const ab = (await c.query("select coalesce(max(reihenfolge) + 1, 0) as r from angebot_kosten where position_id = $1", [p.id])).rows[0].r;
await ansaetzeEinfuegen(c, p.id, ansaetze, ab);
await c.query(`update angebot_position set aufmass = $2, mit_aufmass = true, menge = coalesce($3, menge), einheit = coalesce($4, einheit),
mit_kalkulation = mit_kalkulation or $5 where id = $1`, [p.id, blatt, menge, v.einheit || null, ansaetze.length > 0]);
return { id: p.id };
}
const ort = await platzUnter(c, id, q.nach_id, q.titel_id);
// Leistungen aus GAEB haben oft kein Mengenblatt: dann zählt die eingetragene Menge; das Blatt merkt sich die Herkunft
const mitBlatt = hatBlatt(vorlageBlatt);
const menge = q.menge ?? (mitBlatt ? werteBlatt(vorlageBlatt, umg).menge ?? 1 : 1);
const p = (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, langtext, menge, einheit, mit_kalkulation, mit_aufmass, aufmass, ep_fest)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning id`,
[id, ort.titel_id, ort.reihenfolge, v.kurztext || v.name, v.langtext || null, menge, v.einheit || "St", ansaetze.length > 0, mitBlatt && q.menge === undefined, vorlageBlatt,
v.ep_fest === null || v.ep_fest === undefined || v.ep_fest === "" ? null : Number(v.ep_fest)])).rows[0];
await ansaetzeEinfuegen(c, p.id, ansaetze, 0);
return p;
});
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
return reply.status(201).send(r);
});
// „Als Musterposition speichern“ / „Als Vorlage speichern“: Mengenblatt und Kostenzeilen einer Position in den Katalog
app.post("/api/angebot-positionen/:id/als-vorlage", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const q = z.object({ name: z.string().trim().min(1).max(200), gruppe: z.string().trim().min(1).max(100), art: z.enum(["mengen", "muster"]) }).parse(req.body ?? {});
const r = await transaktion(pool, wer(req), async (c) => {
const p = (await c.query("select * from angebot_position where id = $1", [id])).rows[0];
if (!p) return null;
const kosten = (await c.query("select * from angebot_kosten where position_id = $1 order by reihenfolge, angelegt_am", [id])).rows;
const blatt = alsBlatt(p.mit_aufmass ? p.aufmass : null);
const inhalt = {
werte: blatt.werte, listen: blatt.listen, zeilen: blatt.zeilen, menge: blatt.menge ?? null,
ansaetze: p.mit_kalkulation ? kosten.map((k) => ({
kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, bezug: k.bezug, menge: Number(k.menge), personen: Number(k.personen),
einheit: k.einheit, ek: k.ek === null ? null : Number(k.ek), faktor: Number(k.faktor), aktiv: k.aktiv,
})) : [],
};
return (await c.query(`insert into mengenvorlage (art, gruppe, name, kurztext, langtext, einheit, inhalt) values ($1, $2, $3, $4, $5, $6, $7) returning *`,
[q.art, q.gruppe, q.name, q.art === "muster" ? p.kurztext : null, q.art === "muster" ? p.langtext : null, p.einheit, inhalt])).rows[0];
});
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
return reply.status(201).send(r);
});
// 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 (!BELEG[x.angebot.belegart as Belegart]?.annehmbar) throw new AngebotFehler(`Ein${x.angebot.belegart === "auftragsbestaetigung" ? "e" : ""} ${BELEG[x.angebot.belegart as Belegart]?.name ?? "Dokument"} wird nicht angenommen; angenommen werden Angebote und Nachträge.`);
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 status = ["anfrage", "angebot"].includes(p.status) ? "auftrag" : p.status;
// aus A-26-024 wird P-26-024, die Zahl bleibt (Henning, 26.10.2026)
const nummer = projektNummer(p.nummer, 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,
fremd_kosten = case when $5 then $9 else fremd_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 + ka.fahrt.kosten, x.ergebnis.stunden, ka.subunternehmer.kosten]);
// 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)) };
});
}