Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
515 lines
36 KiB
TypeScript
515 lines
36 KiB
TypeScript
// 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)) };
|
||
});
|
||
}
|