Angebote mit Kalkulation: Leistungsverzeichnis, Kostenzeilen, Versandprüfung, Annehmen macht den Auftrag (0.16.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-20 22:16:30 +00:00
parent 334cd9357e
commit 8979795502
17 changed files with 1567 additions and 19 deletions

277
src/server/angebote.ts Normal file
View File

@@ -0,0 +1,277 @@
// Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation. Anlegen mit festgeschriebenen Sätzen (A36),
// Versandprüfung (A14), Kalkulationsstand beim Versand und bei Auftrag (A19), „Angebot annehmen“ macht aus dem
// Projekt den Auftrag mit Abschnitten, Vorgängen und Zahlungsplan (A4, P9).
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Client, type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { mitNeuplanung } from "./terminplan.js";
import { werName } from "./anmeldung.js";
import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot } from "../domain/kalkulation.js";
import { plusTage } from "../domain/datum.js";
import { naechsterArbeitstag } from "../domain/kalender.js";
const IdParam = z.object({ id: z.uuid() });
const heute = () => new Date().toISOString().slice(0, 10);
export const ANGEBOT_TEILE = new Set(["angebot", "angebot_titel", "angebot_position", "angebot_kosten"]);
export class AngebotFehler extends Error {
statusCode = 409;
}
/** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */
export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze {
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege">>;
return {
stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) },
zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) },
wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent),
};
}
export async function ladeAngebot(c: Pick<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
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 NeuSchema = z.object({
projekt_id: z.uuid(),
belegart: z.enum(["angebot", "kostenvoranschlag"]).default("angebot"),
// Kopie eines anderen Angebots (neue Version, Vorlage aus einem früheren Angebot)
von_angebot_id: z.uuid().optional(),
});
async function kopiereInhalt(c: Client, von: string, nach: string): Promise<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(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, reihenfolge)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) returning id`,
[nach, p.titel_id ? titelNeu.get(p.titel_id) : null, p.oz, p.kurztext, p.langtext, p.menge, p.einheit, p.art, p.ep_fest, p.reihenfolge])).rows[0];
posNeu.set(p.id, n.id);
}
for (const p of positionen) {
if (p.grundposition_id && posNeu.has(p.grundposition_id)) await c.query("update angebot_position set grundposition_id = $2 where id = $1", [posNeu.get(p.id), posNeu.get(p.grundposition_id)]);
}
const kosten = (await c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1", [von])).rows;
for (const k of kosten) {
await c.query(`insert into angebot_kosten (position_id, kostenart, lohnart, beschreibung, menge, einheit, ek, faktor, faktor_grund, zuschlag_prozent, reihenfolge)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
[posNeu.get(k.position_id), k.kostenart, k.lohnart, k.beschreibung, k.menge, k.einheit, k.ek, k.faktor, k.faktor_grund, k.zuschlag_prozent, k.reihenfolge]);
}
}
export function registriereAngebote(
app: FastifyInstance, pool: Pool, einstellungen: () => Promise<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));
// das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie
const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear());
const k = e.kalkulation;
const datum = heute();
const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined;
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`,
[q.projekt_id, nummer, vorlage?.belegart ?? q.belegart, datum, k.bindefristWochen ? plusTage(datum, 7 * k.bindefristWochen) : null,
vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall,
// A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen
{ stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, stand: datum }])).rows[0];
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
return neu;
});
if (!a) return reply.status(404).send({ fehler: "Projekt nicht gefunden" });
return reply.status(201).send(a);
});
app.get("/api/angebote/:id/voll", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const x = await ladeAngebot(pool, id, await einstellungen());
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" });
return { ...x, pruefung: pruefung(x) };
});
// A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“
app.post("/api/angebote/:id/versenden", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const q = z.object({ trotzdem: z.boolean().default(false), datum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.body ?? {});
const e = await einstellungen();
const r = await transaktion(pool, wer(req), async (c) => {
const x = await ladeAngebot(c, id, e);
if (!x) return null;
if (x.angebot.status !== "entwurf") throw new AngebotFehler("Das Angebot ist nicht mehr im Entwurf.");
const p = pruefung(x);
if (p.some((f) => f.stufe === "fehler") && !q.trotzdem) return { pruefung: p, versendet: false };
const am = q.datum ?? heute();
await c.query("update angebot set status = 'versendet', versendet_am = $2, staende = staende || $3::jsonb where id = $1",
[id, am, JSON.stringify([stand(x, "versand", wer(req))])]);
if (["anfrage"].includes(x.angebot.projekt_status)) await c.query("update projekt set status = 'angebot' where id = $1", [x.angebot.projekt_id]);
return { pruefung: p, versendet: true };
});
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
return r;
});
// Zurück in den Entwurf, z. B. nach Rückfrage des Kunden; der versendete Stand bleibt in den Ständen erhalten
app.post("/api/angebote/:id/bearbeiten", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const r = await transaktion(pool, wer(req), async (c) =>
(await c.query("update angebot set status = 'entwurf', entschieden_am = null where id = $1 and status in ('versendet', 'abgelehnt') returning *", [id])).rows[0]);
return r ?? reply.status(409).send({ fehler: "Nur ein versendetes oder abgelehntes Angebot lässt sich wieder bearbeiten." });
});
app.post("/api/angebote/:id/ablehnen", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const r = await transaktion(pool, wer(req), async (c) =>
(await c.query("update angebot set status = 'abgelehnt', entschieden_am = $2 where id = $1 and status in ('entwurf', 'versendet') returning *", [id, heute()])).rows[0]);
return r ?? reply.status(409).send({ fehler: "Dieses Angebot lässt sich nicht als abgelehnt markieren." });
});
// A4: Angebot annehmen → Auftrag. Titel werden Abschnitte mit je einem Vorgang (Stunden aus der Kalkulation),
// der Auftragswert ist die Summe der angenommenen Angebote, der Zahlungsplan entsteht nach P9 von selbst.
app.post("/api/angebote/:id/annehmen", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const q = z.object({ start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), personen: z.number().positive().max(20).default(2) }).parse(req.body ?? {});
const e = await einstellungen();
const woche = { tage: e.arbeitstage };
const r = await transaktion(pool, wer(req), async (c) => (await mitNeuplanung(c, woche, async () => {
const x = await ladeAngebot(c, id, e);
if (!x) return null;
if (!["entwurf", "versendet"].includes(x.angebot.status)) throw new AngebotFehler("Das Angebot ist schon angenommen oder abgelehnt.");
if (!x.positionen.length) throw new AngebotFehler("Das Angebot hat noch keine Position.");
await c.query("update angebot set status = 'angenommen', entschieden_am = $2, versendet_am = coalesce(versendet_am, $2), staende = staende || $3::jsonb where id = $1",
[id, heute(), JSON.stringify([stand(x, "auftrag", wer(req))])]);
const pid = x.angebot.projekt_id as string;
const p = (await c.query("select * from projekt where id = $1", [pid])).rows[0];
// Auftragswert: alle angenommenen Angebote des Projekts (ein zweites Angebot kann ein Nachtrag sein)
const summe = (await c.query("select id from angebot where projekt_id = $1 and status = 'angenommen'", [pid])).rows;
let umsatz = 0;
for (const s of summe) umsatz += s.id === id ? x.ergebnis.netto : (await ladeAngebot(c, s.id, e))!.ergebnis.netto;
const nummer = /^A-/.test(p.nummer) && !(await c.query("select 1 from projekt where nummer = $1", [p.nummer.replace(/^A-/, "P-")])).rowCount
? p.nummer.replace(/^A-/, "P-") : p.nummer;
const status = ["anfrage", "angebot"].includes(p.status) ? "auftrag" : p.status;
// geplante Kosten für die Liquidität, nur wenn noch keine eingetragen sind
const leer = !Number(p.material_kosten) && !Number(p.fremd_kosten) && !Number(p.sonstige_kosten);
const ka = x.ergebnis.kostenarten;
await c.query(`update projekt set umsatz_netto = $2, status = $3, nummer = $4,
material_kosten = case when $5 then $6 else material_kosten end, sonstige_kosten = case when $5 then $7 else sonstige_kosten end,
soll_stunden = coalesce(soll_stunden, 0) + $8 where id = $1`,
[pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.kosten, x.ergebnis.stunden]);
// Abschnitte nur, wenn das Projekt noch keinen Terminplan hat
const abschnitte = (await c.query("select count(*)::int as n from abschnitt where projekt_id = $1", [pid])).rows[0].n;
let neu = 0;
if (!abschnitte) {
const gruppen = x.titel.length
? x.titel.map((t) => ({ name: t.bezeichnung, stunden: x.positionen.filter((p) => p.titel_id === t.id).reduce((s, p) => s + (x.ergebnis.positionen[p.id]!.zaehlt ? x.ergebnis.positionen[p.id]!.stunden : 0), 0) }))
: [{ name: "Ausführung", stunden: x.ergebnis.stunden }];
let start = q.start ? naechsterArbeitstag(q.start, woche) : naechsterArbeitstag(plusTage(heute(), 14), woche);
let vorher: string | null = null;
for (const [i, g] of gruppen.entries()) {
const ab = (await c.query("insert into abschnitt (projekt_id, name, reihenfolge) values ($1, $2, $3) returning id", [pid, g.name, i])).rows[0];
const stunden = Math.round(g.stunden * 100) / 100;
const dauer = Math.max(1, Math.ceil(stunden / (e.stundenProTag * q.personen)));
const v: { id: string } = (await c.query("insert into vorgang (abschnitt_id, name, start, dauer, stunden, personen, reihenfolge) values ($1, $2, $3, $4, $5, $6, 0) returning id",
[ab.id, g.name, start, dauer, stunden > 0 ? stunden : null, q.personen])).rows[0];
if (vorher) await c.query("insert into vorgang_vorgaenger (vorgang_id, vorgaenger_id, art) values ($1, $2, 'EA')", [v.id, vorher]);
vorher = v.id;
start = naechsterArbeitstag(plusTage(start, 1), woche);
neu++;
}
}
return { projekt_id: pid, nummer, umsatz, abschnitte: neu };
}, [], e.stundenProTag, e.aufgabenVorlage)).ergebnis);
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
const p = (await pool.query("select * from projekt where id = $1", [r.projekt_id])).rows[0];
return { ...r, projekt: await nachProjekt(p, wer(req)) };
});
}

View File

@@ -25,6 +25,7 @@ import { registrierePersonal } from "./personal.js";
import { registriereZeiten } from "./zeiten.js";
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js";
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
import { formatDatum, plusTage } from "../domain/datum.js";
@@ -91,6 +92,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
}
}
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
app.post("/api/projekte/:id/ordner", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0];
@@ -217,6 +220,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
const row = await transaktion(pool, benutzer(req), async (c) => {
if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string });
await pruefeBearbeitbar(c, t.name, undefined, daten);
await versatzAusDatum(c, t.name, daten);
const spalten = felder.filter((f) => daten[f] !== undefined);
return geplant(c, t.name, async () =>
@@ -241,6 +245,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
if (t.name === "kosten" && daten.netto !== undefined && daten.automatisch === undefined) daten.automatisch = false;
if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
const row = await transaktion(pool, benutzer(req), async (c) => {
await pruefeBearbeitbar(c, t.name, id, daten);
await versatzAusDatum(c, t.name, daten, id);
const spalten = felder.filter((f) => daten[f] !== undefined);
if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
@@ -260,8 +265,14 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const n = await transaktion(pool, benutzer(req), async (c) =>
geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id)));
const n = await transaktion(pool, benutzer(req), async (c) => {
// ein angenommenes Angebot ist das Soll der Nachkalkulation (A19) und bleibt
if (t.name === "angebot" && (await c.query("select 1 from angebot where id = $1 and status = 'angenommen'", [id])).rowCount) {
throw new AngebotFehler("Ein angenommenes Angebot lässt sich nicht löschen.");
}
await pruefeBearbeitbar(c, t.name === "angebot" ? "" : t.name, id, {});
return geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id));
});
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
}
@@ -351,6 +362,15 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
: !bis && eingeplant.has(s.id) ? `${s.name} ist eingeplant, aber ohne Freistellungsbescheinigung (§ 48b)` : "";
if (text) u.warnungen.push({ art: "freistellung", ziel: `subunternehmer-${s.id}`, text });
}
// A35: Bindefrist eines versendeten Angebots läuft bald ab
const bis = plusTage(heute, e.kalkulation.erinnerungTage);
const angebote = await pool.query(`select a.id, a.nummer, a.bindefrist, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id
where a.status = 'versendet' and a.bindefrist is not null and a.bindefrist <= $1 order by a.bindefrist`, [bis]);
for (const a of angebote.rows) {
u.warnungen.push({ art: "angebot", ziel: `angebot-${a.id}`,
text: a.bindefrist < heute ? `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) ist seit ${formatDatum(a.bindefrist)} abgelaufen`
: `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) endet am ${formatDatum(a.bindefrist)}, nachfassen?` });
}
return u;
});

View File

@@ -50,6 +50,25 @@ export const EinstellungenSchema = z.object({
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
kalenderToken: z.string().min(20).nullable().default(null),
aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE),
// Stufe 3a: Vorgaben der Angebotskalkulation. Stundensätze (EK, Cent) gelten, bis Hennings Stundensatz-Excel da ist
kalkulation: z
.object({
stundensaetze: z
.object({ planer: z.number().int().min(0).default(8000), geselle: z.number().int().min(0).default(5831), helfer: z.number().int().min(0).default(5000) })
.prefault({}),
zuschlaege: z
.object({ lohn: z.number().min(0).max(500).default(20), material: z.number().min(0).max(500).default(5), geraet: z.number().min(0).max(500).default(10), sonstiges: z.number().min(0).max(500).default(10) })
.prefault({}),
wagnis: z.number().min(0).max(50).default(5),
gewinn: z.number().min(0).max(50).default(5),
ausfall: z.number().min(0).max(50).default(5),
bindefristWochen: z.number().int().min(0).max(52).default(4),
// A35: so viele Tage vor Ablauf der Bindefrist erscheint die Erinnerung auf der Startseite
erinnerungTage: z.number().int().min(0).max(60).default(5),
kopftext: z.string().max(5000).default("vielen Dank für Ihre Anfrage. Gern bieten wir Ihnen die folgenden Leistungen an:"),
schlusstext: z.string().max(5000).default("An dieses Angebot halten wir uns bis zum {bindefrist} gebunden. Wir freuen uns auf Ihren Auftrag."),
})
.prefault({}),
});
export type Einstellungen = z.infer<typeof EinstellungenSchema>;

View File

@@ -54,8 +54,17 @@ export async function baustellenKalender(pool: Pool, woche: Arbeitswoche): Promi
export async function aufgabenKalender(pool: Pool): Promise<string> {
const r = await pool.query(`select a.id, a.text, a.faellig_am, a.geaendert_am, p.nummer from aufgabe a left join projekt p on p.id = a.projekt_id
where a.erledigt_am is null and a.faellig_am is not null`);
return kalender("Aufgaben", r.rows.map((a) => ({
uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am,
titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am,
})));
// A35: Ende der Bindefrist offener Angebote als Termin (Outlook classic gleicht keine Aufgaben ab, E15)
const b = await pool.query(`select a.id, a.nummer, a.bindefrist, a.geaendert_am, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id
where a.status = 'versendet' and a.bindefrist is not null`);
return kalender("Aufgaben", [
...r.rows.map((a) => ({
uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am,
titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am,
})),
...b.rows.map((a) => ({
uid: `bindefrist-${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.bindefrist, bis: a.bindefrist,
titel: `Bindefrist Angebot ${a.nummer} (${a.bezeichnung})`, geaendert: a.geaendert_am,
})),
]);
}

