Neue Angebotsmaske: Mengenblatt mit Formeln, Musterpositionen und Mengenvorlagen im Katalog, Kostenzeilen mit Bezug, Subunternehmer (0.17.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:
@@ -7,7 +7,9 @@ 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 { 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, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsterArbeitstag } from "../domain/kalender.js";
|
||||
|
||||
@@ -16,17 +18,23 @@ 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">>;
|
||||
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen">>;
|
||||
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),
|
||||
mengen: { verschnitt: e.kalkulation.verschnitt, oeffnung_ab: e.kalkulation.oeffnungAb, ...(s.mengen ?? {}) },
|
||||
};
|
||||
}
|
||||
|
||||
@@ -110,22 +118,62 @@ async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void
|
||||
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];
|
||||
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(`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]);
|
||||
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])]);
|
||||
}
|
||||
|
||||
/** Alle Vorlagen: mitgelieferte und eigene */
|
||||
async function vorlagen(c: Pick<Pool, "query">): Promise<Mengenvorlage[]> {
|
||||
const eigene = (await c.query("select * from mengenvorlage order by gruppe, reihenfolge, name")).rows as Mengenvorlage[];
|
||||
return [...STANDARD_VORLAGEN, ...eigene.map((v) => ({ ...v, fest: false }))];
|
||||
}
|
||||
|
||||
/**
|
||||
* 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({}),
|
||||
});
|
||||
|
||||
export function registriereAngebote(
|
||||
app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>,
|
||||
nachProjekt: (p: Record<string, any>, wer: string) => Promise<Record<string, unknown>>,
|
||||
@@ -165,7 +213,7 @@ export function registriereAngebote(
|
||||
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];
|
||||
{ stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, 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;
|
||||
@@ -217,6 +265,85 @@ export function registriereAngebote(
|
||||
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);
|
||||
const menge = werteBlatt(vorlageBlatt, umg).menge ?? 1;
|
||||
const p = (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, langtext, menge, einheit, mit_kalkulation, mit_aufmass, aufmass)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, true, $9) returning id`,
|
||||
[id, ort.titel_id, ort.reihenfolge, v.kurztext || v.name, v.langtext || null, menge, v.einheit || "St", ansaetze.length > 0, vorlageBlatt])).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) => {
|
||||
@@ -245,8 +372,9 @@ export function registriereAngebote(
|
||||
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, x.ergebnis.stunden]);
|
||||
[pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.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;
|
||||
|
||||
@@ -57,11 +57,14 @@ export const EinstellungenSchema = z.object({
|
||||
.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) })
|
||||
.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), subunternehmer: 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),
|
||||
// Vorgaben der Mengenblätter (A22): Verschnitt in %, Öffnungen ab dieser Fläche abziehen (E28)
|
||||
verschnitt: z.number().min(0).max(100).default(10),
|
||||
oeffnungAb: z.number().min(0).max(100).default(2.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),
|
||||
|
||||
44
src/server/migrations/015_mengenblatt.sql
Normal file
44
src/server/migrations/015_mengenblatt.sql
Normal file
@@ -0,0 +1,44 @@
|
||||
-- Neue Angebotsmaske (Henning, 21.10.2026): Schalter Aufmaß und Kalkulation je Position, Mengenblatt mit Kürzeln,
|
||||
-- Kostenzeilen mit Bezug auf das Mengenblatt (Bezug × Ansatz × Personen), Subunternehmer als eigene Kostenart,
|
||||
-- Textzeilen im Leistungsverzeichnis und eigene Mengenvorlagen und Musterpositionen.
|
||||
|
||||
alter table angebot_position
|
||||
add column mit_kalkulation boolean not null default true,
|
||||
add column mit_aufmass boolean not null default false,
|
||||
add column aufmass jsonb,
|
||||
add column textzeile boolean not null default false,
|
||||
add column markiert boolean not null default false;
|
||||
-- bisher: ohne Kostenzeilen galt der feste Preis
|
||||
update angebot_position p set mit_kalkulation = exists (select 1 from angebot_kosten k where k.position_id = p.id);
|
||||
|
||||
alter table angebot_kosten drop constraint angebot_kosten_kostenart_check;
|
||||
alter table angebot_kosten add constraint angebot_kosten_kostenart_check
|
||||
check (kostenart in ('lohn', 'material', 'geraet', 'subunternehmer', 'sonstiges'));
|
||||
alter table angebot_kosten
|
||||
-- Kürzel oder Formel aus dem Mengenblatt; leer = Menge der Position (menge ist dann je Einheit)
|
||||
add column bezug text,
|
||||
add column personen numeric(8, 2) not null default 1 check (personen > 0),
|
||||
-- „notwendig“ wie in der Urkalk: abgewählte Zeilen bleiben sichtbar und zählen nicht
|
||||
add column aktiv boolean not null default true,
|
||||
-- beim Wechsel der Vorlage werden diese Zeilen ersetzt
|
||||
add column aus_vorlage boolean not null default false;
|
||||
|
||||
create table mengenvorlage (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
-- mengen: nur Mengenblatt; muster: Musterposition mit Texten und Kalkulation
|
||||
art text not null default 'mengen' check (art in ('mengen', 'muster')),
|
||||
gruppe text not null,
|
||||
name text not null,
|
||||
beschreibung text,
|
||||
kurztext text,
|
||||
langtext text,
|
||||
einheit text,
|
||||
-- Mengenblatt (Werte, Listen, Aufmaßzeilen, Menge) und Zeitansätze/Material
|
||||
inhalt jsonb not null default '{"werte": [], "listen": [], "zeilen": [], "ansaetze": []}',
|
||||
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 trigger mengenvorlage_protokoll before insert or update or delete on mengenvorlage
|
||||
for each row execute function stempel_und_protokoll();
|
||||
@@ -7,6 +7,35 @@ const id = z.uuid();
|
||||
const text = z.string().trim().min(1, "darf nicht leer sein");
|
||||
const optText = z.string().trim().nullable().optional();
|
||||
|
||||
// Mengenblatt (A22) als JSON: Werte, Listen, freie Aufmaßzeilen; Formeln bleiben Text, gerechnet wird beim Lesen
|
||||
const formel = z.string().max(500);
|
||||
const kurzeFormel = z.string().trim().max(500);
|
||||
const kuerzel = z.string().trim().max(40);
|
||||
const blatt = z.object({
|
||||
vorlage: z.object({ id: z.string().max(80), name: z.string().max(200) }).nullable().optional(),
|
||||
werte: z.array(z.object({ kz: kuerzel, bez: z.string().max(200).nullable().optional(), einheit: z.string().max(20).nullable().optional(), formel, eingabe: z.boolean().optional() })).max(300),
|
||||
listen: z.array(z.object({
|
||||
kz: kuerzel, name: z.string().max(200).nullable().optional(),
|
||||
spalten: z.array(z.object({ kz: kuerzel, bez: z.string().max(200).nullable().optional(), einheit: z.string().max(20).nullable().optional(), art: z.enum(["text", "zahl"]).optional(), formel: formel.nullable().optional() })).max(20),
|
||||
zeilen: z.array(z.record(z.string().max(40), z.string().max(500))).max(500),
|
||||
})).max(20),
|
||||
zeilen: z.array(z.object({ text: z.string().max(300).nullable().optional(), formel })).max(500),
|
||||
menge: kurzeFormel.nullable().optional(),
|
||||
});
|
||||
// Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position
|
||||
const ansatz = z.object({
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "subunternehmer", "sonstiges"]),
|
||||
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
|
||||
beschreibung: z.string().max(300).nullable().optional(),
|
||||
bezug: kurzeFormel.nullable().optional(),
|
||||
menge: z.number().min(0).max(1e9),
|
||||
personen: z.number().positive().max(50).optional(),
|
||||
einheit: z.string().max(20).nullable().optional(),
|
||||
ek: z.number().int().min(0).nullable().optional(),
|
||||
faktor: z.number().positive().max(100).optional(),
|
||||
aktiv: z.boolean().optional(),
|
||||
});
|
||||
|
||||
export interface Tabelle {
|
||||
name: string;
|
||||
pfad: string;
|
||||
@@ -117,7 +146,8 @@ export const TABELLEN: Tabelle[] = [
|
||||
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(),
|
||||
zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), subunternehmer: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(),
|
||||
mengen: z.object({ verschnitt: z.number().min(0).max(100), oeffnung_ab: z.number().min(0).max(100) }).partial().optional(),
|
||||
stand: datum.optional(),
|
||||
}).optional(),
|
||||
notiz: optText,
|
||||
@@ -150,6 +180,11 @@ export const TABELLEN: Tabelle[] = [
|
||||
art: z.enum(["normal", "alternativ", "eventual", "eventual_summe"]).optional(),
|
||||
grundposition_id: id.nullable().optional(),
|
||||
ep_fest: cent.min(0).nullable().optional(),
|
||||
mit_kalkulation: z.boolean().optional(),
|
||||
mit_aufmass: z.boolean().optional(),
|
||||
aufmass: blatt.nullable().optional(),
|
||||
textzeile: z.boolean().optional(),
|
||||
markiert: z.boolean().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
@@ -159,7 +194,7 @@ export const TABELLEN: Tabelle[] = [
|
||||
sortierung: "position_id, reihenfolge",
|
||||
schema: z.object({
|
||||
position_id: id,
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "sonstiges"]),
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "subunternehmer", "sonstiges"]),
|
||||
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
|
||||
beschreibung: optText,
|
||||
menge: z.number().min(0).max(1e9).optional(),
|
||||
@@ -168,6 +203,27 @@ export const TABELLEN: Tabelle[] = [
|
||||
faktor: z.number().positive().max(100).optional(),
|
||||
faktor_grund: optText,
|
||||
zuschlag_prozent: z.number().min(0).max(500).nullable().optional(),
|
||||
bezug: kurzeFormel.nullable().optional(),
|
||||
personen: z.number().positive().max(50).optional(),
|
||||
aktiv: z.boolean().optional(),
|
||||
aus_vorlage: z.boolean().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
// Mengenvorlagen und Musterpositionen (A23): eigene; die mitgelieferten stehen im Programm (domain/mengenvorlagen.ts)
|
||||
{
|
||||
name: "mengenvorlage",
|
||||
pfad: "mengenvorlagen",
|
||||
sortierung: "gruppe, reihenfolge, name",
|
||||
schema: z.object({
|
||||
art: z.enum(["mengen", "muster"]),
|
||||
gruppe: text,
|
||||
name: text,
|
||||
beschreibung: optText,
|
||||
kurztext: optText,
|
||||
langtext: optText,
|
||||
einheit: optText,
|
||||
inhalt: blatt.extend({ ansaetze: z.array(ansatz).max(100).default([]) }),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
|
||||
Reference in New Issue
Block a user