Files
Betriebsf-hrungssoftware/src/server/stammdaten.ts
Claude 1c42265a28
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
+ Dokument mit Belegkette und GAEB-Import X/P/D 81–86 (0.28.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-22 08:00:31 +00:00

241 lines
17 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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 { aktuelleSaetze } from "./stundensaetze.js";
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 { leseGaebDatei } 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(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
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(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
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 = leseGaebDatei(q.text, q.dateiname); } 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(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
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 });
});
}