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

View File

@@ -9,7 +9,8 @@ import { mitNeuplanung } from "./terminplan.js";
import { werName } from "./anmeldung.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 type { Mengenvorlage } from "../domain/mengenvorlagen.js";
import { hatBlatt, vorlagen } from "./leistungen-daten.js";
import { plusTage } from "../domain/datum.js";
import { naechsterArbeitstag } from "../domain/kalender.js";
@@ -130,11 +131,6 @@ async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void
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“):
@@ -173,6 +169,8 @@ const EinfuegenSchema = z.object({
position_id: z.uuid().optional(),
/** Eingaben der Vorlage, beim Einfügen abgefragt */
eingaben: z.record(z.string().max(40), z.string().max(500)).default({}),
/** Menge statt der aus dem Mengenblatt (KI-Vorschlag) */
menge: z.number().min(0).max(1e9).optional(),
});
export function registriereAngebote(
@@ -311,10 +309,13 @@ export function registriereAngebote(
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];
// Leistungen aus GAEB haben oft kein Mengenblatt: dann zählt die eingetragene Menge; das Blatt merkt sich die Herkunft
const mitBlatt = hatBlatt(vorlageBlatt);
const menge = q.menge ?? (mitBlatt ? werteBlatt(vorlageBlatt, umg).menge ?? 1 : 1);
const p = (await c.query(`insert into angebot_position (angebot_id, titel_id, reihenfolge, kurztext, langtext, menge, einheit, mit_kalkulation, mit_aufmass, aufmass, ep_fest)
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning id`,
[id, ort.titel_id, ort.reihenfolge, v.kurztext || v.name, v.langtext || null, menge, v.einheit || "St", ansaetze.length > 0, mitBlatt && q.menge === undefined, vorlageBlatt,
v.ep_fest === null || v.ep_fest === undefined || v.ep_fest === "" ? null : Number(v.ep_fest)])).rows[0];
await ansaetzeEinfuegen(c, p.id, ansaetze, 0);
return p;
});

View File