View File

@@ -0,0 +1,97 @@
-- Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation im Programm statt in Plancraft.
-- Ein Projekt kann mehrere Angebote haben; „Angebot annehmen“ macht daraus den Auftrag (A4).
create table angebot (
id uuid primary key default gen_random_uuid(),
projekt_id uuid not null references projekt (id) on delete cascade,
nummer text not null unique,
-- A7: Kostenvoranschlag aus derselben Kalkulation, als „unverbindlich“ gekennzeichnet
belegart text not null default 'angebot' check (belegart in ('angebot', 'kostenvoranschlag')),
status text not null default 'entwurf' check (status in ('entwurf', 'versendet', 'angenommen', 'abgelehnt')),
datum date not null default current_date,
-- A35: Standard 4 Wochen ab Angebotsdatum
bindefrist date,
betreff text,
kopftext text,
schlusstext text,
-- A37: Wagnis, Gewinn und Zahlungsausfall je Angebot, zusätzlich zu den Zuschlägen je Kostenart
wagnis_prozent numeric(6, 2) not null default 5,
gewinn_prozent numeric(6, 2) not null default 5,
ausfall_prozent numeric(6, 2) not null default 5,
-- A36: Stundensätze (Cent je Lohnart) und Standardzuschläge beim Anlegen festgeschrieben
saetze jsonb not null default '{}',
-- A19: festgeschriebene Kalkulationsstände (beim Versand und bei Auftrag), neueste zuletzt
staende jsonb not null default '[]',
versendet_am date,
entschieden_am date,
notiz text,
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index angebot_projekt on angebot (projekt_id);
create trigger angebot_protokoll before insert or update or delete on angebot
for each row execute function stempel_und_protokoll();
create table angebot_titel (
id uuid primary key default gen_random_uuid(),
angebot_id uuid not null references angebot (id) on delete cascade,
oz text,
bezeichnung text not null,
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index angebot_titel_angebot on angebot_titel (angebot_id);
create trigger angebot_titel_protokoll before insert or update or delete on angebot_titel
for each row execute function stempel_und_protokoll();
create table angebot_position (
id uuid primary key default gen_random_uuid(),
angebot_id uuid not null references angebot (id) on delete cascade,
titel_id uuid references angebot_titel (id) on delete cascade,
oz text,
kurztext text not null,
langtext text,
menge numeric(14, 4) not null default 1,
einheit text not null default 'St',
-- A28: normal, alternativ (zu einer Grundposition), eventual (ohne Gesamtbetrag), eventual_summe (einkalkuliert)
art text not null default 'normal' check (art in ('normal', 'alternativ', 'eventual', 'eventual_summe')),
grundposition_id uuid references angebot_position (id) on delete set null deferrable initially deferred,
-- fester Einheitspreis in Cent: Position ohne Kalkulation oder „Preis anpassen“ (A21)
ep_fest bigint check (ep_fest >= 0),
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index angebot_position_angebot on angebot_position (angebot_id);
create trigger angebot_position_protokoll before insert or update or delete on angebot_position
for each row execute function stempel_und_protokoll();
-- A2, A32, A33: Kostenzeilen je Einheit der Position
create table angebot_kosten (
id uuid primary key default gen_random_uuid(),
position_id uuid not null references angebot_position (id) on delete cascade,
kostenart text not null check (kostenart in ('lohn', 'material', 'geraet', 'sonstiges')),
lohnart text check (lohnart in ('planer', 'geselle', 'helfer')),
beschreibung text,
-- je Einheit der Position; bei Lohn Stunden
menge numeric(14, 4) not null default 1,
einheit text,
-- Cent je Einheit der Kostenzeile; bei Lohn leer = Stundensatz der Lohnart
ek bigint check (ek >= 0),
faktor numeric(8, 4) not null default 1 check (faktor > 0),
faktor_grund text,
-- leer = Standardzuschlag der Kostenart
zuschlag_prozent numeric(7, 2),
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index angebot_kosten_position on angebot_kosten (position_id);
create trigger angebot_kosten_protokoll before insert or update or delete on angebot_kosten
for each row execute function stempel_und_protokoll();

View File

@@ -98,6 +98,79 @@ export const TABELLEN: Tabelle[] = [
notiz: optText,
}),
},
// Stufe 3a: Angebote mit Kalkulation (A2, A19, A28, A32, A37); Status und Stände nur über eigene Routen
{
name: "angebot",
pfad: "angebote",
sortierung: "projekt_id, datum, nummer",
schema: z.object({
projekt_id: id,
nummer: text,
belegart: z.enum(["angebot", "kostenvoranschlag"]).optional(),
datum: datum.optional(),
bindefrist: datum.nullable().optional(),
betreff: optText,
kopftext: optText,
schlusstext: optText,
wagnis_prozent: z.number().min(0).max(50).optional(),
gewinn_prozent: z.number().min(0).max(50).optional(),
ausfall_prozent: z.number().min(0).max(50).optional(),
saetze: z.object({
stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(),
zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(),
stand: datum.optional(),
}).optional(),
notiz: optText,
reihenfolge: z.number().int().optional(),
}),
},
{
name: "angebot_titel",
pfad: "angebot-titel",
sortierung: "angebot_id, reihenfolge",
schema: z.object({
angebot_id: id,
oz: optText,
bezeichnung: text,
reihenfolge: z.number().int().optional(),
}),
},
{
name: "angebot_position",
pfad: "angebot-positionen",
sortierung: "angebot_id, reihenfolge",
schema: z.object({
angebot_id: id,
titel_id: id.nullable().optional(),
oz: optText,
kurztext: text,
langtext: optText,
menge: z.number().min(0).max(1e9).optional(),
einheit: text.optional(),
art: z.enum(["normal", "alternativ", "eventual", "eventual_summe"]).optional(),
grundposition_id: id.nullable().optional(),
ep_fest: cent.min(0).nullable().optional(),
reihenfolge: z.number().int().optional(),
}),
},
{
name: "angebot_kosten",
pfad: "angebot-kosten",
sortierung: "position_id, reihenfolge",
schema: z.object({
position_id: id,
kostenart: z.enum(["lohn", "material", "geraet", "sonstiges"]),
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
beschreibung: optText,
menge: z.number().min(0).max(1e9).optional(),
einheit: optText,
ek: cent.min(0).nullable().optional(),
faktor: z.number().positive().max(100).optional(),
faktor_grund: optText,
zuschlag_prozent: z.number().min(0).max(500).nullable().optional(),
reihenfolge: z.number().int().optional(),
}),
},
{
name: "abschnitt",
pfad: "abschnitte",