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:
@@ -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;
|
||||
});
|
||||
|
||||
@@ -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);
|
||||
|
||||
67
src/server/leistungen-daten.ts
Normal file
67
src/server/leistungen-daten.ts
Normal 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}`)));
|
||||
}
|
||||
119
src/server/migrations/017_stammdaten.sql
Normal file
119
src/server/migrations/017_stammdaten.sql
Normal 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
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 });
|
||||
});
|
||||
}
|
||||
@@ -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)) {
|
||||
|
||||
@@ -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,
|
||||
}),
|
||||
},
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user