@@ -26,6 +26,7 @@ import { registriereZeiten } from "./zeiten.js";
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js";
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
import { registriereStammdaten } from "./stammdaten.js";
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
import { formatDatum, plusTage } from "../domain/datum.js";
@@ -93,6 +94,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
}
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
registriereStammdaten(app, pool, ladeEinstellungen);
app.post("/api/projekte/:id/ordner", async (req, reply) => {
const { id } = IdParam.parse(req.params);

View File

@@ -0,0 +1,67 @@
// Leistungen und Mengenvorlagen aus Programm und Datenbank, mit den aktuellen Artikelpreisen aus dem Materialstamm.
// Eine Kostenzeile mit Artikel nimmt immer den EK des Artikels: neue Preise rechnen die Leistungen neu,
// Angebote behalten ihre Preise, weil die Kostenzeilen dort beim Einfügen festgeschrieben werden.
import type { Pool } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js";
import { type KKosten, type PositionErgebnis, type Saetze, berechnePosition, umgebungVon } from "../domain/kalkulation.js";
import { type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
import { ekJeEinheit } from "../domain/datanorm.js";
export interface ArtikelKurz { id: string; lieferant: string; artikelnummer: string; bezeichnung: string; einheit: string | null; ek: number | null; ek_je_einheit: number | null; preiseinheit: number; herkunft: string; stand: string | null }
/** Alle Vorlagen: mitgelieferte und eigene; Artikel-EK eingesetzt */
export 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[];
const alle = [...STANDARD_VORLAGEN, ...eigene.map((v) => ({ ...v, fest: false }))];
const ids = [...new Set(alle.flatMap((v) => (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x)))];
if (!ids.length) return alle;
const art = await artikelNach(c, ids);
return alle.map((v) => ({
...v,
inhalt: { ...v.inhalt, ansaetze: (v.inhalt.ansaetze ?? []).map((z) => {
const a = z.artikel_id ? art.get(z.artikel_id) : undefined;
return a ? { ...z, ek: a.ek_je_einheit ?? z.ek ?? null, einheit: z.einheit || a.einheit } : z;
}) },
}));
}
export async function artikelNach(c: Pick<Pool, "query">, ids: string[]): Promise<Map<string, ArtikelKurz>> {
if (!ids.length) return new Map();
const r = await c.query("select id, lieferant, artikelnummer, bezeichnung, einheit, ek, preiseinheit, herkunft, stand from artikel where id = any($1::uuid[])", [ids]);
return new Map(r.rows.map((a) => [a.id, { ...a, ek: a.ek === null ? null : Number(a.ek), preiseinheit: Number(a.preiseinheit), ek_je_einheit: ekJeEinheit(a) }]));
}
/** Sätze der Stammdaten: Vorgaben der Angebote aus den Einstellungen */
export function stammSaetze(e: Einstellungen): Saetze {
const k = e.kalkulation;
return {
stundensaetze: { ...k.stundensaetze }, zuschlaege: { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall,
mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz,
};
}
export const hatBlatt = (b: Blatt) => b.werte.length > 0 || b.listen.length > 0 || b.zeilen.length > 0 || !!b.menge?.trim();
/** Vorkalkulation einer Leistung wie eine Position im Angebot: Menge aus dem Mengenblatt, sonst 1 */
export function rechneLeistung(v: Mengenvorlage, s: Saetze): PositionErgebnis {
const { ansaetze = [], ...rest } = v.inhalt;
const blatt = alsBlatt(rest);
const mitBlatt = hatBlatt(blatt);
let menge = 1;
if (mitBlatt) { try { menge = werteBlatt(blatt, umgebungVon(s)).menge ?? 1; } catch { menge = 1; } }
const kosten: KKosten[] = ansaetze.map((z, i) => ({
id: String(i), position_id: v.id, kostenart: z.kostenart, lohnart: z.lohnart ?? null, beschreibung: z.beschreibung ?? null, menge: z.menge,
einheit: z.einheit ?? null, ek: z.ek ?? null, faktor: z.faktor ?? 1, bezug: z.bezug ?? null, personen: z.personen ?? 1, aktiv: z.aktiv ?? true, reihenfolge: i,
}));
return berechnePosition({
id: v.id, kurztext: v.kurztext || v.name, menge: menge || 1, einheit: v.einheit || "St", ep_fest: v.ep_fest ?? null,
mit_kalkulation: ansaetze.length > 0, mit_aufmass: mitBlatt, aufmass: mitBlatt ? blatt : null,
}, kosten, s);
}
/** Leistungen für Liste und Katalog: eine geänderte Kopie ersetzt die mitgelieferte mit gleichem Namen */
export function nurLeistungen(alle: Mengenvorlage[]): Mengenvorlage[] {
const eigene = new Set(alle.filter((v) => !v.fest).map((v) => `${v.gruppe}|${v.name}`));
return alle.filter((v) => v.art === "muster" && !(v.fest && eigene.has(`${v.gruppe}|${v.name}`)));
}

View File

@@ -0,0 +1,119 @@
-- Stammdaten (Henning, 21.10.2026): Leistungen mit Ordnern aus GAEB oder selbst angelegt, Materialstamm aus
-- DATANORM mit Rabatten je Lieferant. Leistungen sind die bisherigen Musterpositionen (mengenvorlage, art 'muster'),
-- damit nichts doppelt existiert; der Ordner steht in „gruppe“ als Pfad mit „ / “.
-- Beim Einspielen einer Sicherung bleiben Zeitstempel erhalten und es entsteht kein Protokoll
create or replace function stempel_und_protokoll() returns trigger language plpgsql as $$
declare
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
begin
if current_setting('betrieb.einspielen', true) = 'ja' then
if tg_op = 'DELETE' then return old; end if;
new.angelegt_am := coalesce(new.angelegt_am, now());
new.geaendert_am := coalesce(new.geaendert_am, now());
new.geaendert_von := coalesce(new.geaendert_von, wer);
return new;
end if;
if tg_op = 'DELETE' then
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
return old;
end if;
new.geaendert_am := now();
new.geaendert_von := wer;
if tg_op = 'INSERT' then
new.angelegt_am := now();
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
else
new.angelegt_am := old.angelegt_am;
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
end if;
return new;
end $$;
-- Artikel ändern sich zu Tausenden mit jeder Preisliste: nur Zeitstempel, kein Protokoll
create function nur_stempel() returns trigger language plpgsql as $$
begin
if current_setting('betrieb.einspielen', true) = 'ja' then
new.angelegt_am := coalesce(new.angelegt_am, now());
new.geaendert_am := coalesce(new.geaendert_am, now());
return new;
end if;
new.geaendert_am := now();
if tg_op = 'INSERT' then new.angelegt_am := now(); else new.angelegt_am := old.angelegt_am; end if;
return new;
end $$;
alter table mengenvorlage
-- OZ aus der GAEB-Datei oder eigene Nummer
add column nummer text,
add column herkunft text not null default 'eigen' check (herkunft in ('eigen', 'gaeb', 'plancraft')),
-- „Preis festlegen auf“ (Cent je Einheit); ohne Kalkulation der feste Preis
add column ep_fest bigint check (ep_fest >= 0),
-- Dateiname des Imports
add column quelle text,
add column notiz text;
create table artikel (
id uuid primary key default gen_random_uuid(),
-- leer = eigener Artikel ohne Lieferant
lieferant text not null default '',
artikelnummer text not null default '',
bezeichnung text not null,
langtext text,
warengruppe text,
rabattgruppe text,
ean text,
einheit text,
-- Preis gilt je 1, 10, 100 oder 1000 Einheiten
preiseinheit integer not null default 1 check (preiseinheit in (1, 10, 100, 1000)),
-- brutto: Listenpreis, Rabatt wird abgezogen; netto: Preis ist schon der EK
preisart text not null default 'brutto' check (preisart in ('brutto', 'netto')),
-- Cent je Preiseinheit
listenpreis bigint check (listenpreis >= 0),
-- eigener Rabatt in %, sonst der Rabatt der Rabattgruppe des Lieferanten
rabatt numeric(5, 2) check (rabatt >= 0 and rabatt <= 100),
-- EK netto in Cent je Preiseinheit, aus Listenpreis und Rabatt gerechnet
ek bigint check (ek >= 0),
ek_vorher bigint,
herkunft text not null default 'eigen' check (herkunft in ('eigen', 'datanorm')),
-- Datum der Preisliste
stand date,
merkliste boolean not null default false,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now()
);
create unique index artikel_nummer on artikel (lieferant, artikelnummer) where artikelnummer <> '';
create index artikel_warengruppe on artikel (lieferant, warengruppe);
create trigger artikel_stempel before insert or update on artikel for each row execute function nur_stempel();
-- EK netto aus Listenpreis und Rabatt (eigener Rabatt, sonst der der Rabattgruppe); der alte EK bleibt zum Vergleich
create function artikel_ek() returns trigger language plpgsql as $$
begin
if current_setting('betrieb.einspielen', true) = 'ja' then return new; end if;
if new.listenpreis is not null then
new.ek := case when new.preisart = 'netto' then new.listenpreis
else round(new.listenpreis * (1 - coalesce(new.rabatt,
(select r.rabatt from lieferant_rabatt r where r.lieferant = new.lieferant and r.rabattgruppe = new.rabattgruppe), 0) / 100)) end;
end if;
if tg_op = 'UPDATE' and new.ek is distinct from old.ek then new.ek_vorher := old.ek; end if;
return new;
end $$;
-- Rabatte je Lieferant und Rabattgruppe (DATANORM .RAB oder von Hand)
create table lieferant_rabatt (
id uuid primary key default gen_random_uuid(),
lieferant text not null,
rabattgruppe text not null,
bezeichnung text,
rabatt numeric(5, 2) not null check (rabatt >= 0 and rabatt <= 100),
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system',
unique (lieferant, rabattgruppe)
);
create trigger lieferant_rabatt_protokoll before insert or update or delete on lieferant_rabatt
for each row execute function stempel_und_protokoll();
create trigger artikel_ek before insert or update on artikel for each row execute function artikel_ek();

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 });
});
}

