Stammdaten: Leistungen mit Ordnern und Vorkalkulation, GAEB- und DATANORM-Import, Material mit Rabatten, Angebot mit Reitern Leistungen/Material und KI-Vorschlag (0.18.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-21 16:02:01 +00:00
parent 1190a06bd8
commit e748adc76f
26 changed files with 2374 additions and 103 deletions

239
src/server/stammdaten.ts Normal file
View File

@@ -0,0 +1,239 @@
// Stammdaten (Henning, 21.10.2026): Leistungen mit Vorkalkulation, GAEB-Import in Ordner, Materialstamm mit
// DATANORM-Import und Rabatten je Lieferant. Siehe Entwürfe 1–4 in stammdaten/entwurf.
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { werName } from "./anmeldung.js";
import { artikelNach, nurLeistungen, rechneLeistung, stammSaetze, vorlagen } from "./leistungen-daten.js";
import { leseGaeb } from "../domain/gaeb.js";
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
const IdParam = z.object({ id: z.string().min(1).max(80) });
const leeresInhalt = { werte: [], listen: [], zeilen: [], menge: null, ansaetze: [] };
const ArtikelImport = z.object({
artikelnummer: z.string().trim().min(1).max(60),
bezeichnung: z.string().trim().min(1).max(500),
langtext: z.string().max(5000).nullable().optional(),
einheit: z.string().max(20).nullable().optional(),
preiseinheit: z.union([z.literal(1), z.literal(10), z.literal(100), z.literal(1000)]).default(1),
preisart: z.enum(["brutto", "netto"]).default("brutto"),
listenpreis: z.number().int().min(0).nullable().optional(),
rabattgruppe: z.string().max(40).nullable().optional(),
warengruppe: z.string().max(100).nullable().optional(),
ean: z.string().max(20).nullable().optional(),
loeschen: z.boolean().optional(),
});
const ImportSchema = z.object({
lieferant: z.string().trim().min(1).max(100),
stand: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
artikel: z.array(ArtikelImport).max(5000).default([]),
preise: z.array(z.object({ artikelnummer: z.string().trim().min(1).max(60), preisart: z.enum(["brutto", "netto"]), preis: z.number().int().min(0), rabatt: z.number().min(0).max(100).nullable() })).max(20000).default([]),
rabatte: z.array(z.object({ rabattgruppe: z.string().trim().min(1).max(40), rabatt: z.number().min(0).max(100), bezeichnung: z.string().max(200).nullable().optional() })).max(5000).default([]),
});
export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>): void {
const wer = (req: FastifyRequest) => werName(req);
/** Leistungen mit Kosten, VK und Stunden je Einheit (Liste und Katalog im Angebot) */
app.get("/api/leistungen", async () => {
const s = stammSaetze(await einstellungen());
return nurLeistungen(await vorlagen(pool)).map((v) => {
const r = rechneLeistung(v, s);
return {
id: v.id, gruppe: v.gruppe, name: v.name, nummer: v.nummer ?? null, kurztext: v.kurztext || v.name, langtext: v.langtext ?? "", einheit: v.einheit ?? "",
herkunft: v.fest ? "mitgeliefert" : v.herkunft ?? "eigen", fest: !!v.fest, ep_fest: v.ep_fest == null ? null : Number(v.ep_fest),
geaendert_am: v.geaendert_am ?? null, quelle: v.quelle ?? null, zeilen: (v.inhalt.ansaetze ?? []).length,
mit_blatt: v.inhalt.werte.length > 0 || v.inhalt.listen.length > 0,
kosten: r.kosten_je_einheit, ep: r.ep, ep_kalkuliert: r.ep_kalkuliert, std: r.std_je_einheit,
};
});
});
/** eine Leistung mit Vorkalkulation, Artikeln der Kostenzeilen und Verwendung in Angeboten */
app.get("/api/leistungen/:id", async (req, reply) => {
const { id } = IdParam.parse(req.params);
const v = (await vorlagen(pool)).find((x) => String(x.id) === id);
if (!v) return reply.status(404).send({ fehler: "Diese Leistung gibt es nicht (mehr)." });
const s = stammSaetze(await einstellungen());
const artikel = Object.fromEntries(await artikelNach(pool, (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x)));
const angebote = (await pool.query(`select a.id, a.nummer, a.datum from angebot_position p join angebot a on a.id = p.angebot_id
where p.aufmass -> 'vorlage' ->> 'id' = $1 order by a.datum desc, a.nummer desc`, [id])).rows;
return { leistung: v, ergebnis: rechneLeistung(v, s), saetze: s, artikel, angebote };
});
/** GAEB-Datei (Text schon dekodiert) → Leistungen in Ordnern nach den Titeln. Erneutes Einlesen aktualisiert Texte. */
app.post("/api/leistungen/gaeb", async (req, reply) => {
const q = z.object({ dateiname: z.string().trim().min(1).max(200), text: z.string().min(1).max(30_000_000), ordner: z.string().trim().max(200).optional() }).parse(req.body ?? {});
let lv;
try { lv = leseGaeb(q.text); } catch (e) { return reply.status(400).send({ fehler: (e as Error).message }); }
const r = await transaktion(pool, wer(req), async (c) => {
const da = (await c.query("select id, nummer, gruppe from mengenvorlage where art = 'muster' and herkunft = 'gaeb'")).rows;
const nach = new Map(da.map((x) => [`${x.gruppe}|${x.nummer}`, x.id as string]));
let neu = 0, aktualisiert = 0;
for (const [i, p] of lv.positionen.entries()) {
const gruppe = [q.ordner, p.ordner || lv.name].filter(Boolean).join(" / ") || "GAEB";
const alt = nach.get(`${gruppe}|${p.oz}`);
if (alt) {
await c.query(`update mengenvorlage set name = $2, kurztext = $2, langtext = $3, einheit = $4, ep_fest = coalesce($5, ep_fest), quelle = $6 where id = $1`,
[alt, p.kurztext, p.langtext || null, p.einheit || null, p.ep, q.dateiname]);
aktualisiert++;
} else {
await c.query(`insert into mengenvorlage (art, gruppe, name, kurztext, langtext, einheit, inhalt, nummer, herkunft, ep_fest, quelle, reihenfolge)
values ('muster', $1, $2, $2, $3, $4, $5, $6, 'gaeb', $7, $8, $9)`,
[gruppe, p.kurztext, p.langtext || null, p.einheit || null, leeresInhalt, p.oz, p.ep, q.dateiname, i]);
neu++;
}
}
return { neu, aktualisiert, name: lv.name, titel: lv.titel, mit_preis: lv.positionen.filter((p) => p.ep !== null).length };
});
return reply.status(201).send(r);
});
/** Auswahl in der Liste: verschieben, kopieren, löschen, Preis um x % ändern */
app.post("/api/leistungen/aktion", async (req) => {
const q = z.object({
ids: z.array(z.string().min(1).max(80)).min(1).max(5000),
aktion: z.enum(["verschieben", "kopieren", "loeschen", "preis"]),
ordner: z.string().trim().min(1).max(300).optional(),
prozent: z.number().min(-90).max(500).optional(),
}).parse(req.body ?? {});
const s = stammSaetze(await einstellungen());
const alle = new Map((await vorlagen(pool)).map((v) => [String(v.id), v]));
const gewaehlt = q.ids.map((i) => alle.get(i)).filter((v): v is Mengenvorlage => !!v);
const eigene = gewaehlt.filter((v) => !v.fest);
return transaktion(pool, wer(req), async (c) => {
let n = 0;
if (q.aktion === "kopieren" || (q.aktion !== "loeschen" && gewaehlt.some((v) => v.fest))) {
// mitgelieferte werden beim Ändern zu eigenen Kopien
for (const v of q.aktion === "kopieren" ? gewaehlt : gewaehlt.filter((x) => x.fest)) {
const kopie = (await c.query(`insert into mengenvorlage (art, gruppe, name, beschreibung, kurztext, langtext, einheit, inhalt, nummer, herkunft, ep_fest, quelle)
values ('muster', $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning *`,
[v.gruppe, q.aktion === "kopieren" && !v.fest ? `${v.name} (Kopie)` : v.name, v.beschreibung ?? null, q.aktion === "kopieren" && !v.fest ? `${v.kurztext || v.name} (Kopie)` : v.kurztext ?? null,
v.langtext ?? null, v.einheit ?? null, { ...v.inhalt, ansaetze: (v.inhalt.ansaetze ?? []).map((z) => (z.artikel_id ? { ...z, ek: null } : z)) },
v.nummer ?? null, v.herkunft ?? "eigen", v.ep_fest ?? null, v.quelle ?? null])).rows[0];
if (q.aktion !== "kopieren") eigene.push({ ...kopie, fest: false });
n++;
}
if (q.aktion === "kopieren") return { anzahl: n };
}
if (q.aktion === "loeschen") {
const r = await c.query("delete from mengenvorlage where id = any($1::uuid[])", [eigene.map((v) => v.id)]);
return { anzahl: r.rowCount ?? 0, uebersprungen: gewaehlt.length - eigene.length };
}
if (q.aktion === "verschieben") {
if (!q.ordner) throw new Error("Ordner fehlt");
const r = await c.query("update mengenvorlage set gruppe = $2 where id = any($1::uuid[])", [eigene.map((v) => v.id), q.ordner]);
return { anzahl: r.rowCount ?? 0 };
}
const f = 1 + (q.prozent ?? 0) / 100;
for (const v of eigene) {
const ep = rechneLeistung(v, s).ep;
await c.query("update mengenvorlage set ep_fest = $2 where id = $1", [v.id, Math.max(0, Math.round(ep * f))]);
n++;
}
return { anzahl: n };
});
});
// ---------- Materialstamm ----------
/** Lieferanten, Warengruppen und Merkliste mit Anzahl (linke Spalte der Seite Material) */
app.get("/api/artikel-uebersicht", async () => {
const [l, w, m, g] = await Promise.all([
pool.query("select lieferant, count(*)::int as anzahl, max(stand) as stand from artikel group by lieferant order by lieferant = '', lieferant"),
pool.query("select coalesce(warengruppe, '') as warengruppe, count(*)::int as anzahl from artikel group by 1 order by 1"),
pool.query("select count(*)::int as n from artikel where merkliste"),
pool.query("select count(*)::int as n from artikel"),
]);
const rabatte = (await pool.query("select * from lieferant_rabatt order by lieferant, rabattgruppe")).rows.map((r) => ({ ...r, rabatt: Number(r.rabatt) }));
return { lieferanten: l.rows, warengruppen: w.rows, merkliste: m.rows[0].n, gesamt: g.rows[0].n, rabatte };
});
/** Artikel suchen: Text in Bezeichnung, Nummer, EAN; höchstens limit Treffer, dazu die Gesamtzahl */
app.get("/api/artikel-suche", async (req) => {
const q = z.object({
q: z.string().max(200).default(""), lieferant: z.string().max(100).optional(), warengruppe: z.string().max(100).optional(),
merkliste: z.enum(["1", "0"]).optional(), limit: z.coerce.number().int().min(1).max(2000).default(500),
}).parse(req.query);
const wo: string[] = [], werte: unknown[] = [];
for (const wort of q.q.trim().split(/\s+/).filter(Boolean).slice(0, 6)) {
werte.push(`%${wort.replace(/[%_\\]/g, (x) => `\\${x}`)}%`);
wo.push(`(bezeichnung ilike $${werte.length} or artikelnummer ilike $${werte.length} or coalesce(ean, '') ilike $${werte.length} or coalesce(warengruppe, '') ilike $${werte.length})`);
}
if (q.lieferant !== undefined) { werte.push(q.lieferant); wo.push(`lieferant = $${werte.length}`); }
if (q.warengruppe !== undefined) { werte.push(q.warengruppe); wo.push(`coalesce(warengruppe, '') = $${werte.length}`); }
if (q.merkliste === "1") wo.push("merkliste");
const bed = wo.length ? `where ${wo.join(" and ")}` : "";
const anzahl = (await pool.query(`select count(*)::int as n from artikel ${bed}`, werte)).rows[0].n;
werte.push(q.limit);
const zeilen = (await pool.query(`select a.*, (select r.rabatt from lieferant_rabatt r where r.lieferant = a.lieferant and r.rabattgruppe = a.rabattgruppe) as gruppen_rabatt
from artikel a ${bed} order by merkliste desc, lieferant, bezeichnung limit $${werte.length}`, werte)).rows;
return { anzahl, zeilen };
});
app.get("/api/artikel/:id/genutzt", async (req) => {
const { id } = IdParam.parse(req.params);
const r = await pool.query(`select id, name from mengenvorlage where inhalt -> 'ansaetze' @> $1::jsonb order by name`, [JSON.stringify([{ artikel_id: id }])]);
return r.rows;
});
/** DATANORM-Import in Paketen: Rabatte, Artikel (neu oder geändert, L = löschen) und Preisänderungen eines Lieferanten */
app.post("/api/artikel/import", async (req) => {
const q = ImportSchema.parse(req.body ?? {});
return transaktion(pool, wer(req), async (c) => {
for (const r of q.rabatte) {
await c.query(`insert into lieferant_rabatt (lieferant, rabattgruppe, rabatt, bezeichnung) values ($1, $2, $3, $4)
on conflict (lieferant, rabattgruppe) do update set rabatt = excluded.rabatt, bezeichnung = coalesce(excluded.bezeichnung, lieferant_rabatt.bezeichnung)`,
[q.lieferant, r.rabattgruppe, r.rabatt, r.bezeichnung ?? null]);
}
// EK der vorhandenen Artikel mit den neuen Rabatten neu rechnen (Trigger artikel_ek)
if (q.rabatte.length) await c.query("update artikel set rabattgruppe = rabattgruppe where lieferant = $1 and rabattgruppe = any($2)", [q.lieferant, q.rabatte.map((r) => r.rabattgruppe)]);
const weg = q.artikel.filter((a) => a.loeschen).map((a) => a.artikelnummer);
const bleiben = q.artikel.filter((a) => !a.loeschen);
const vorher = new Map((await c.query("select artikelnummer, listenpreis from artikel where lieferant = $1 and artikelnummer = any($2)",
[q.lieferant, [...bleiben.map((a) => a.artikelnummer), ...q.preise.map((p) => p.artikelnummer)]])).rows.map((r) => [r.artikelnummer, r.listenpreis === null ? null : Number(r.listenpreis)]));
let neu = 0, geaendert = 0, neuerPreis = 0;
for (let i = 0; i < bleiben.length; i += 500) {
const paket = bleiben.slice(i, i + 500);
await c.query(`insert into artikel (lieferant, artikelnummer, bezeichnung, langtext, einheit, preiseinheit, preisart, listenpreis, rabattgruppe, warengruppe, ean, herkunft, stand)
select $1, x.artikelnummer, x.bezeichnung, x.langtext, x.einheit, x.preiseinheit, x.preisart, x.listenpreis, x.rabattgruppe, x.warengruppe, x.ean, 'datanorm', $3
from json_to_recordset($2::json) as x(artikelnummer text, bezeichnung text, langtext text, einheit text, preiseinheit int, preisart text, listenpreis bigint, rabattgruppe text, warengruppe text, ean text)
on conflict (lieferant, artikelnummer) where artikelnummer <> '' do update set bezeichnung = excluded.bezeichnung, langtext = coalesce(excluded.langtext, artikel.langtext),
einheit = excluded.einheit, preiseinheit = excluded.preiseinheit, preisart = excluded.preisart, listenpreis = coalesce(excluded.listenpreis, artikel.listenpreis),
rabattgruppe = excluded.rabattgruppe, warengruppe = coalesce(excluded.warengruppe, artikel.warengruppe), ean = coalesce(excluded.ean, artikel.ean),
herkunft = 'datanorm', stand = coalesce(excluded.stand, artikel.stand)`,
[q.lieferant, JSON.stringify(paket), q.stand ?? null]);
}
for (const a of bleiben) {
if (!vorher.has(a.artikelnummer)) neu++;
else { geaendert++; if (a.listenpreis != null && vorher.get(a.artikelnummer) !== a.listenpreis) neuerPreis++; }
}
for (const p of q.preise) {
const r = await c.query(`update artikel set listenpreis = $3, preisart = $4, rabatt = coalesce($5, rabatt), stand = coalesce($6, stand) where lieferant = $1 and artikelnummer = $2`,
[q.lieferant, p.artikelnummer, p.preis, p.preisart, p.rabatt, q.stand ?? null]);
if (r.rowCount && vorher.get(p.artikelnummer) !== p.preis) neuerPreis++;
}
const geloescht = weg.length ? (await c.query("delete from artikel where lieferant = $1 and artikelnummer = any($2)", [q.lieferant, weg])).rowCount ?? 0 : 0;
return { neu, geaendert, neuer_preis: neuerPreis, geloescht, rabatte: q.rabatte.length };
});
});
/** Rabatt einer Rabattgruppe von Hand; die Artikel der Gruppe rechnen ihren EK neu */
app.post("/api/lieferanten-rabatte/setzen", async (req) => {
const q = z.object({ lieferant: z.string().trim().min(1).max(100), rabattgruppe: z.string().trim().min(1).max(40), rabatt: z.number().min(0).max(100).nullable() }).parse(req.body ?? {});
return transaktion(pool, wer(req), async (c) => {
if (q.rabatt === null) await c.query("delete from lieferant_rabatt where lieferant = $1 and rabattgruppe = $2", [q.lieferant, q.rabattgruppe]);
else await c.query(`insert into lieferant_rabatt (lieferant, rabattgruppe, rabatt) values ($1, $2, $3)
on conflict (lieferant, rabattgruppe) do update set rabatt = excluded.rabatt`, [q.lieferant, q.rabattgruppe, q.rabatt]);
const r = await c.query("update artikel set rabattgruppe = rabattgruppe where lieferant = $1 and rabattgruppe = $2", [q.lieferant, q.rabattgruppe]);
return { artikel: r.rowCount ?? 0 };
});
});
/** KI-Vorschlag: in der Testversion fragt der Browser Claude; auf dem Server kommt das mit eigenem Zugang später */
app.post("/api/ki", async () => {
throw Object.assign(new Error("Der KI-Vorschlag ist auf dem Server noch nicht eingerichtet. In der Testversion geht er schon."), { statusCode: 409 });
});
}