Angebote mit Kalkulation: Leistungsverzeichnis, Kostenzeilen, Versandprüfung, Annehmen macht den Auftrag (0.16.0)
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:
277
src/server/angebote.ts
Normal file
277
src/server/angebote.ts
Normal 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)) };
|
||||
});
|
||||
}
|
||||
@@ -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;
|
||||
});
|
||||
|
||||
|
||||
@@ -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>;
|
||||
|
||||
@@ -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,
|
||||
})),
|
||||
]);
|
||||
}
|
||||
|
||||
97
src/server/migrations/014_angebote.sql
Normal file
97
src/server/migrations/014_angebote.sql
Normal 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();
|
||||
@@ -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",
|
||||
|
||||
Reference in New Issue
Block a user