View File

@@ -26,6 +26,8 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
if (Number(belegt.rows[0]!.n) > 0) throw new NichtLeer("Eine Sicherung lässt sich nur in ein leeres Programm einspielen.");
const anzahl: Record<string, number> = {};
// Zeitstempel aus der Sicherung behalten, kein Protokoll (Migration 017)
await c.query("select set_config('betrieb.einspielen', 'ja', true)");
// TABELLEN steht in der Reihenfolge der Fremdschlüssel, NUR_SICHERUNG hängt an ihnen
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) {
const zeilen = s.daten[t.pfad] ?? [];
@@ -33,11 +35,20 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
// so passt eine ältere Sicherung auch nach einer Migration
const vorhanden = new Set((await c.query<{ column_name: string }>(
"select column_name from information_schema.columns where table_schema = current_schema() and table_name = $1", [t.name])).rows.map((r) => r.column_name));
// gleich aufgebaute Zeilen zu Hunderten auf einmal (der Materialstamm hat schnell 20.000 Artikel)
const pakete = new Map<string, Record<string, unknown>[]>();
for (const zeile of zeilen) {
// T15: Vorgänge aus einer Sicherung von vor 0.12 behalten ihre Dauer
const z = t.name === "vorgang" && !("dauer_fest" in zeile) ? { ...zeile, dauer_fest: true } : zeile;
const spalten = Object.keys(z).filter((k) => vorhanden.has(k)).join(", ");
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_record(null::${t.name}, $1::json)`, [JSON.stringify(z)]);
const paket = pakete.get(spalten) ?? [];
paket.push(z);
pakete.set(spalten, paket);
}
for (const [spalten, paket] of pakete) {
for (let i = 0; i < paket.length; i += 500) {
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_recordset(null::${t.name}, $1::json)`, [JSON.stringify(paket.slice(i, i + 500))]);
}
}
anzahl[t.pfad] = zeilen.length;
}
@@ -46,6 +57,7 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
if (s.einstellungen !== undefined) {
await c.query("update einstellungen set daten = $1", [EinstellungenSchema.parse(s.einstellungen)]);
}
await c.query("select set_config('betrieb.einspielen', '', true)");
await c.query("select setval('vorgang_nummer_seq', greatest((select max(nummer) from vorgang), 1000))");
// Sicherung von vor 0.6.0: dieselbe Regel wie Migration 006, damit laufende Projekte keinen automatischen Zahlungsplan bekommen
if (!(s.daten.projekte ?? []).some((p) => "zahlungsplan" in p)) {

View File

@@ -34,6 +34,8 @@ const ansatz = z.object({
ek: z.number().int().min(0).nullable().optional(),
faktor: z.number().positive().max(100).optional(),
aktiv: z.boolean().optional(),
/** Artikel aus dem Materialstamm: EK und Einheit kommen von dort */
artikel_id: z.uuid().nullable().optional(),
});
export interface Tabelle {
@@ -211,6 +213,42 @@ export const TABELLEN: Tabelle[] = [
reihenfolge: z.number().int().optional(),
}),
},
// Materialstamm (Stammdaten, 21.10.2026): DATANORM je Lieferant oder eigene Artikel; Preise in Cent je Preiseinheit
{
name: "artikel",
pfad: "artikel",
sortierung: "lieferant, artikelnummer, bezeichnung",
schema: z.object({
lieferant: z.string().trim().max(100).optional(),
artikelnummer: z.string().trim().max(60).optional(),
bezeichnung: text,
langtext: optText,
warengruppe: optText,
rabattgruppe: optText,
ean: optText,
einheit: optText,
preiseinheit: z.union([z.literal(1), z.literal(10), z.literal(100), z.literal(1000)]).optional(),
preisart: z.enum(["brutto", "netto"]).optional(),
listenpreis: cent.min(0).nullable().optional(),
rabatt: z.number().min(0).max(100).nullable().optional(),
ek: cent.min(0).nullable().optional(),
ek_vorher: cent.nullable().optional(),
herkunft: z.enum(["eigen", "datanorm"]).optional(),
stand: datum.nullable().optional(),
merkliste: z.boolean().optional(),
}),
},
{
name: "lieferant_rabatt",
pfad: "lieferanten-rabatte",
sortierung: "lieferant, rabattgruppe",
schema: z.object({
lieferant: text,
rabattgruppe: text,
bezeichnung: optText,
rabatt: z.number().min(0).max(100),
}),
},
// Mengenvorlagen und Musterpositionen (A23): eigene; die mitgelieferten stehen im Programm (domain/mengenvorlagen.ts)
{
name: "mengenvorlage",
@@ -226,6 +264,12 @@ export const TABELLEN: Tabelle[] = [
einheit: optText,
inhalt: blatt.extend({ ansaetze: z.array(ansatz).max(100).default([]) }),
reihenfolge: z.number().int().optional(),
// Leistungen (Stammdaten): Nummer/OZ, Herkunft, „Preis festlegen auf“
nummer: optText,
herkunft: z.enum(["eigen", "gaeb", "plancraft"]).optional(),
ep_fest: cent.min(0).nullable().optional(),
quelle: optText,
notiz: optText,
}),
},
{