Stammdaten: Leistungen mit Ordnern und Vorkalkulation, GAEB- und DATANORM-Import, Material mit Rabatten, Angebot mit Reitern Leistungen/Material und KI-Vorschlag (0.18.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:
239
src/server/stammdaten.ts
Normal file
239
src/server/stammdaten.ts
Normal 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 });
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user