Files
Betriebsf-hrungssoftware/test/api.test.ts
Claude 0bfda30c69
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.31.0: Nextcloud-Zugang als Maske unter Daten (P10)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-23 06:18:47 +00:00

1484 lines
104 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.
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
import { describe, it, expect, beforeAll, afterAll } from "vitest";
import { falscheNextcloud } from "./falsche-nextcloud.js";
import type { FastifyInstance } from "fastify";
import { erstellePool, type Pool } from "../src/server/db.js";
import { migriere } from "../src/server/migrate.js";
import { baueApp } from "../src/server/app.js";
import { readFileSync } from "node:fs";
import { uebernimmV70 } from "../src/domain/v70.js";
import { liquiditaetsDaten } from "../src/domain/projektplan.js";
import { liquiditaet } from "../src/domain/liquiditaet.js";
import { bestandAus } from "./v70-referenz.js";
import { feiertag } from "../src/domain/kalender.js";
import { dateiText } from "../src/domain/kodierung.js";
const url = process.env.TEST_DATABASE_URL;
describe.skipIf(!url)("API mit Datenbank", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const anlegen = async (pfad: string, body: object, benutzer = "henning") => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body, headers: { "x-benutzer": benutzer } });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
it("Migrationen laufen nur einmal", async () => {
expect(await migriere(pool)).toEqual([]);
});
it("Status", async () => {
const r = await app.inject("/api/status");
expect(r.json()).toMatchObject({ ok: true });
});
it("umbenannter Kontakt erscheint überall mit neuem Namen (Abnahme Stufe 0)", async () => {
const k = await anlegen("kontakte", { name: "Dachdeckerei Meier", rolle: "subunternehmer" });
const p = await anlegen("projekte", { nummer: "26-01", bezeichnung: "Dachstuhl Musterweg", bauherr_id: k.id, umsatz_netto: 4_500_000 });
const a = await anlegen("abschnitte", { projekt_id: p.id, name: "Montage" });
const v = await anlegen("vorgaenge", { abschnitt_id: a.id, name: "Eindecken", start: "2026-11-02", dauer: 3, kontakt_id: k.id });
const r = await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { name: "Meier Bedachungen GmbH" } });
expect(r.statusCode).toBe(200);
const sicht = await pool.query(
`select kp.name as bauherr, kv.name as ausfuehrend from projekt p
join kontakt kp on kp.id = p.bauherr_id join vorgang v on v.id = $2 join kontakt kv on kv.id = v.kontakt_id where p.id = $1`,
[p.id, v.id],
);
expect(sicht.rows[0]).toEqual({ bauherr: "Meier Bedachungen GmbH", ausfuehrend: "Meier Bedachungen GmbH" });
});
it("Beträge bleiben centgenau", async () => {
const p = await anlegen("projekte", { nummer: "26-02", bezeichnung: "Carport" });
const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Anzahlung", netto: 123_456_789_01, termin: "2026-11-02" });
expect(z.netto).toBe(123_456_789_01);
expect(z.termin).toBe("2026-11-02");
});
it("lehnt ungültige Eingaben ab", async () => {
const r1 = await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "" } });
expect(r1.statusCode).toBe(400);
const r2 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1, termin: "2026-01-01" } });
expect(r2.statusCode).toBe(409);
const r3 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1.5, termin: "2026-01-01" } });
expect(r3.statusCode).toBe(400);
});
it("Protokoll hält fest, wer was geändert hat", async () => {
const k = await anlegen("kontakte", { name: "Holzhandel Nord" }, "henning");
await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { telefon: "04541 123" }, headers: { "x-benutzer": "buero" } });
await app.inject({ method: "DELETE", url: `/api/kontakte/${k.id}`, headers: { "x-benutzer": "henning" } });
const r = (await app.inject(`/api/protokoll?datensatz=${k.id}`)).json();
expect(r.map((x: { aktion: string; benutzer: string }) => [x.aktion, x.benutzer])).toEqual([
["loeschen", "henning"], ["aendern", "buero"], ["anlegen", "henning"],
]);
});
it("Einstellungen mit Vorgaben und Liquidität aus der Datenbank", async () => {
const e = (await app.inject("/api/einstellungen")).json();
expect(e.arbeitstage).toEqual([1, 2, 3, 4]);
expect(e.ust.satz).toBe(19);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, startsaldo: 500_000 } });
const p = await anlegen("projekte", { nummer: "26-03", bezeichnung: "Gaube" });
await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 1_000_000, termin: "2027-03-01" });
await anlegen("laufende-kosten", { bezeichnung: "Kfz-Versicherung", betrag: 60_000, rhythmus: "jaehrlich", start: "2027-03-20" });
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2027-03-01&anzahl=1")).json();
expect(l[0]).toMatchObject({ einnahmen: 1_190_000, ausgaben: -60_000, kontostand: 500_000 + 1_190_000 - 60_000 });
// Zahlungsfrist je Rate: Standard 14 Kalendertage nach Termin bzw. Rechnungsdatum, je Rate änderbar
const spaet = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Schluss", netto: 100_000, termin: "2027-03-25" });
const maerz = async () => (await app.inject("/api/liquiditaet?ansicht=monat&start=2027-03-01&anzahl=1")).json()[0].einnahmen;
expect(await maerz()).toBe(1_190_000);
await app.inject({ method: "PATCH", url: `/api/zahlungen/${spaet.id}`, payload: { zahlungsziel_tage: 3 } });
expect(await maerz()).toBe(1_190_000 + 119_000);
await app.inject({ method: "PATCH", url: `/api/zahlungen/${spaet.id}`, payload: { zahlungsziel_tage: 3, rechnungsdatum: "2027-03-30" } });
expect(await maerz()).toBe(1_190_000);
});
it("Export enthält alle Tabellen", async () => {
const r = await app.inject("/api/export");
const j = r.json();
expect(Object.keys(j.daten)).toContain("vorgaenge");
expect(j.daten.kontakte.length).toBeGreaterThan(0);
});
});
describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
let pool: Pool;
let app: FastifyInstance;
const sicherung = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8"));
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const importiere = (payload: object) => app.inject({ method: "POST", url: "/api/import/v70", payload, headers: { "x-benutzer": "henning" } });
it("lehnt fremde Dateien ab", async () => {
const r = await importiere({ format: "etwas anderes" });
expect(r.statusCode).toBe(400);
expect(r.json().fehler).toMatch(/keine Sicherung/);
});
it("übernimmt die Sicherung einmal, danach nicht mehr", async () => {
const r = await importiere(sicherung);
expect(r.statusCode, r.body).toBe(201);
expect(r.json().anzahl).toMatchObject({ projekte: 9, kontakte: 7, vorgaenge: 13, zahlungen: 5, kosten: 2, laufendeKosten: 10 });
expect((await importiere(sicherung)).statusCode).toBe(409);
const e = (await app.inject("/api/einstellungen")).json();
expect(e).toMatchObject({ arbeitstage: [1, 2, 3, 4], rundung: "halb", zahlungsziele: { kundenTage: 14, materialTage: 7 } });
const protokoll = (await app.inject("/api/protokoll?limit=1")).json();
expect(protokoll[0].benutzer).toBe("henning");
});
it("Liquidität aus der Datenbank wie aus der Sicherung gerechnet", async () => {
const u = uebernimmV70(sicherung); // wie der Server: Mo–Do
const erwartet = liquiditaet(liquiditaetsDaten(bestandAus(u), { tage: u.einstellungen.arbeitstage }), {
ansicht: "monat", start: "2026-07-01", anzahl: 12, startsaldo: 0, ziele: u.einstellungen.zahlungsziele,
});
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2026-07-01&anzahl=12")).json();
const kurz = (p: { von: string; einnahmen: number; ausgaben: number; kontostand: number }[]) =>
p.map(({ von, einnahmen, ausgaben, kontostand }) => ({ von, einnahmen, ausgaben, kontostand }));
expect(kurz(l)).toEqual(kurz(erwartet));
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
});
it("Liquidität Lage: Mindestgrenze automatisch oder fest (Zahnrad)", async () => {
const l = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
expect(l.wochen).toHaveLength(6);
expect(l.mindestgrenzeArt).toBe("auto");
expect(l.mindestgrenze).toBe(l.laufendMonat);
expect(l.lage.frei).toBe(l.kontostand - l.mindestgrenze);
const e = (await app.inject("/api/einstellungen")).json();
const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, mindestgrenzeArt: "fest", mindestreserve: 600_000 } });
expect(r.statusCode, r.body).toBe(200);
const l2 = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
expect(l2.mindestgrenze).toBe(600_000);
expect(l2.lage.frei).toBe(l2.kontostand - 600_000);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
});
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
const t = (await app.inject("/api/terminplan")).json();
expect(t.vorgaenge).toHaveLength(13);
expect(t.vorgaenge.every((v: { nummer: number }) => v.nummer > 1000)).toBe(true);
const nr = new Map(t.vorgaenge.map((v: { id: string }) => [v.id, v]));
for (const k of t.verknuepfungen.filter((k: { art: string }) => k.art === "EA")) {
const a = nr.get(k.vorgaenger_id) as { ende: string };
const b = nr.get(k.vorgang_id) as { anfang: string; dauer: number };
if (b.dauer > 0) expect(b.anfang > a.ende, `${a.ende} → ${b.anfang}`).toBe(true);
}
});
it("längerer Vorgang schiebt Nachfolger, Kreis wird abgelehnt", async () => {
const t = (await app.inject("/api/terminplan")).json();
const k = t.verknuepfungen.find((k: { art: string; verzoegerung: number }) => k.art === "EA");
const vor = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgaenger_id);
const nach = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgang_id);
const r = await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) + 10 } });
expect(r.statusCode, r.body).toBe(200);
const t2 = (await app.inject("/api/terminplan")).json();
const nach2 = t2.vorgaenge.find((v: { id: string }) => v.id === nach.id);
const vor2 = t2.vorgaenge.find((v: { id: string }) => v.id === vor.id);
expect(nach2.anfang > vor2.ende).toBe(true);
expect(nach2.anfang > nach.anfang).toBe(true);
const kreis = await app.inject({ method: "POST", url: "/api/verknuepfungen", payload: { vorgang_id: vor.id, vorgaenger_id: nach.id } });
expect(kreis.statusCode).toBe(409);
expect(kreis.json().fehler).toMatch(/Kreis/);
// kürzer machen: der enge Nachfolger rückt wieder nach vorn
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) } });
const t3 = (await app.inject("/api/terminplan")).json();
expect(t3.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang).toBe(nach.anfang);
// von Hand nach hinten gezogen: bleibt dort und zieht den Nachfolger mit
const spaeter = "2027-06-07";
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { start: spaeter } });
const t4 = (await app.inject("/api/terminplan")).json();
expect(t4.vorgaenge.find((v: { id: string }) => v.id === vor.id).anfang).toBe(spaeter);
expect(t4.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang > spaeter).toBe(true);
});
it("Besetzung: Mitarbeiter gelten sofort, Subunternehmer erst nach Freigabe; Überschneidung wird gemeldet", async () => {
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
const ma = await neu("kontakte", { name: "Henning Schaarschmidt", rolle: "mitarbeiter" });
const sub = await neu("kontakte", { name: "Jens Meier", firma: "Meier Bedachungen GmbH", rolle: "subunternehmer" });
const t = (await app.inject("/api/terminplan")).json();
const frei = (v: { id: string; dauer: number }) => Number(v.dauer) > 0 && !t.verknuepfungen.some((k: { vorgang_id: string }) => k.vorgang_id === v.id);
const [a, b] = t.vorgaenge.filter(frei);
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${b.id}`, payload: { start: a.anfang } });
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: ma.id })).freigegeben).toBe(true);
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: sub.id, personen: 2 })).freigegeben).toBe(false);
expect((await neu("besetzungen", { vorgang_id: b.id, kontakt_id: ma.id })).freigegeben).toBe(true);
const ohne = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: a.id } });
expect(ohne.statusCode).toBe(400);
const t2 = (await app.inject("/api/terminplan")).json();
expect(t2.ueberschneidungen).toEqual([expect.objectContaining({ name: "Henning Schaarschmidt", ab: a.anfang })]);
expect(t2.besetzungen.map((x: { kurz: string }) => x.kurz).sort()).toEqual(["HS", "HS", "Meier"]);
});
it("Startseite: Aufgaben, Warnungen und wer macht was", async () => {
await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Statik anfragen", faellig_am: "2026-10-16" } });
const t = (await app.inject("/api/terminplan")).json();
const u = (await app.inject(`/api/uebersicht?heute=${t.ueberschneidungen[0].ab}`)).json();
expect(u.aufgaben.ueberfaellig.map((a: { text: string }) => a.text)).toContain("Statik anfragen");
const arten = u.warnungen.map((w: { art: string }) => w.art);
expect(arten).toEqual(expect.arrayContaining(["aufgabe", "kontostand"]));
expect(u.warnungen.find((w: { art: string }) => w.art === "kontostand").text).toMatch(/nicht eingetragen/);
expect(u.einsatz.tage).toHaveLength(8);
expect(u.einsatz.zeilen.map((z: { anzeige: string }) => z.anzeige)).toContain("Henning Schaarschmidt");
});
it("Aufgaben mit Kategorie, Projekt und Kunde; gelöschte Kategorie bleibt ohne Folgen", async () => {
const anlegen = async (pfad: string, body: object) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const kat = await anlegen("aufgaben-kategorien", { name: "Bestellung" });
const doppelt = await app.inject({ method: "POST", url: "/api/aufgaben-kategorien", payload: { name: "Bestellung" } });
expect(doppelt.statusCode).toBeGreaterThanOrEqual(400);
const k = await anlegen("kontakte", { name: "Familie Groth", rolle: "bauherr" });
const p = await anlegen("projekte", { nummer: "P-26-099", bezeichnung: "Carport Groth", bauherr_id: k.id, baustelle_ort: "Mölln" });
const a = await anlegen("aufgaben", { text: "Holz bestellen", kategorie_id: kat.id, projekt_id: p.id, kontakt_id: k.id, faellig_am: "2026-10-01" });
const u = (await app.inject("/api/uebersicht?heute=2026-10-20")).json();
const zeile = u.aufgaben.ueberfaellig.find((x: { id: string }) => x.id === a.id);
expect(zeile).toMatchObject({ kategorie: "Bestellung", projekt_name: "Carport Groth", kontakt_name: "Familie Groth" });
expect((await app.inject({ method: "DELETE", url: `/api/aufgaben-kategorien/${kat.id}` })).statusCode).toBeLessThan(300);
const nach = (await app.inject("/api/aufgaben")).json().find((x: { id: string }) => x.id === a.id);
expect(nach.kategorie_id).toBeNull();
expect((await app.inject(`/api/projekte/${p.id}`)).json().baustelle_ort).toBe("Mölln");
});
it("Zahlungsplan entsteht automatisch, folgt Auftragswert und Terminen, bis er von Hand geändert wird", async () => {
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
const raten = async (id: string) => (await app.inject("/api/zahlungen")).json()
.filter((z: { projekt_id: string }) => z.projekt_id === id).sort((a: { reihenfolge: number }, b: { reihenfolge: number }) => a.reihenfolge - b.reihenfolge);
const p = await neu("projekte", { nummer: "P-26-098", bezeichnung: "Dachstuhl Ziegelei" });
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(400);
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 2_000_000 } });
expect(await raten(p.id)).toHaveLength(0); // noch keine Termine
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2026-11-09", dauer: 3 });
expect((await raten(p.id)).map((z: { netto: number }) => z.netto)).toEqual([600_000, 800_000, 400_000, 200_000]);
// ein später angelegter Vorgang „Richten“ bekommt die 40-%-Rate
const richten = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-02", dauer: 2 });
expect((await raten(p.id))[1]).toMatchObject({ vorgang_id: richten.id, termin: "2026-11-03" });
// neuer Auftragswert: Raten anteilig
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 3_000_000 } });
expect((await raten(p.id)).map((z: { netto: number }) => z.netto)).toEqual([900_000, 1_200_000, 600_000, 300_000]);
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(409);
// Richten verschiebt sich um eine Woche: die geplante Rate geht mit
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-09" } });
const r1 = (await raten(p.id))[1];
expect(r1.termin).toBe("2026-11-10");
// von Hand geändert: Plan ist fest, Auftragswert ändert die Raten nicht mehr
await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { netto: 1_000_000 } });
expect((await app.inject(`/api/projekte/${p.id}`)).json().zahlungsplan).toBe("fest");
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 4_000_000 } });
expect((await raten(p.id))[1].netto).toBe(1_000_000);
// gestellte Raten bleiben stehen, geplante wandern weiter mit
await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { status: "gestellt" } });
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-16" } });
expect((await app.inject(`/api/zahlungen/${r1.id}`)).json().termin).toBe("2026-11-10");
expect((await app.inject("/api/terminplan")).json().zahlungen.filter((z: { projekt_id: string }) => z.projekt_id === p.id)).toHaveLength(4);
// alle gelöscht: es kommt kein neuer automatisch
for (const z of await raten(p.id)) await app.inject({ method: "DELETE", url: `/api/zahlungen/${z.id}` });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Abnahme", start: "2026-11-30", dauer: 0 });
expect(await raten(p.id)).toHaveLength(0);
});
it("Kalender-Abo nur mit gültigem Geheimnis", async () => {
expect((await app.inject("/kalender/xxxxxxxxxxxxxxxxxxxxxxxx/baustellen.ics")).statusCode).toBe(404);
const { kalenderToken } = (await app.inject({ method: "POST", url: "/api/kalender/neu" })).json();
const r = await app.inject(`/kalender/${kalenderToken}/baustellen.ics`);
expect(r.statusCode).toBe(200);
expect(r.headers["content-type"]).toMatch(/text\/calendar/);
expect(r.body).toContain("X-WR-CALNAME:Baustellen");
expect(r.body).toMatch(/SUMMARY:P-26-\d+/);
expect((await app.inject(`/kalender/${kalenderToken}/aufgaben.ics`)).body).toContain("Aufgabe: Statik anfragen");
expect((await app.inject(`/kalender/${kalenderToken.slice(0, -1)}${kalenderToken.endsWith("x") ? "y" : "x"}/baustellen.ics`)).statusCode).toBe(404);
});
});
describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => {
let pool: Pool;
let app: FastifyInstance;
const f = falscheNextcloud();
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloud: f.nc, anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
it("neues Projekt bekommt einen Ordner, Statuswechsel verschiebt ihn", async () => {
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-130", bezeichnung: "Carport Most", status: "angebot" } })).json();
expect(p.nextcloud_link).toBe("01 Angebot/A-26-130 Carport Most");
const q = (await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { nummer: "P-26-021", status: "auftrag" } })).json();
expect(q.nextcloud_link).toBe("02 laufende Projekte/P-26-021 Carport Most");
expect(f.relativ()).toContain("02 laufende Projekte/P-26-021 Carport Most/02 Umsetzung");
});
it("Ablage zeigt den Projektordner und reicht Dateien durch", async () => {
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "P-26-022", bezeichnung: "Gaube Lüth", status: "auftrag" } })).json();
f.dateien.set(`${f.wurzel}/${p.nextcloud_link}/01 Auftrag/Angebot A-26-140.pdf`, "%PDF-Probe");
const wurzel = (await app.inject(`/api/projekte/${p.id}/ablage`)).json();
expect(wurzel.eintraege.map((e: { name: string }) => e.name)).toEqual(["01 Auftrag", "02 Umsetzung", "03 Bilder"]);
const auftrag = (await app.inject(`/api/projekte/${p.id}/ablage?pfad=${encodeURIComponent("01 Auftrag")}`)).json();
expect(auftrag.eintraege).toEqual([
{ name: "03 Stundenlohnarb.", ordner: true, groesse: 0, geaendert: null },
{ name: "Angebot A-26-140.pdf", ordner: false, groesse: 10, geaendert: "2026-10-19T08:00:00.000Z" },
]);
const d = await app.inject(`/api/projekte/${p.id}/ablage/datei?pfad=${encodeURIComponent("01 Auftrag/Angebot A-26-140.pdf")}`);
expect(d.statusCode).toBe(200);
expect(d.body).toBe("%PDF-Probe");
expect((await app.inject(`/api/projekte/${p.id}/ablage?pfad=..%2F..`)).statusCode).toBe(400);
expect((await app.inject(`/api/projekte/${p.id}/ablage/datei?pfad=gibtsnicht.pdf`)).statusCode).toBe(404);
});
it("Fehler der Nextcloud verhindert das Speichern nicht", async () => {
f.ordner.clear(); // Wurzel fehlt: jede Anlage schlägt fehl
const r = await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-131", bezeichnung: "Gaube", status: "angebot" } });
expect(r.statusCode).toBe(201);
expect(r.json().ordner_fehler).toMatch(/Nextcloud/);
f.ordner.add(f.wurzel);
const nochmal = (await app.inject({ method: "POST", url: `/api/projekte/${r.json().id}/ordner` })).json();
expect(nochmal.nextcloud_link).toBe("01 Angebot/A-26-131 Gaube");
});
it("Testversion: der erste neue Benutzer legt den bisherigen Inhaber mit an", async () => {
const r = await app.inject({ method: "POST", url: "/api/benutzer", payload: { anmeldename: "jan", name: "Jan", rolle: "mitarbeiter" } });
expect(r.statusCode, r.body).toBe(201);
const s = (await app.inject("/api/sitzung")).json();
expect(s.benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" });
expect(s.benutzer.id).toBeTruthy();
expect(s.auswahl.map((x: { name: string }) => x.name).sort()).toEqual(["Henning", "Jan"]);
// Passwörter gibt es in der Testversion nicht
expect((await app.inject({ method: "PATCH", url: `/api/benutzer/${r.json().id}`, payload: { passwort: "geheim123" } })).statusCode).toBe(400);
});
});
describe.skipIf(!url)("Nextcloud-Zugang über die Maske unter Daten", () => {
let pool: Pool;
let app: FastifyInstance;
const f = falscheNextcloud("https://cloud.test/remote.php/dav/files/henning/01 Projekte");
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloudAbruf: f.abruf, anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
it("speichert Adresse und App-Passwort, gibt das Passwort nie zurück und legt danach Ordner an", async () => {
expect((await app.inject("/api/nextcloud")).json()).toMatchObject({ adresse: "", ordner: "01 Projekte", passwortGesetzt: false, einrichtbar: true });
expect((await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).statusCode).toBe(409);
// ohne Zugang: Projekt speichert ohne Ordner
const ohne = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-150", bezeichnung: "Vordach", status: "angebot" } })).json();
expect(ohne.nextcloud_link).toBeNull();
// Pfad vom PC statt Ordner in der Nextcloud
expect((await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "C:\\Nc\\01 Projekte" } })).statusCode).toBe(400);
const r = await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test/", benutzer: "henning", ordner: "01 Projekte", passwort: "app-passwort-123" } });
expect(r.statusCode, r.body).toBe(200);
const z = (await app.inject("/api/nextcloud")).json();
expect(z).toMatchObject({ adresse: "https://cloud.test", passwortGesetzt: true, webdav: "https://cloud.test/remote.php/dav/files/henning/01%20Projekte" });
expect(JSON.stringify(z)).not.toContain("app-passwort-123");
expect((await app.inject("/api/export")).body).not.toContain("app-passwort-123");
expect((await app.inject("/api/einstellungen")).body).not.toContain("app-passwort-123");
// Prüfen: Ordner erreichbar, Statusordner fehlen noch
let p = (await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json();
expect(p).toMatchObject({ ok: true, vorhanden: [], fehlen: ["01 Angebot", "02 laufende Projekte", "03 Gewährl.-Projekte", "04 Archiv"] });
f.ordner.add(`${f.wurzel}/02 laufende Projekte`);
f.ordner.add(`${f.wurzel}/02 laufende Projekte/P-26-151 Dachgaube`);
p = (await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json();
expect(p.vorhanden).toEqual(["02 laufende Projekte"]);
// alle Projekte abgleichen: vorhandener Ordner wird übernommen, fehlender angelegt
await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "P-26-151", bezeichnung: "Dachgaube", status: "auftrag" } });
const a = (await app.inject({ method: "POST", url: "/api/nextcloud/abgleichen" })).json();
expect(a).toEqual({ ok: 2, fehler: [] });
expect(f.relativ()).toContain("01 Angebot/A-26-150 Vordach/03 Bilder");
expect(f.relativ().filter((o) => o.startsWith("02 laufende Projekte/P-26-151"))).toContain("02 laufende Projekte/P-26-151 Dachgaube");
// leeres Passwort behält das alte; löschen schaltet den Zugang ab
await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwort: "" } });
expect((await app.inject("/api/nextcloud")).json().passwortGesetzt).toBe(true);
await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwortLoeschen: true } });
expect((await app.inject("/api/nextcloud")).json().passwortGesetzt).toBe(false);
});
it("Browser-Testversion: Adresse ja, App-Passwort erst auf dem Server", async () => {
const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloudEinrichtbar: false, anmeldung: "testversion" });
const r = await t.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwort: "x" } });
expect(r.statusCode).toBe(409);
expect((await t.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte" } })).statusCode).toBe(200);
expect((await t.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json().fehler).toMatch(/erst auf dem Server/);
await t.close();
});
});
describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => {
let pool: Pool;
let app: FastifyInstance;
const sicherung = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8"));
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
it("bringt jeden Datensatz mit derselben ID zurück", async () => {
expect((await app.inject({ method: "POST", url: "/api/import/v70", payload: sicherung })).statusCode).toBe(201);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...(await app.inject("/api/einstellungen")).json(), startsaldo: 1234500 } });
const kat = (await app.inject({ method: "POST", url: "/api/aufgaben-kategorien", payload: { name: "Büro" } })).json();
await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Angebot nachfassen", kategorie_id: kat.id } });
const mv = await app.inject({ method: "POST", url: "/api/mengenvorlagen", payload: { art: "muster", gruppe: "Klempner", name: "Ortgangblech", einheit: "m",
inhalt: { werte: [{ kz: "L", formel: "8", eingabe: true }], listen: [], zeilen: [], menge: "L", ansaetze: [{ kostenart: "lohn", lohnart: "geselle", bezug: "L", menge: 0.1, personen: 1 }] } } });
expect(mv.statusCode, mv.body).toBe(201);
const art = await app.inject({ method: "POST", url: "/api/artikel/import", payload: { lieferant: "Holzhandel Nord", stand: "2026-10-14",
rabatte: [{ rabattgruppe: "KVH", rabatt: 30 }], artikel: [{ artikelnummer: "4711-0820", bezeichnung: "KVH 8/20", einheit: "m³", listenpreis: 55000, rabattgruppe: "KVH" }] } });
expect(art.statusCode, art.body).toBe(200);
const vorher = (await app.inject("/api/export")).json();
expect(vorher.daten.artikel[0]).toMatchObject({ ek: 38500 });
expect(vorher.daten["aufgaben-kategorien"]).toHaveLength(1);
expect(vorher.daten.mengenvorlagen).toHaveLength(1);
expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(409);
expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: { programm: "anders" } })).statusCode).toBe(400);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
const r = await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher });
expect(r.statusCode, r.body).toBe(201);
expect(r.json().anzahl.vorgaenge).toBe(13);
const nachher = (await app.inject("/api/export")).json();
const ohneZeit = (d: Record<string, Record<string, unknown>[]>) =>
Object.fromEntries(Object.entries(d).map(([k, z]) => [k, z.map(({ angelegt_am, geaendert_am, ...rest }) => rest)]));
expect(ohneZeit(nachher.daten)).toEqual(ohneZeit(vorher.daten));
// seit 0.18: Zeitstempel bleiben beim Einspielen erhalten
expect(nachher.daten.mengenvorlagen[0].geaendert_am).toBe(vorher.daten.mengenvorlagen[0].geaendert_am);
expect(nachher.daten.artikel[0].angelegt_am).toBe(vorher.daten.artikel[0].angelegt_am);
expect(nachher.einstellungen.startsaldo).toBe(1234500);
// neue Vorgänge bekommen Nummern hinter den übernommenen
const a = vorher.daten.abschnitte[0];
const v = await app.inject({ method: "POST", url: "/api/vorgaenge", payload: { abschnitt_id: a.id, name: "Neu", start: "2026-11-02", dauer: 1 } });
expect(v.statusCode, v.body).toBe(201);
expect(v.json().nummer).toBeGreaterThan(Math.max(...vorher.daten.vorgaenge.map((x: { nummer: number }) => x.nummer)));
});
it("Sicherung von vor 0.12: Vorgänge behalten ihre Dauer (T15)", async () => {
const vorher = (await app.inject("/api/export")).json();
vorher.daten.vorgaenge = vorher.daten.vorgaenge.map(({ dauer_fest, ...v }: { dauer_fest: boolean }) => v);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(201);
expect((await pool.query("select bool_and(dauer_fest) as alle from vorgang")).rows[0].alle).toBe(true);
});
it("Ansichten der Tabellen je Benutzer: speichern, Sicherung, Umzug", async () => {
const ansicht = { aktuell: { sort: [["faellig", "auf"]], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" }, aus: [] }, name: "Meine Woche", ansichten: [] };
expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: ansicht })).statusCode).toBe(204);
expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/Böse Tabelle", payload: ansicht })).statusCode).toBe(400);
expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { x: "y".repeat(100_001) } })).statusCode).toBe(413);
expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht });
const stand = (await app.inject("/api/export")).json();
expect(stand.daten.ansichten).toHaveLength(1);
// auf dem Server gibt es schon eine Ansicht des Inhabers: die aus der Sicherung gewinnt, die Daten zählen trotzdem als leer
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { name: null } })).statusCode).toBe(204);
const r = await app.inject({ method: "POST", url: "/api/import/stand", payload: stand });
expect(r.statusCode, r.body).toBe(201);
expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht });
});
});
describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => {
let pool: Pool;
let app: FastifyInstance;
const CODE = "einrichtung-123";
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "passwort", einrichtungsCode: CODE });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const keks = (r: { headers: Record<string, unknown> }) => String(r.headers["set-cookie"]).split(";")[0]!;
const als = (cookie: string, method: "GET" | "POST" | "PATCH" | "DELETE", u: string, payload?: object) =>
app.inject({ method, url: u, payload, headers: { cookie } });
const anmelden = async (anmeldename: string, passwort: string) => {
const r = await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename, passwort } });
expect(r.statusCode, r.body).toBe(200);
return keks(r);
};
let inhaber = "";
it("ohne Anmeldung nichts außer Status und Anmeldeseite", async () => {
expect((await app.inject("/api/projekte")).statusCode).toBe(401);
expect((await app.inject("/api/status")).statusCode).toBe(200);
expect((await app.inject("/api/sitzung")).json()).toMatchObject({ art: "passwort", benutzer: null, einrichtung: true });
});
it("Einrichtung legt den Inhaber nur mit dem richtigen Code an, und nur einmal", async () => {
const daten = { name: "Henning Schaarschmidt", anmeldename: "Henning", passwort: "sehrgeheim1" };
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: "falsch" } })).statusCode).toBe(403);
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, passwort: "kurz", code: CODE } })).statusCode).toBe(400);
const r = await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, code: CODE } });
expect(r.statusCode, r.body).toBe(201);
expect(String(r.headers["set-cookie"])).toMatch(/HttpOnly; SameSite=Lax; Max-Age=7776000/);
inhaber = keks(r);
expect((await als(inhaber, "GET", "/api/sitzung")).json().benutzer).toMatchObject({ anmeldename: "henning", rolle: "inhaber" });
expect((await als(inhaber, "GET", "/api/projekte")).statusCode).toBe(200);
expect((await app.inject({ method: "POST", url: "/api/einrichtung", payload: { ...daten, anmeldename: "zweiter", code: CODE } })).statusCode).toBe(409);
});
it("falsches Passwort und Sperre nach fünf Fehlversuchen", async () => {
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "gibtsnicht", passwort: "x" } })).statusCode).toBe(401);
for (let i = 0; i < 5; i++) {
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "falsch" } })).statusCode).toBe(401);
}
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "henning", passwort: "sehrgeheim1" } })).statusCode).toBe(429);
// Groß/klein und Leerzeichen umgehen die Sperre nicht
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "HENNING ", passwort: "sehrgeheim1" } })).statusCode).toBe(429);
});
it("Büro und Mitarbeiter: jeder sieht nur, was zu seiner Rolle gehört (E27, P13)", async () => {
const buero = await als(inhaber, "POST", "/api/benutzer", { anmeldename: "buero", name: "Büro", rolle: "buero", passwort: "buero12345" });
expect(buero.statusCode, buero.body).toBe(201);
expect(buero.json()).not.toHaveProperty("passwort");
expect(buero.json().hat_passwort).toBe(true);
const ma = (await als(inhaber, "POST", "/api/benutzer", { anmeldename: "jan", name: "Jan Zimmermann", rolle: "mitarbeiter", passwort: "jan123456" })).json();
expect(ma.kontakt_id).toBeTruthy();
const kontakt = (await als(inhaber, "GET", `/api/kontakte/${ma.kontakt_id}`)).json();
expect(kontakt).toMatchObject({ name: "Jan Zimmermann", rolle: "mitarbeiter" });
// Jan ist auf einem von zwei Projekten eingeteilt
const neu = async (pfad: string, d: object) => (await als(inhaber, "POST", `/api/${pfad}`, d)).json();
const p1 = await neu("projekte", { nummer: "P-26-101", bezeichnung: "Carport Kruse", baustelle_ort: "Mölln", umsatz_netto: 1_000_000 });
const p2 = await neu("projekte", { nummer: "P-26-102", bezeichnung: "Dach Lange" });
const a1 = await neu("abschnitte", { projekt_id: p1.id, name: "Montage" });
const a2 = await neu("abschnitte", { projekt_id: p2.id, name: "Montage" });
const v1 = await neu("vorgaenge", { abschnitt_id: a1.id, name: "Abbund", start: "2026-11-02", dauer: 2 });
await neu("vorgaenge", { abschnitt_id: a2.id, name: "Richten", start: "2026-11-02", dauer: 2 });
await neu("besetzungen", { vorgang_id: v1.id, kontakt_id: ma.kontakt_id });
const b = await anmelden("buero", "buero12345");
expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(200);
expect((await als(b, "GET", "/api/benutzer")).statusCode).toBe(403);
expect((await als(b, "GET", "/api/export")).statusCode).toBe(403);
// Stundensätze zeigen Löhne (U2): nur Inhaber; die Namen der Lohnarten braucht das Büro
expect((await als(b, "GET", "/api/stundensaetze")).statusCode).toBe(403);
expect((await als(b, "GET", "/api/lohnarten")).statusCode).toBe(200);
expect((await als(b, "PATCH", `/api/projekte/${p2.id}`, { notiz: "Büro war hier" })).statusCode).toBe(200);
const j = await anmelden("jan", "jan123456");
for (const u of ["/api/projekte", "/api/zahlungen", "/api/kontakte", "/api/terminplan", "/api/uebersicht", "/api/liquiditaet", "/api/benutzer", "/api/einstellungen"]) {
expect((await als(j, "GET", u)).statusCode, u).toBe(403);
}
expect((await als(j, "PATCH", `/api/projekte/${p1.id}`, { umsatz_netto: 1 })).statusCode).toBe(403);
const e = (await als(j, "GET", "/api/ich/einsaetze?heute=2026-11-02")).json();
expect(e.einsaetze).toHaveLength(1);
expect(e.einsaetze[0]).toMatchObject({ name: "Abbund", nummer: "P-26-101", baustelle_ort: "Mölln", anfang: "2026-11-02", ende: "2026-11-03" });
expect(JSON.stringify(e)).not.toMatch(/umsatz|netto/);
// einzelner Freitag für einen Vorgang freigegeben: endet am Freitag, Jan sieht ihn als Einsatz
const v3 = await neu("vorgaenge", { abschnitt_id: a1.id, name: "Richten", start: "2026-11-09", dauer: 5 });
expect((await als(inhaber, "GET", "/api/terminplan")).json().vorgaenge.find((x: { id: string }) => x.id === v3.id).ende).toBe("2026-11-16");
const fr = await als(inhaber, "PATCH", `/api/vorgaenge/${v3.id}`, { freitage: ["2026-11-13"] });
expect(fr.statusCode, fr.body).toBe(200);
expect(fr.json().freitage).toEqual(["2026-11-13"]);
await neu("besetzungen", { vorgang_id: v3.id, kontakt_id: ma.kontakt_id });
const e2 = (await als(j, "GET", "/api/ich/einsaetze?heute=2026-11-09&tage=7")).json();
expect(e2.einsaetze.find((x: { name: string }) => x.name === "Richten")).toMatchObject({ anfang: "2026-11-09", ende: "2026-11-13", freitage: ["2026-11-13"] });
// Ablage nur für eigene Projekte; ohne Nextcloud kommt beim eigenen der Hinweis
expect((await als(j, "GET", `/api/projekte/${p2.id}/ablage`)).statusCode).toBe(403);
expect((await als(j, "GET", `/api/projekte/${p1.id}/ablage`)).statusCode).toBe(409);
});
it("Passwort ändern meldet andere Geräte ab; gesperrte Benutzer kommen nicht mehr rein", async () => {
const j1 = await anmelden("jan", "jan123456");
const j2 = await anmelden("jan", "jan123456");
expect((await als(j1, "POST", "/api/ich/passwort", { alt: "falsch", neu: "neuespasswort" })).statusCode).toBe(400);
expect((await als(j1, "POST", "/api/ich/passwort", { alt: "jan123456", neu: "neuespasswort" })).statusCode).toBe(200);
expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(200);
expect((await als(j2, "GET", "/api/ich/einsaetze")).statusCode).toBe(401);
const jan = (await als(inhaber, "GET", "/api/benutzer")).json().find((x: { anmeldename: string }) => x.anmeldename === "jan");
expect((await als(inhaber, "PATCH", `/api/benutzer/${jan.id}`, { aktiv: false })).statusCode).toBe(200);
expect((await als(j1, "GET", "/api/ich/einsaetze")).statusCode).toBe(401);
expect((await app.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(401);
});
it("es bleibt immer ein Inhaber; Passwörter stehen nirgends im Klartext oder im Protokoll", async () => {
const ich = (await als(inhaber, "GET", "/api/sitzung")).json().benutzer;
expect((await als(inhaber, "PATCH", `/api/benutzer/${ich.id}`, { rolle: "buero" })).statusCode).toBe(409);
expect((await als(inhaber, "DELETE", `/api/benutzer/${ich.id}`)).statusCode).toBe(409);
const prot = (await pool.query("select vorher, nachher from protokoll where tabelle = 'benutzer'")).rows;
expect(prot.length).toBeGreaterThan(0);
expect(JSON.stringify(prot)).not.toMatch(/passwort|scrypt/);
const hash = (await pool.query("select passwort from benutzer where anmeldename = 'henning'")).rows[0].passwort;
expect(hash).toMatch(/^scrypt\$/);
expect(hash).not.toContain("sehrgeheim1");
const sicherung = (await als(inhaber, "GET", "/api/export")).json();
expect(sicherung.daten.benutzer.length).toBe(3);
expect(JSON.stringify(sicherung)).not.toMatch(/scrypt/);
expect((await pool.query("select id from sitzung")).rows.every((r) => /^[0-9a-f]{64}$/.test(r.id))).toBe(true);
});
it("Anfragen von fremden Seiten werden abgewiesen", async () => {
const r = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://boese.example", host: "betrieb.schaarschmidt-holzbau.de" } });
expect(r.statusCode).toBe(403);
const ok = await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "x" }, headers: { cookie: inhaber, origin: "https://betrieb.schaarschmidt-holzbau.de", host: "betrieb.schaarschmidt-holzbau.de" } });
expect(ok.statusCode).toBe(201);
});
it("Abmelden beendet die Sitzung", async () => {
const b = await anmelden("buero", "buero12345");
expect((await als(b, "POST", "/api/abmeldung")).statusCode).toBe(200);
expect((await als(b, "GET", "/api/projekte")).statusCode).toBe(401);
});
it("Personal: Modell, Abwesenheit, Urlaubskonto; den Stundenlohn sieht nur der Inhaber (M1, M8, M4, U2)", async () => {
const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id;
const m = await als(inhaber, "POST", "/api/mitarbeiter", { kontakt_id: jan, personalnummer: "17", lohn_cent: 2850, urlaubstage: 28 });
expect(m.statusCode, m.body).toBe(201);
expect(m.json().lohn_cent).toBe(2850);
const mod = await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-01-01", stunden: [8, 8, 8, 8, 6.5, 0, 0] });
expect(mod.statusCode, mod.body).toBe(201);
expect(mod.json().stunden).toEqual([8, 8, 8, 8, 6.5, 0, 0]);
expect((await als(inhaber, "POST", "/api/arbeitszeitmodelle", { kontakt_id: jan, gueltig_ab: "2026-02-01", stunden: [8, 8] })).statusCode).toBe(400);
expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-02", bis: "2026-11-06" })).statusCode).toBe(201);
expect((await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: "2026-11-09", bis: "2026-11-08" })).statusCode).toBe(400);
expect((await als(inhaber, "POST", "/api/urlaubskonten", { kontakt_id: jan, jahr: 2026, uebertrag: 3 })).statusCode).toBe(201);
const b = await anmelden("buero", "buero12345");
const liste = (await als(b, "GET", "/api/personal?heute=2026-11-03")).json();
const j = liste.find((x: { id: string }) => x.id === jan);
expect(j).toMatchObject({ stunden: [8, 8, 8, 8, 6.5, 0, 0], eigenesModell: true, heute: { soll: 8, frei: 0 } });
expect(j.urlaub).toMatchObject({ anspruch: 28, uebertrag: 3, genommen: 2, geplant: 3, rest: 26 });
expect(j.stammdaten.lohn_cent).toBeUndefined();
expect((await als(b, "GET", "/api/mitarbeiter")).json()[0]).not.toHaveProperty("lohn_cent");
expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { lohn_cent: 9999 })).statusCode).toBe(403);
expect((await als(b, "PATCH", `/api/mitarbeiter/${m.json().id}`, { personalnummer: "18" })).json()).not.toHaveProperty("lohn_cent");
const v = (await als(b, "GET", `/api/verfuegbarkeit?von=2026-11-06&bis=2026-11-09&kontakt_id=${jan}`)).json();
expect(v[0].tage.map((t: { frei: number }) => t.frei)).toEqual([0, 0, 0, 8]);
// Mitarbeiter selbst kommen an die Personalliste nicht heran (Jan wurde oben gesperrt)
const janB = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id;
expect((await als(inhaber, "PATCH", `/api/benutzer/${janB}`, { aktiv: true })).statusCode).toBe(200);
const jj = await anmelden("jan", "neuespasswort");
expect((await als(jj, "GET", "/api/personal")).statusCode).toBe(403);
expect((await als(jj, "GET", "/api/mitarbeiter")).statusCode).toBe(403);
// Mitarbeiter scheiden nur aus, löschen geht weder beim Kontakt noch bei den Personaldaten
const weg = await als(inhaber, "DELETE", `/api/kontakte/${jan}`);
expect(weg.statusCode).toBe(409);
expect(weg.json().fehler).toMatch(/Austrittsdatum/);
expect((await als(inhaber, "DELETE", `/api/mitarbeiter/${m.json().id}`)).statusCode).toBe(409);
expect((await pool.query("select 1 from kontakt where id = $1", [jan])).rowCount).toBe(1);
});
it("Zeiterfassung: ein Eintrag je Tag, Pausenabzug nach M3, Anteile je Vorgang (Z1, E21)", async () => {
const heute = new Date().toISOString().slice(0, 10);
const tag = (n: number) => new Date(Date.now() + n * 86400000).toISOString().slice(0, 10);
const jj = await anmelden("jan", "neuespasswort");
const ich = (await als(jj, "GET", "/api/ich/zeiten")).json();
expect(ich.angestellt).toBe(true);
expect(ich.projekte.map((p: { nummer: string }) => p.nummer)).toContain("P-26-101");
expect(JSON.stringify(ich)).not.toMatch(/umsatz|netto"|lohn/);
const v1 = ich.einsaetze[0];
expect(v1).toMatchObject({ name: "Abbund" });
// 7:00 bis 16:10 ohne Pause: 9:10 da, voller Abzug 45 Min → 8:25 (Standard „voll“)
const r = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "7:00", ende: "16:10", anteile: [{ vorgang_id: v1.id, taetigkeit: "Abbund Sparren" }] });
expect(r.statusCode, r.body).toBe(200);
expect(r.json()).toMatchObject({ beginn: "07:00", ende: "16:10", pause_min: 0, abzug_min: 45, netto_min: 505, ueber_zehn: false });
expect(r.json().anteile).toMatchObject([{ vorgang_id: v1.id, projekt_id: v1.projekt_id, stunden: 8.42, taetigkeit: "Abbund Sparren" }]);
// gleicher Tag noch einmal: ersetzt, aufgeteilt auf zwei Baustellen
const p2 = ich.projekte.find((p: { nummer: string }) => p.nummer === "P-26-102");
const falsch = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 4 }, { projekt_id: p2.id, stunden: 3 }] });
expect(falsch.statusCode).toBe(400);
expect(falsch.json().fehler).toMatch(/ergeben 7, gearbeitet wurden 8 Stunden/);
const zwei = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 5 }, { projekt_id: p2.id, stunden: 3 }] });
expect(zwei.statusCode, zwei.body).toBe(200);
expect(zwei.json()).toMatchObject({ pause_min: 30, abzug_min: 0, netto_min: 480 });
expect((await pool.query("select count(*) as n from zeiteintrag")).rows[0].n).toBe(1);
expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(1)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(400);
expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-20)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(403);
expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-3)}`, { beginn: "15:00", ende: "07:00" })).statusCode).toBe(400);
expect((await als(jj, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).statusCode).toBe(403);
// Inhaber bucht für sich selbst: Kontakt entsteht, keine Pausenregel; und trägt für Jan nach
const selbst = await als(inhaber, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "06:00", ende: "17:00", anteile: [{ projekt_id: p2.id }] });
expect(selbst.statusCode, selbst.body).toBe(200);
expect(selbst.json()).toMatchObject({ abzug_min: 0, netto_min: 660, ueber_zehn: true });
const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id;
expect((await als(inhaber, "PUT", `/api/zeiten/${jan}/${tag(-20)}`, { beginn: "07:00", ende: "13:00" })).statusCode).toBe(200);
const alle = (await als(inhaber, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).json();
expect(alle.tage).toHaveLength(3);
expect(alle.leute.find((l: { id: string }) => l.id === jan).angestellt).toBe(true);
expect((await als(inhaber, "GET", "/api/zeiten/projekte")).json()).toEqual({ [v1.projekt_id]: 5, [p2.id]: 14 });
// 2 Jahre aufbewahren: Kontakt mit Stunden lässt sich nicht löschen; Sicherung enthält die Stunden
expect((await als(inhaber, "DELETE", `/api/kontakte/${jan}`)).statusCode).toBe(409);
const sicherung = (await als(inhaber, "GET", "/api/export")).json();
expect(sicherung.daten.zeiteintraege).toHaveLength(3);
expect(sicherung.daten.zeitanteile).toHaveLength(4);
});
it("Stundenliste fürs Steuerbüro: nur Angestellte, Excel-tauglich, Mitarbeiter kommen nicht heran (M5)", async () => {
const heute = new Date().toISOString().slice(0, 10);
const monat = heute.slice(0, 7);
const r = await als(inhaber, "GET", `/api/zeiten/csv?monat=${monat}`);
expect(r.statusCode, r.body).toBe(200);
expect(r.headers["content-type"]).toMatch(/text\/csv/);
expect(r.headers["content-disposition"]).toContain(`stunden-${monat}.csv`);
expect(r.rawPayload[0]).toBe(0xef); // BOM, damit Excel die Umlaute richtig liest
const zeilen = r.body.replace(/^\uFEFF/, "").split("\r\n");
expect(zeilen[0]).toBe("Personalnr.;Name;Datum;Tag;Beginn;Ende;Pause Min.;Arbeitszeit Std.;Soll Std.;Abwesenheit;Abwesend Std.;Baustellen;Bemerkung");
const d = `${heute.slice(8, 10)}.${heute.slice(5, 7)}.${heute.slice(0, 4)}`;
const tag = zeilen.find((z) => z.startsWith("18;Jan Zimmermann;" + d))!;
expect(tag).toMatch(/;07:00;15:30;30;8,00;/);
expect(tag).toMatch(/"P-26-101 Abbund 5,00; P-26-102 3,00";$/);
expect(zeilen.some((z) => z.startsWith("18;Jan Zimmermann;Summe "))).toBe(true);
expect(r.body).not.toContain("Henning");
expect((await als(inhaber, "GET", "/api/zeiten/csv?monat=2026-13")).statusCode).toBe(400);
const b = await anmelden("buero", "buero12345");
expect((await als(b, "GET", `/api/zeiten/csv?monat=${monat}`)).statusCode).toBe(200);
const jj = await anmelden("jan", "neuespasswort");
expect((await als(jj, "GET", `/api/zeiten/csv?monat=${monat}`)).statusCode).toBe(403);
});
it("Urlaubsantrag: Mitarbeiter beantragt, sieht Rest und Einsätze, Henning entscheidet mit Antwort (M10)", async () => {
// drei Arbeitstage Di–Do ohne Feiertag, mindestens 60 Tage voraus
const plus = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10);
let von = plus(new Date().toISOString().slice(0, 10), 60);
while (new Date(`${von}T00:00:00Z`).getUTCDay() !== 2 || [0, 1, 2].some((i) => feiertag(plus(von, i)))) von = plus(von, 1);
const bis = plus(von, 2);
const jj = await anmelden("jan", "neuespasswort");
const konto = (await als(jj, "GET", "/api/ich/urlaub")).json();
expect(konto.konto).toHaveProperty("rest");
const p = await als(jj, "GET", `/api/ich/urlaub/pruefen?von=${von}&bis=${bis}`);
expect(p.statusCode, p.body).toBe(200);
expect(p.json()).toMatchObject({ tage: 3, einsaetze: [] });
expect((await als(jj, "POST", "/api/ich/urlaub", { von: "2020-01-07", bis: "2020-01-08" })).statusCode).toBe(400);
expect((await als(jj, "POST", "/api/ich/urlaub", { von, bis, halbtag: true })).statusCode).toBe(400);
const samstag = plus(von, 4);
expect((await als(jj, "POST", "/api/ich/urlaub", { von: samstag, bis: plus(samstag, 1) })).json().fehler).toMatch(/keine Arbeitstage/);
const a = await als(jj, "POST", "/api/ich/urlaub", { von, bis, notiz: "Hochzeit" });
expect(a.statusCode, a.body).toBe(201);
expect(a.json()).toMatchObject({ status: "beantragt", tage: 3, kontakt_id: expect.any(String) });
expect((await als(jj, "POST", "/api/ich/urlaub", { von: bis, bis: bis })).statusCode).toBe(409);
// beantragt sperrt noch nichts
const jan = a.json().kontakt_id;
expect((await als(inhaber, "GET", `/api/verfuegbarkeit?von=${von}&bis=${von}&kontakt_id=${jan}`)).json()[0].tage[0].frei).toBe(8);
const u = (await als(inhaber, "GET", "/api/uebersicht")).json();
expect(u.warnungen[0]).toMatchObject({ art: "urlaub", ziel: `mitarbeiter-${jan}`, text: expect.stringMatching(/^Urlaubsantrag von Jan Zimmermann: /) });
const b = await anmelden("buero", "buero12345");
const offen = (await als(b, "GET", "/api/urlaub/antraege")).json();
expect(offen).toHaveLength(1);
expect(offen[0]).toMatchObject({ name: "Jan Zimmermann", tage: 3, notiz: "Hochzeit" });
expect(offen[0].rest_danach).toBe(offen[0].rest_vorher - 3);
expect((await als(jj, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "genehmigt" })).statusCode).toBe(403);
expect((await als(jj, "GET", "/api/urlaub/antraege")).statusCode).toBe(403);
const ok = await als(inhaber, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "genehmigt", antwort: "Viel Spaß!" });
expect(ok.statusCode, ok.body).toBe(200);
expect((await als(inhaber, "POST", `/api/urlaub/${a.json().id}/entscheidung`, { status: "abgelehnt" })).statusCode).toBe(409);
const meine = (await als(jj, "GET", "/api/ich/urlaub")).json();
expect(meine.antraege.find((x: { id: string }) => x.id === a.json().id)).toMatchObject({ status: "genehmigt", antwort: "Viel Spaß!", tage: 3 });
expect((await als(jj, "DELETE", `/api/ich/urlaub/${a.json().id}`)).statusCode).toBe(409);
expect((await als(inhaber, "GET", `/api/verfuegbarkeit?von=${von}&bis=${von}&kontakt_id=${jan}`)).json()[0].tage[0].frei).toBe(0);
expect((await als(inhaber, "GET", "/api/uebersicht")).json().warnungen.some((w: { art: string }) => w.art === "urlaub")).toBe(false);
// zweiter Antrag, zurückgezogen
const z = await als(jj, "POST", "/api/ich/urlaub", { von: plus(von, 7), halbtag: true });
expect(z.statusCode, z.body).toBe(201);
expect(z.json()).toMatchObject({ bis: plus(von, 7), halbtag: true, tage: 0.5 });
expect((await als(jj, "DELETE", `/api/ich/urlaub/${z.json().id}`)).statusCode).toBe(204);
});
it("Dauer aus Stunden und Besetzung, Auslastung im Terminplan (T15, T16)", async () => {
const tp = (await als(inhaber, "GET", "/api/terminplan")).json();
const abschnitt = tp.vorgaenge.find((v: { name: string }) => v.name === "Abbund").abschnitt_id;
// ein Montag gut vier Monate voraus, die Woche ohne Feiertag
const plus = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10);
let start = plus(new Date().toISOString().slice(0, 10), 120);
while (new Date(`${start}T00:00:00Z`).getUTCDay() !== 1 || [0, 1, 2, 3, 7].some((i) => feiertag(plus(start, i)))) start = plus(start, 1);
const v = (await als(inhaber, "POST", "/api/vorgaenge", { abschnitt_id: abschnitt, name: "Dach decken", start, dauer: 1, stunden: 32 })).json();
expect(v.dauer_fest).toBe(false);
const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id;
expect((await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, kontakt_id: jan })).statusCode).toBe(201);
const lies = async () => (await als(inhaber, "GET", "/api/terminplan")).json().vorgaenge.find((x: { id: string }) => x.id === v.id);
expect(await lies()).toMatchObject({ dauer: 4, dauer_besetzung: 4, ende: plus(start, 3) }); // Jan Mo–Do je 8 Std.
// zweite Person: halb so lang
const kolonne = (await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, platzhalter: "Helfer", personen: 1 })).json();
expect((await lies()).dauer).toBe(2);
await als(inhaber, "DELETE", `/api/besetzungen/${kolonne.id}`);
// genehmigter Urlaub am Dienstag: einen Tag länger, Balken an dem Tag heller
const u = (await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "frei", von: plus(start, 1), bis: plus(start, 1), status: "genehmigt" })).json();
expect(await lies()).toMatchObject({ dauer: 5, reduziert: [plus(start, 1)] });
await als(inhaber, "DELETE", `/api/abwesenheiten/${u.id}`);
expect((await lies()).dauer).toBe(4);
// von Hand geändert: Dauer fest, die Berechnung bleibt als Abweichung sichtbar
const fest = await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer: 6 });
expect(fest.json()).toMatchObject({ dauer: 6, dauer_fest: true });
expect(await lies()).toMatchObject({ dauer: 6, dauer_besetzung: 4, dauer_fest: true });
expect((await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer_fest: false })).statusCode).toBe(200);
expect((await lies()).dauer).toBe(4);
// Auslastung: Jan steht im Team, die Woche des Vorgangs zählt seine 32 Stunden als geplant
const plan = (await als(inhaber, "GET", "/api/terminplan")).json();
expect(plan.team).toContain(jan);
const w = plan.auslastung.find((x: { ab: string }) => x.ab === start);
expect(w.personen.find((x: { kontakt_id: string }) => x.kontakt_id === jan).geplant).toBe(32);
});
it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => {
const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id;
await pool.query("update benutzer set aktiv = true where id = $1", [jan]);
expect((await t.inject("/api/projekte")).statusCode).toBe(200);
expect((await t.inject({ url: "/api/projekte", headers: { "x-test-benutzer": jan } })).statusCode).toBe(403);
expect((await t.inject({ url: "/api/sitzung", headers: { "x-test-benutzer": jan } })).json()).toMatchObject({ art: "testversion", benutzer: { anmeldename: "jan" } });
expect((await t.inject({ method: "POST", url: "/api/anmeldung", payload: { anmeldename: "jan", passwort: "neuespasswort" } })).statusCode).toBe(400);
await t.close();
});
});
describe.skipIf(!url)("Zahlungen, Kosten und Aufgaben im Terminplan", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const neu = async (pfad: string, body: object) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const aendern = async (pfad: string, body: object) => {
const r = await app.inject({ method: "PATCH", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(200);
return r.json();
};
const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json();
it("Aufgaben aus der Vorlage hängen am Vorgang und wandern mit; gelöschte kommen nicht wieder", async () => {
const p = await neu("projekte", { nummer: "P-26-200", bezeichnung: "Carport Lindenweg", status: "angebot" });
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
const abbund = await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2027-03-08", dauer: 3 });
// nur beauftragte Projekte bekommen Vorlage-Aufgaben
expect((await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(0);
await aendern(`projekte/${p.id}`, { status: "auftrag" });
const auf = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id);
// Gerüst wartet auf einen Vorgang „Richten“
expect(auf.map((x: { text: string }) => x.text).sort()).toEqual(["Material bestellen", "Statik anfordern", "Subunternehmer beauftragen"]);
const material = auf.find((x: { text: string }) => x.text === "Material bestellen");
// 7 Arbeitstage (Mo–Do) vor Montag, 8.3.2027
expect(material).toMatchObject({ vorgang_id: abbund.id, bezug_art: "AA", bezug_tage: -7, faellig_am: "2027-02-23" });
// Abbund eine Woche später: die Aufgabe geht mit
await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-15" });
expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-02");
// Fälligkeit von Hand (Raute gezogen): neuer Versatz, bleibt verknüpft
expect(await aendern(`aufgaben/${material.id}`, { faellig_am: "2027-03-08" })).toMatchObject({ vorgang_id: abbund.id, bezug_tage: -4 });
await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-22" });
expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-15");
// erledigt: bleibt stehen
await aendern(`aufgaben/${material.id}`, { erledigt_am: "2026-10-20T10:00:00Z" });
await aendern(`vorgaenge/${abbund.id}`, { start: "2027-03-29" });
expect((await hole(`aufgaben/${material.id}`)).faellig_am).toBe("2027-03-15");
// Richten kommt dazu: jetzt auch das Gerüst
await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2027-04-05", dauer: 1 });
const statik = auf.find((x: { text: string }) => x.text === "Statik anfordern");
await app.inject({ method: "DELETE", url: `/api/aufgaben/${statik.id}` });
expect((await app.inject({ method: "POST", url: "/api/vorlage/anwenden" })).json()).toEqual({ neu: 0 });
const jetzt = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id).map((x: { text: string }) => x.text).sort();
expect(jetzt).toEqual(["Gerüst bestellen", "Material bestellen", "Subunternehmer beauftragen"]);
// im Terminplan stehen sie beim Projekt
expect((await hole("terminplan")).aufgaben.filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(3);
});
it("neue Vorlage-Einträge gelten auch für laufende Projekte; schon angefangene Vorgänge bekommen keine Aufgabe mehr", async () => {
const p = await neu("projekte", { nummer: "P-26-201", bezeichnung: "Gaube Bergstraße", status: "ausfuehrung" });
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2026-01-05", dauer: 2 });
await neu("vorgaenge", { abschnitt_id: a.id, name: "Dämmung", start: "2027-05-03", dauer: 2 });
expect((await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id)).toHaveLength(0);
const e = await hole("einstellungen");
const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, aufgabenVorlage: [...e.aufgabenVorlage,
{ id: "daemmung", text: "Dämmstoff abrufen", bezug: "dämm", art: "AA", tage: -3, kategorie_id: null }] } });
expect(r.statusCode, r.body).toBe(200);
const auf = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === p.id);
expect(auf).toMatchObject([{ text: "Dämmstoff abrufen", faellig_am: "2027-04-27" }]);
// schon überfällig: kommt nicht (Vorgang in drei Tagen, Aufgabe 15 Arbeitstage davor)
const q = await neu("projekte", { nummer: "P-26-204", bezeichnung: "Vordach Kirchweg", status: "auftrag" });
const qa = await neu("abschnitte", { projekt_id: q.id, name: "Bauablauf" });
const bald = new Date(Date.now() + 3 * 86400000).toISOString().slice(0, 10);
await neu("vorgaenge", { abschnitt_id: qa.id, name: "Abbund", start: bald, dauer: 2 });
const texte = (await hole("aufgaben")).filter((x: { projekt_id: string }) => x.projekt_id === q.id).map((x: { text: string }) => x.text);
expect(texte).not.toContain("Statik anfordern");
});
it("Kosten und Raten hängen mit Versatz am Vorgang; Liquidität folgt", async () => {
const p = await neu("projekte", { nummer: "P-26-202", bezeichnung: "Anbau Seeweg", status: "auftrag", umsatz_netto: 1_000_000 });
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Montage", start: "2027-06-07", dauer: 4 });
const k = await neu("kosten", { projekt_id: p.id, art: "material", bezeichnung: "Holz", netto: 300_000, termin: "2027-06-01", vorgang_id: v.id, bezug_art: "AA", bezug_tage: -2 });
expect((await hole(`kosten/${k.id}`)).termin).toBe("2027-06-02");
await aendern(`vorgaenge/${v.id}`, { start: "2027-06-14" });
expect((await hole(`kosten/${k.id}`)).termin).toBe("2027-06-09");
const tp = await hole("terminplan");
expect(tp.kosten.find((x: { id: string }) => x.id === k.id)).toMatchObject({ vorgang_id: v.id, bezug_art: "AA", bezug_tage: -2 });
// Raten: EE mit Versatz
const z = (await hole("zahlungen")).filter((x: { projekt_id: string }) => x.projekt_id === p.id);
expect(z).toHaveLength(4);
const schluss = z.find((x: { art: string }) => x.art === "schluss");
await aendern(`zahlungen/${schluss.id}`, { termin: "2027-06-23" });
expect((await hole(`zahlungen/${schluss.id}`))).toMatchObject({ vorgang_id: v.id, bezug_art: "EE", bezug_tage: 3 });
await aendern(`vorgaenge/${v.id}`, { start: "2027-06-21" });
expect((await hole(`zahlungen/${schluss.id}`)).termin).toBe("2027-06-30");
// Freitag: ohne Freigabe rutscht die Raute auf Montag, mit Freigabe bleibt sie auf dem Freitag und wandert so mit
await aendern(`zahlungen/${schluss.id}`, { termin: "2027-06-25" });
expect((await hole(`zahlungen/${schluss.id}`)).termin).toBe("2027-06-28");
await aendern(`zahlungen/${schluss.id}`, { termin: "2027-06-25", freitag: true });
expect((await hole(`zahlungen/${schluss.id}`))).toMatchObject({ termin: "2027-06-25", bezug_tage: 1, freitag: true });
await aendern(`vorgaenge/${v.id}`, { start: "2027-06-28" });
expect((await hole(`zahlungen/${schluss.id}`)).termin).toBe("2027-07-02");
});
it("Schlussrechnung ohne Betrag ist der Rest aus Auftragswert und allen anderen Raten", async () => {
const p = await neu("projekte", { nummer: "P-26-203", bezeichnung: "Dachsanierung Mühlenweg", umsatz_netto: 5_000_000 });
await neu("zahlungen", { projekt_id: p.id, art: "anzahlung", bezeichnung: "Anzahlung", netto: 1_500_000, termin: "2027-01-04", status: "bezahlt" });
const ab = await neu("zahlungen", { projekt_id: p.id, art: "abschlag", bezeichnung: "1. Abschlag", netto: 2_000_000, termin: "2027-02-01", status: "gestellt" });
const s = await neu("zahlungen", { projekt_id: p.id, art: "schluss", bezeichnung: "Schlussrechnung", netto: 0, rest: true, termin: "2027-03-01" });
expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_500_000);
await aendern(`zahlungen/${ab.id}`, { netto: 2_500_000 });
expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_000_000);
await aendern(`projekte/${p.id}`, { umsatz_netto: 5_600_000 });
expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_600_000);
// eigener Betrag: nicht mehr automatisch
await aendern(`zahlungen/${s.id}`, { netto: 1_200_000, rest: false });
await aendern(`projekte/${p.id}`, { umsatz_netto: 6_000_000 });
expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_200_000);
});
});
describe.skipIf(!url)("Kolonnen und Subunternehmer (0.15)", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const neu = async (pfad: string, body: object) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const aendern = async (pfad: string, body: object) => {
const r = await app.inject({ method: "PATCH", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(200);
return r.json();
};
const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json();
type K = { kontakt_id: string; besetzung_teil: string; netto: number; termin: string; zahlungsziel_tage: number | null; automatisch: boolean; id: string; bezeichnung: string };
const subKosten = async (id: string) => ((await hole("kosten")) as K[]).filter((k) => k.kontakt_id === id).sort((a, b) => a.besetzung_teil.localeCompare(b.besetzung_teil));
it("Kolonne als eine Ressource: zählt mit allen Mitgliedern, mit Subunternehmer erst nach Freigabe", async () => {
const anna = await neu("kontakte", { name: "Anna Holz", rolle: "mitarbeiter" });
const ben = await neu("kontakte", { name: "Ben Balken", rolle: "mitarbeiter" });
const sub = await neu("kontakte", { name: "Jan Meier", firma: "Meier Dach GmbH", rolle: "subunternehmer" });
await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 5000, kolonnengroesse: 2 });
const k1 = await neu("kolonnen", { name: "Kolonne 1", leitung_kontakt_id: anna.id });
for (const m of [anna, ben]) await neu("kolonnen-mitglieder", { kolonne_id: k1.id, kontakt_id: m.id });
const p = await neu("projekte", { nummer: "P-26-300", bezeichnung: "Halle Nord", status: "auftrag" });
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
// 64 Stunden mit zwei Leuten à 8 Std. = 4 Arbeitstage
const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2027-03-08", dauer: 1, stunden: 64, dauer_fest: false });
const b = await neu("besetzungen", { vorgang_id: v.id, kolonne_id: k1.id });
expect(b.freigegeben).toBe(true);
expect((await hole(`vorgaenge/${v.id}`)).dauer).toBe(4);
// ein Mitarbeiter der Kolonne zugleich direkt auf einem anderen Vorgang: Überschneidung
const v2 = await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2027-03-09", dauer: 1 });
await neu("besetzungen", { vorgang_id: v2.id, kontakt_id: ben.id });
const tp = await hole("terminplan");
expect(tp.ueberschneidungen.some((u: { wer: string }) => u.wer === ben.id)).toBe(true);
expect(tp.besetzungen.find((x: { id: string }) => x.id === b.id)).toMatchObject({ anzeige: "Kolonne 1", mitglieder: [anna.id, ben.id] });
// Kolonne mit Subunternehmer: nur vorgemerkt
const k2 = await neu("kolonnen", { name: "Dachkolonne" });
await neu("kolonnen-mitglieder", { kolonne_id: k2.id, kontakt_id: sub.id });
const b2 = await neu("besetzungen", { vorgang_id: v2.id, kolonne_id: k2.id });
expect(b2.freigegeben).toBe(false);
// Person, Platzhalter oder Kolonne, nie zwei davon
const r = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: v.id, kolonne_id: k1.id, kontakt_id: anna.id } });
expect(r.statusCode).toBeGreaterThanOrEqual(400);
});
it("Einsatz eines Subunternehmers wird zur Ausgabe mit Skonto, Einbehalt und Zahlungsziel", async () => {
const sub = await neu("kontakte", { name: "Kai Kran", firma: "Kran Kai", rolle: "subunternehmer" });
await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 6000, helfersatz: 4000, zahlungsziel_tage: 14, skonto_prozent: 2, skonto_tage: 7, einbehalt_prozent: 5 });
const p = await neu("projekte", { nummer: "P-26-301", bezeichnung: "Carport", status: "auftrag" });
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2027-03-08", dauer: 2 });
const b = await neu("besetzungen", { vorgang_id: v.id, kontakt_id: sub.id, personen: 2 });
// vorgemerkt: noch keine Kosten
expect(await subKosten(sub.id)).toHaveLength(0);
await aendern(`besetzungen/${b.id}`, { freigegeben: true });
// 2 Tage × 8 Std. × (60 € + 40 €) = 1.600 €; 2 % Skonto = 1.568 €; davon 5 % Einbehalt = 78,40 €
let [einbehalt, leistung] = await subKosten(sub.id);
expect(leistung).toMatchObject({ netto: 148960, termin: "2027-03-09", zahlungsziel_tage: 7, automatisch: true });
expect(einbehalt).toMatchObject({ netto: 7840, termin: "2032-03-09" });
// Vorgang länger: Kosten und Termin gehen mit
await aendern(`vorgaenge/${v.id}`, { dauer: 3 });
[einbehalt, leistung] = await subKosten(sub.id);
expect(leistung).toMatchObject({ netto: 223440, termin: "2027-03-10" });
// Betrag von Hand: bleibt fest
await aendern(`kosten/${leistung.id}`, { netto: 200000 });
await aendern(`vorgaenge/${v.id}`, { dauer: 4 });
[einbehalt, leistung] = await subKosten(sub.id);
expect(leistung).toMatchObject({ netto: 200000, automatisch: false });
expect(einbehalt.netto).toBe(15680);
// Einsatz entfernt: geplante automatische Kosten verschwinden, die von Hand geänderte bleibt
await app.inject({ method: "DELETE", url: `/api/besetzungen/${b.id}` });
const rest = await subKosten(sub.id);
expect(rest.map((k) => k.netto)).toEqual([200000]);
// Einbehalt steht nicht im Terminplan
expect((await hole("terminplan")).kosten.some((k: { bezeichnung: string }) => k.bezeichnung.includes("Sicherheitseinbehalt"))).toBe(false);
});
it("Übersicht warnt vor fehlender oder ablaufender Freistellungsbescheinigung", async () => {
const sub = await neu("kontakte", { name: "Olaf Ohne", rolle: "subunternehmer" });
await neu("subunternehmer", { kontakt_id: sub.id, freistellung_bis: "2027-03-20" });
const u = await hole("uebersicht?heute=2027-03-01");
expect(u.warnungen).toContainEqual(expect.objectContaining({ art: "freistellung", ziel: `subunternehmer-${sub.id}`, text: expect.stringContaining("läuft am 20.03.2027 ab") }));
const u2 = await hole("uebersicht?heute=2027-03-21");
expect(u2.warnungen).toContainEqual(expect.objectContaining({ text: expect.stringContaining("Olaf Ohne ist seit 20.03.2027 abgelaufen") }));
});
});
describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const neu = async (pfad: string, body: object) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const post = (pfad: string, body: object = {}) => app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json();
it("Angebot anlegen, kalkulieren, prüfen, versenden, annehmen: Auftrag mit Abschnitten und Zahlungsplan (A4, A14, A19, A36)", async () => {
const bauherr = await neu("kontakte", { name: "Familie Krause", rolle: "bauherr" });
const p = await neu("projekte", { nummer: "A-26-130", bezeichnung: "Carport Krause", status: "anfrage" });
const a = await neu("angebote/neu", { projekt_id: p.id });
expect(a).toMatchObject({ nummer: "A-26-130", status: "entwurf", saetze: { stundensaetze: { geselle: 5831 } } });
expect(a.bindefrist > a.datum).toBe(true);
expect((await hole(`projekte/${p.id}`)).status).toBe("angebot");
const zweites = await neu("angebote/neu", { projekt_id: p.id });
expect(zweites.nummer).toBe("A-26-131");
const t1 = await neu("angebot-titel", { angebot_id: a.id, bezeichnung: "Abbund", reihenfolge: 0 });
const t2 = await neu("angebot-titel", { angebot_id: a.id, bezeichnung: "Montage", reihenfolge: 1 });
const p1 = await neu("angebot-positionen", { angebot_id: a.id, titel_id: t1.id, kurztext: "Abbund KVH", menge: 100, einheit: "m" });
await neu("angebot-kosten", { position_id: p1.id, kostenart: "lohn", lohnart: "geselle", menge: 0.2 });
await neu("angebot-kosten", { position_id: p1.id, kostenart: "material", menge: 1, ek: 420, faktor: 1.1, beschreibung: "KVH 8/16" });
const p2 = await neu("angebot-positionen", { angebot_id: a.id, titel_id: t2.id, kurztext: "Richten", menge: 1, einheit: "Stk." });
await neu("angebot-kosten", { position_id: p2.id, kostenart: "lohn", lohnart: "geselle", menge: 24 });
const voll = await hole(`angebote/${a.id}/voll`);
expect(voll.ergebnis.stunden).toBe(44);
// Dokumentansicht: USt-Satz für die Summe und Leistungsort aus dem Projekt
expect(voll.ust_satz).toBe(19);
expect(voll.angebot).toHaveProperty("baustelle_ort");
expect(voll.ergebnis.netto).toBe(voll.ergebnis.titel[t1.id] + voll.ergebnis.titel[t2.id]);
expect(voll.pruefung.map((x: { text: string }) => x.text)).toEqual(expect.arrayContaining([
expect.stringContaining("kein Bauherr"), expect.stringContaining("„Stk.“ bitte als „St“"),
]));
// mit Fehler nur „trotzdem“; danach ist das Angebot gesperrt
expect((await post(`angebote/${a.id}/versenden`)).json()).toMatchObject({ versendet: false });
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { bauherr_id: bauherr.id } });
await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${p2.id}`, payload: { einheit: "St" } });
expect((await post(`angebote/${a.id}/versenden`)).json()).toMatchObject({ versendet: true, pruefung: [] });
const gesperrt = await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${p1.id}`, payload: { menge: 120 } });
expect(gesperrt.statusCode).toBe(409);
expect(gesperrt.json().fehler).toMatch(/versendet/);
expect((await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { notiz: "Kunde ruft Freitag an" } })).statusCode).toBe(200);
// Stundensätze ändern wirkt nicht auf das bestehende Angebot (A36)
const e = await hole("einstellungen");
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, kalkulation: { ...e.kalkulation, stundensaetze: { ...e.kalkulation.stundensaetze, geselle: 9000 } } } });
expect((await hole(`angebote/${a.id}/voll`)).ergebnis.netto).toBe(voll.ergebnis.netto);
const r = await post(`angebote/${a.id}/annehmen`, { start: "2026-11-02" });
expect(r.statusCode, r.body).toBe(200);
expect(r.json()).toMatchObject({ nummer: "P-26-130", umsatz: voll.ergebnis.netto, abschnitte: 2 });
const proj = await hole(`projekte/${p.id}`);
expect(proj).toMatchObject({ status: "auftrag", nummer: "P-26-130", umsatz_netto: voll.ergebnis.netto, soll_stunden: 44 });
const tp = await hole("terminplan");
const vs = tp.vorgaenge.filter((v: { abschnitt_id: string }) => tp.abschnitte.some((x: { id: string; projekt_id: string }) => x.id === v.abschnitt_id && x.projekt_id === p.id));
expect(vs.map((v: { name: string; stunden: number; dauer: number }) => [v.name, v.stunden, v.dauer])).toEqual([["Abbund", 20, 2], ["Montage", 24, 2]]);
expect(vs[1].start > vs[0].start).toBe(true);
const raten = (await hole("zahlungen")).filter((z: { projekt_id: string }) => z.projekt_id === p.id);
expect(raten.reduce((s: number, z: { netto: number }) => s + z.netto, 0)).toBe(voll.ergebnis.netto);
const ang = await hole(`angebote/${a.id}`);
expect(ang.staende.map((s: { anlass: string }) => s.anlass)).toEqual(["versand", "auftrag"]);
expect(ang.staende[1].netto).toBe(voll.ergebnis.netto);
expect((await app.inject({ method: "DELETE", url: `/api/angebote/${a.id}` })).statusCode).toBe(409);
expect((await post(`angebote/${a.id}/annehmen`)).statusCode).toBe(409);
});
it("Bindefrist: Erinnerung auf der Startseite 5 Tage vorher und Termin im Aufgaben-Kalender (A35)", async () => {
const p = await neu("projekte", { nummer: "A-26-140", bezeichnung: "Dachgaube Lüders" });
const a = await neu("angebote/neu", { projekt_id: p.id });
const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Gaube pauschal", menge: 1, einheit: "psch", ep_fest: 850000 });
expect(pos.id).toBeTruthy();
await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { bindefrist: "2026-12-10" } });
await post(`angebote/${a.id}/versenden`, { trotzdem: true });
expect((await hole("uebersicht?heute=2026-12-01")).warnungen.some((w: { art: string }) => w.art === "angebot")).toBe(false);
const u = await hole("uebersicht?heute=2026-12-05");
expect(u.warnungen).toContainEqual(expect.objectContaining({ art: "angebot", ziel: `angebot-${a.id}`, text: expect.stringContaining("endet am 10.12.2026") }));
// eine Kopie als neue Version übernimmt Positionen, bekommt eine neue Nummer und die heutigen Sätze
const kopie = await neu("angebote/neu", { projekt_id: p.id, von_angebot_id: a.id });
expect(kopie.nummer).not.toBe(a.nummer);
expect((await hole(`angebote/${kopie.id}/voll`)).ergebnis.netto).toBe(850000);
expect((await post(`angebote/${a.id}/ablehnen`)).statusCode).toBe(200);
expect((await hole("uebersicht?heute=2026-12-05")).warnungen.some((w: { art: string }) => w.art === "angebot")).toBe(false);
});
it("Mengenblatt, Musterpositionen und Bausteine: einfügen unter der markierten Zeile, Bezug rechnet mit, eigene Vorlage (A22, A23)", async () => {
const p = await neu("projekte", { nummer: "A-26-150", bezeichnung: "Dachstuhl Petersen" });
const a = await neu("angebote/neu", { projekt_id: p.id });
expect(a.saetze.mengen).toEqual({ verschnitt: 10, oeffnung_ab: 2.5 });
const t = (await post(`angebote/${a.id}/einfuegen`, { was: "titel" })).json();
const erste = (await post(`angebote/${a.id}/einfuegen`, { was: "position", titel_id: t.id })).json();
const letzte = (await post(`angebote/${a.id}/einfuegen`, { was: "text", nach_id: erste.id })).json();
// Musterposition Pfettendach mit geänderter Pfettenlänge zwischen die beiden Zeilen
const r = await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "std-pfettendach", nach_id: erste.id, eingaben: { LP: "12" } });
expect(r.statusCode, r.body).toBe(201);
const voll = await hole(`angebote/${a.id}/voll`);
const reihe = voll.positionen.filter((x: { titel_id: string }) => x.titel_id === t.id).sort((x: { reihenfolge: number }, y: { reihenfolge: number }) => x.reihenfolge - y.reihenfolge).map((x: { id: string }) => x.id);
expect(reihe).toEqual([erste.id, r.json().id, letzte.id]);
const pf = voll.positionen.find((x: { id: string }) => x.id === r.json().id);
expect(pf).toMatchObject({ kurztext: expect.stringContaining("Pfettendach"), einheit: "m", mit_aufmass: true, mit_kalkulation: true });
expect(Number(pf.menge)).toBe(213);
const erg = voll.ergebnis.positionen[pf.id];
expect(erg.menge).toBe(213);
// Abbund = HL × 0,03 Std × 2 Personen
const abbund = voll.kosten.filter((k: { position_id: string }) => k.position_id === pf.id).findIndex((k: { beschreibung: string }) => k.beschreibung === "Abbund");
expect(erg.kostenzeilen[abbund].menge_gesamt).toBeCloseTo(213 * 0.03 * 2, 4);
expect(voll.pruefung.some((x: { text: string }) => /Material .* hat keinen Preis/.test(x.text))).toBe(true);
// Aufmaß ändern: Menge und Stunden folgen
const blatt = { ...pf.aufmass, zeilen: [], werte: pf.aufmass.werte.map((w: { kz: string }) => (w.kz === "LP" ? { ...w, formel: "10" } : w)) };
expect((await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${pf.id}`, payload: { aufmass: blatt } })).statusCode).toBe(200);
expect((await hole(`angebote/${a.id}/voll`)).ergebnis.positionen[pf.id].menge).toBe(200);
// freie Position mit Aufmaßzeilen, ohne Kalkulation
const blech = (await post(`angebote/${a.id}/einfuegen`, { was: "position", nach_id: pf.id })).json();
await app.inject({ method: "PATCH", url: `/api/angebot-positionen/${blech.id}`, payload: { mit_aufmass: true, ep_fest: 4850, einheit: "m²",
aufmass: { werte: [], listen: [], zeilen: [{ text: "Nordseite", formel: "10 * 0,3" }, { text: "Giebel", formel: "4 * (8/2/cos(31)) * 0,3" }] } } });
const v2 = await hole(`angebote/${a.id}/voll`);
expect(v2.ergebnis.positionen[blech.id].menge).toBeCloseTo(3 + 4 * (4 / Math.cos((31 * Math.PI) / 180)) * 0.3, 3);
// als eigene Musterposition speichern und in eine neue Zeile einfügen; die Kostenzeilen kommen mit
const mv = await post(`angebot-positionen/${pf.id}/als-vorlage`, { name: "Mein Pfettendach", gruppe: "Dach", art: "muster" });
expect(mv.statusCode, mv.body).toBe(201);
expect(mv.json().inhalt.ansaetze.length).toBe(v2.kosten.filter((k: { position_id: string }) => k.position_id === pf.id).length);
expect((await hole("mengenvorlagen-alle")).some((v: { id: string; fest: boolean }) => v.id === mv.json().id && !v.fest)).toBe(true);
const kopie = (await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: mv.json().id })).json();
const v3 = await hole(`angebote/${a.id}/voll`);
expect(v3.ergebnis.positionen[kopie.id].ep).toBe(v3.ergebnis.positionen[pf.id].ep);
// Mengenvorlage in eine bestehende Position: ersetzt die Kostenzeilen aus der alten Vorlage, eigene bleiben
await neu("angebot-kosten", { position_id: kopie.id, kostenart: "sonstiges", menge: 1, ek: 1000, beschreibung: "Eigene Zeile" });
await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "std-satteldach", position_id: kopie.id });
const v4 = await hole(`angebote/${a.id}/voll`);
expect(v4.kosten.filter((k: { position_id: string }) => k.position_id === kopie.id).map((k: { beschreibung: string }) => k.beschreibung)).toEqual(["Eigene Zeile"]);
expect(v4.positionen.find((x: { id: string }) => x.id === kopie.id).aufmass.vorlage.id).toBe("std-satteldach");
expect((await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: "gibt-es-nicht" })).statusCode).toBe(409);
});
it("Subunternehmer als Kostenart: beim Annehmen werden seine Kosten Fremdleistung", async () => {
const p = await neu("projekte", { nummer: "A-26-160", bezeichnung: "Gerüst Hansen" });
const a = await neu("angebote/neu", { projekt_id: p.id });
const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Gerüst stellen", menge: 100, einheit: "m²" });
await neu("angebot-kosten", { position_id: pos.id, kostenart: "subunternehmer", menge: 1, ek: 800, beschreibung: "Gerüstbau Petersen" });
const voll = await hole(`angebote/${a.id}/voll`);
expect(voll.ergebnis.kosten).toBe(80000);
await post(`angebote/${a.id}/versenden`, { trotzdem: true });
expect((await post(`angebote/${a.id}/annehmen`, { start: "2026-11-02" })).statusCode).toBe(200);
expect((await hole(`projekte/${p.id}`)).fremd_kosten).toBe(80000);
});
it("Stammdaten: GAEB in Ordner, Artikel mit Rabatt, Leistung mit Artikel rechnet neu, Angebot behält den Preis", async () => {
const x84 = readFileSync(new URL("./daten/beispiel.x84", import.meta.url), "utf8");
const g = await post("leistungen/gaeb", { dateiname: "Leistungen-2026.x84", text: x84 });
expect(g.statusCode, g.body).toBe(201);
expect(g.json()).toMatchObject({ neu: 3, aktualisiert: 0, titel: 3, mit_preis: 1 });
expect((await post("leistungen/gaeb", { dateiname: "Leistungen-2026.x84", text: x84 })).json()).toMatchObject({ neu: 0, aktualisiert: 3 });
expect((await post("leistungen/gaeb", { dateiname: "x.x84", text: "kein xml" })).statusCode).toBe(400);
const liste = await hole("leistungen");
const abbund = liste.find((l: { nummer: string }) => l.nummer === "03.01.0020");
expect(abbund).toMatchObject({ gruppe: "03 Konstruktionen / 03.01 Dachstuhl", herkunft: "gaeb", einheit: "m", ep: 2655, ep_fest: 2655, zeilen: 0 });
expect(liste.some((l: { herkunft: string }) => l.herkunft === "mitgeliefert")).toBe(true);
// Materialstamm: Rabattgruppe 30 %, EK = Listenpreis − Rabatt; L-Satz löscht
const imp = await post("artikel/import", { lieferant: "Holzhandel Nord", stand: "2026-10-14", rabatte: [{ rabattgruppe: "KVH", rabatt: 30 }],
artikel: [{ artikelnummer: "4711-0820", bezeichnung: "KVH C24 8/20", einheit: "m³", listenpreis: 55000, rabattgruppe: "KVH", warengruppe: "Bauholz / KVH" },
{ artikelnummer: "SPAX-6120", bezeichnung: "SPAX 6x120", einheit: "St", preiseinheit: 100, preisart: "netto", listenpreis: 3850 }] });
expect(imp.json()).toMatchObject({ neu: 2, geaendert: 0, rabatte: 1 });
const such = await hole("artikel-suche?q=kvh%208");
expect(such.anzahl).toBe(1);
const kvh = such.zeilen[0];
expect(Number(kvh.ek)).toBe(38500);
expect((await hole("artikel-uebersicht")).lieferanten).toEqual([{ lieferant: "Holzhandel Nord", anzahl: 2, stand: expect.anything() }]);
// Leistung bekommt eine Kalkulation mit Artikel: Material 0,016 m³ je m
const r = await app.inject({ method: "PATCH", url: `/api/mengenvorlagen/${abbund.id}`, payload: { ep_fest: null, inhalt: { werte: [], listen: [], zeilen: [], menge: null, ansaetze: [
{ kostenart: "lohn", lohnart: "geselle", beschreibung: "Abbund", menge: 0.1, personen: 1 },
{ kostenart: "material", beschreibung: "KVH 8/20", menge: 0.016, einheit: "m³", artikel_id: kvh.id, faktor: 1.1 },
] } } });
expect(r.statusCode, r.body).toBe(200);
const d1 = await hole(`leistungen/${abbund.id}`);
// Lohn 0,1 h × Stundensatz Geselle; Material 0,016 × 385 € × 1,1 = 6,776 €
const lohn = 0.1 * d1.saetze.stundensaetze.geselle;
expect(d1.ergebnis.kosten_je_einheit).toBe(Math.round(lohn + 677.6));
expect(d1.artikel[kvh.id]).toMatchObject({ ek_je_einheit: 38500 });
expect((await hole(`artikel/${kvh.id}/genutzt`)).map((x: { id: string }) => x.id)).toEqual([abbund.id]);
// ins Angebot: Kostenzeilen mit dem EK von heute
const p = await neu("projekte", { nummer: "A-26-170", bezeichnung: "Dach Stammdaten" });
const a = await neu("angebote/neu", { projekt_id: p.id });
const pos = (await post(`angebote/${a.id}/einfuegen`, { was: "vorlage", vorlage_id: abbund.id, menge: 120 })).json();
const v1 = await hole(`angebote/${a.id}/voll`);
expect(v1.positionen.find((x: { id: string }) => x.id === pos.id)).toMatchObject({ menge: 120, mit_aufmass: false, einheit: "m" });
expect(v1.kosten.filter((k: { position_id: string }) => k.position_id === pos.id).map((k: { ek: string | null }) => k.ek)).toEqual([null, 38500]);
expect((await hole(`leistungen/${abbund.id}`)).angebote.map((x: { nummer: string }) => x.nummer)).toEqual(["A-26-170"]);
// neuer Rabatt: Leistung rechnet neu, Angebot bleibt
expect((await post("lieferanten-rabatte/setzen", { lieferant: "Holzhandel Nord", rabattgruppe: "KVH", rabatt: 20 })).json()).toEqual({ artikel: 1 });
const kvh2 = (await hole("artikel-suche?q=4711")).zeilen[0];
expect([Number(kvh2.ek), Number(kvh2.ek_vorher)]).toEqual([44000, 38500]);
expect((await hole(`leistungen/${abbund.id}`)).ergebnis.kosten_je_einheit).toBe(Math.round(lohn + 0.016 * 44000 * 1.1));
expect((await hole(`angebote/${a.id}/voll`)).kosten.filter((k: { position_id: string }) => k.position_id === pos.id)[1].ek).toBe(38500);
// Preisänderung (P-Satz) und Löschen (L-Satz)
expect((await post("artikel/import", { lieferant: "Holzhandel Nord", preise: [{ artikelnummer: "4711-0820", preisart: "brutto", preis: 60000, rabatt: null }],
artikel: [{ artikelnummer: "SPAX-6120", bezeichnung: "SPAX", loeschen: true }] })).json()).toMatchObject({ neuer_preis: 1, geloescht: 1 });
expect(Number((await hole("artikel-suche?q=4711")).zeilen[0].ek)).toBe(48000);
// Auswahl: verschieben, Preis +10 %, kopieren, löschen
const ids = liste.filter((l: { herkunft: string }) => l.herkunft === "gaeb").map((l: { id: string }) => l.id);
expect((await post("leistungen/aktion", { ids, aktion: "verschieben", ordner: "Zimmererarbeiten" })).json()).toEqual({ anzahl: 3 });
const terrasse = liste.find((l: { nummer: string }) => l.nummer === "06.0010");
await app.inject({ method: "PATCH", url: `/api/mengenvorlagen/${terrasse.id}`, payload: { ep_fest: 5000 } });
expect((await post("leistungen/aktion", { ids: [terrasse.id], aktion: "preis", prozent: 10 })).json()).toEqual({ anzahl: 1 });
expect((await hole(`leistungen/${terrasse.id}`)).leistung.ep_fest).toBe(5500);
expect((await post("leistungen/aktion", { ids: [terrasse.id, "std-pfettendach"], aktion: "kopieren" })).json()).toEqual({ anzahl: 2 });
const nachKopie = await hole("leistungen");
expect(nachKopie.filter((l: { name: string }) => l.name.startsWith("Terrassenbelag Lärche"))).toHaveLength(2);
expect((await post("leistungen/aktion", { ids: [terrasse.id], aktion: "loeschen" })).json()).toMatchObject({ anzahl: 1 });
});
it("KI-Vorschlag: auf dem Server noch nicht eingerichtet, die Antwort wird geprüft", async () => {
const r = await post("ki", { text: "Satteldach" });
expect(r.statusCode).toBe(409);
expect(r.json().fehler).toMatch(/noch nicht eingerichtet/);
const { kiAnfrage, kiVorschlaege } = await import("../src/domain/ki.js");
expect(kiAnfrage("Dach", [{ id: "x1", kurztext: "Abbund", einheit: "m", ordner: "Dach" }])).toContain("x1 | Dach | Abbund | m");
expect(kiVorschlaege('Gern: [{"id":"x1","menge":"12,5","grund":"a"},{"id":"x1","menge":3},{"id":"erfunden","menge":1},{"id":"x2","menge":-1}]', new Set(["x1", "x2"])))
.toEqual([{ id: "x1", menge: 12.5, grund: "a" }, { id: "x2", menge: null, grund: "" }]);
});
it("+ Dokument: Nummernkreise, Sperren nach Belegkette, GAEB-Import, Übernahme und Ausschreibung ohne Preise (A7, A10, A11)", async () => {
const p = await neu("projekte", { nummer: "A-26-180", bezeichnung: "Dorfstraße", status: "anfrage" });
const kv = await neu("angebote/neu", { projekt_id: p.id, belegart: "kostenvoranschlag" });
expect(kv.nummer).toMatch(/^KV-\d{2}-001$/);
expect((await post(`angebote/${kv.id}/annehmen`, {})).statusCode).toBe(409);
const ab = await post("angebote/neu", { projekt_id: p.id, belegart: "auftragsbestaetigung" });
expect(ab.statusCode).toBe(409);
expect(ab.json().fehler).toMatch(/angenommenen Angebot/);
expect((await post("angebote/neu", { projekt_id: p.id, belegart: "nachtrag" })).statusCode).toBe(409);
const dekodiert = (n: string) => dateiText(new Uint8Array(readFileSync(new URL(`./daten/${n}`, import.meta.url))));
const x83 = { dateiname: "LV_Dorfstrasse.X83", text: dekodiert("dorfstrasse.x83") };
const v = (await post("gaeb/vorschau", { ...x83, projekt_id: p.id, belegart: "angebot" })).json();
expect(v).toMatchObject({ format: "GAEB DA XML", version: "3.3", phase: "83", phase_name: "Angebotsaufforderung", titel: 8, positionen: 59, passt: true });
const falsch = (await post("gaeb/vorschau", { ...x83, projekt_id: p.id, belegart: "lieferschein" })).json();
expect(falsch).toMatchObject({ passt: false, vorschlag: "angebot" });
// Angebot aus dem KV übernehmen: Verweis auf den Vorbeleg, eigene Nummer A-26-180
const a = await neu("angebote/neu", { projekt_id: p.id, belegart: "angebot", vorbeleg_id: kv.id, });
expect(a).toMatchObject({ nummer: "A-26-180", belegart: "angebot", vorbeleg_id: kv.id });
// zweites Angebot aus GAEB mit allen Titeln, Positionen und Langtexten
const g = await neu("angebote/neu", { projekt_id: p.id, belegart: "angebot", gaeb: x83 });
expect(g.quelle).toMatch(/GAEB DA XML Phase 83/);
expect(g.betreff).toBe("Dorfstraße 6, Buchholz");
const voll = await hole(`angebote/${g.id}/voll`);
expect(voll.titel).toHaveLength(8);
expect(voll.positionen).toHaveLength(59);
expect(voll.positionen.find((x: { oz: string }) => x.oz === "01.20")).toMatchObject({ kurztext: "Absetzcontainer, 7,00m3", einheit: "St", art: "normal" });
expect(voll.positionen.filter((x: { art: string }) => x.art === "eventual")).toHaveLength(2);
expect(voll.angebot.notiz).toMatch(/Vorbemerkungen aus der GAEB-Datei/);
// P84 mit Preisen: feste Einheitspreise
const p84 = await neu("angebote/neu", { projekt_id: p.id, belegart: "angebot", gaeb: { dateiname: "Fahrzeughalle.p84", text: dekodiert("fahrzeughalle.p84") } });
const v84 = await hole(`angebote/${p84.id}/voll`);
expect(v84.positionen).toHaveLength(48);
expect(v84.positionen[0]).toMatchObject({ oz: "01.0001", menge: 110, einheit: "m", ep_fest: 3302 });
// Ausschreibung an Subunternehmer aus dem Angebot: ohne eigene Preise
const as = await neu("angebote/neu", { projekt_id: p.id, belegart: "ausschreibung", vorbeleg_id: p84.id });
expect(as.nummer).toMatch(/^AS-\d{2}-001$/);
expect((await hole(`angebote/${as.id}/voll`)).positionen.every((x: { ep_fest: unknown }) => x.ep_fest === null)).toBe(true);
// nach dem Annehmen gibt es AB, Nachtrag und Lieferschein
expect((await post(`angebote/${p84.id}/annehmen`, {})).statusCode).toBe(200);
const abNeu = await neu("angebote/neu", { projekt_id: p.id, belegart: "auftragsbestaetigung", vorbeleg_id: p84.id });
expect(abNeu).toMatchObject({ belegart: "auftragsbestaetigung", quelle: `aus Angebot ${p84.nummer}` });
expect((await hole(`angebote/${abNeu.id}/voll`)).positionen).toHaveLength(48);
expect((await post("angebote/neu", { projekt_id: p.id, belegart: "lieferschein", vorbeleg_id: abNeu.id })).statusCode).toBe(201);
expect((await post("angebote/neu", { projekt_id: p.id, belegart: "nachtrag" })).statusCode).toBe(201);
});
});
describe.skipIf(!url)("Stundensätze im Personalmodul (M15–M19)", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const neu = async (pfad: string, body: object = {}) => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json();
it("Excel übernehmen, Personen zählen, ins Angebot festschreiben, neue Version nachfragen (A36, A37)", async () => {
const chef = await neu("kontakte", { name: "Henning", rolle: "mitarbeiter" });
const ges = await neu("kontakte", { name: "Rosty", rolle: "mitarbeiter" });
await neu("mitarbeiter", { kontakt_id: chef.id, angestellt: false });
await neu("mitarbeiter", { kontakt_id: ges.id, angestellt: true });
const p = await neu("projekte", { nummer: "A-26-140", bezeichnung: "Dach Probe", status: "anfrage" });
const alt = await neu("angebote/neu", { projekt_id: p.id });
expect(alt.saetze.stundensaetze).toEqual({ planer: 8000, geselle: 5831, helfer: 5000 });
const v2 = await neu("stundensaetze/excel");
expect((await app.inject({ method: "POST", url: "/api/stundensaetze/excel" })).statusCode).toBe(409);
const s = await hole("stundensaetze");
expect(s.versionen.map((v: { name: string }) => v.name)).toEqual(["Excel 26.05.2026", "Akquise und Verwaltung als Kosten"]);
expect(s.gilt).toBe(v2.id);
const jahr = Number(v2.gilt_ab.slice(0, 4));
expect(s.umfeld[jahr]).toMatchObject({ koepfe: 2, personen: { chef: 1, geselle: 1 } });
const a = await neu("angebote/neu", { projekt_id: p.id });
expect(a.saetze).toMatchObject({ stundensaetze: { mittellohn: 7238, chef: 7238, planer: 10101, geselle: 7238 }, zuschlaege: { lohn: 0 },
stundensatz_version: { id: v2.id } });
expect(a.saetze.lohnarten[0]).toEqual({ id: "mittellohn", name: "Mittellohn" });
const pos = await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Abbund", menge: 10, einheit: "m" });
await neu("angebot-kosten", { position_id: pos.id, kostenart: "lohn", lohnart: "mittellohn", menge: 1 });
expect((await hole(`angebote/${a.id}/voll`)).ergebnis.positionen[pos.id].kosten_je_einheit).toBe(7238);
expect((await hole(`angebote/${a.id}/voll`)).neue_stundensaetze).toBeNull();
// das alte Angebot (Sätze aus den Einstellungen) fragt nach; Übernehmen setzt den Lohnzuschlag auf 0 %
expect((await hole(`angebote/${alt.id}/voll`)).neue_stundensaetze.stundensatz_version.id).toBe(v2.id);
const r = await app.inject({ method: "POST", url: `/api/angebote/${alt.id}/stundensaetze` });
expect(r.json()).toMatchObject({ stundensaetze: { mittellohn: 7238 }, zuschlaege: { lohn: 0 } });
// Gesellenlohn ändern: das Angebot behält seinen Satz, bis es übernimmt
const d = structuredClone(v2.daten);
d.tabellen.find((t: { id: string }) => t.id === "geselle").kosten[0].betrag = 250000;
expect((await app.inject({ method: "PATCH", url: `/api/stundensaetze/${v2.id}`, payload: { daten: d } })).statusCode).toBe(200);
const voll = await hole(`angebote/${a.id}/voll`);
expect(voll.saetze.stundensaetze.mittellohn).toBe(7238);
expect(voll.neue_stundensaetze.stundensaetze.mittellohn).toBeLessThan(7238);
// Lohnarten für die Rolle im Personal; eigene Lohnart als Rolle speicherbar
expect((await hole("lohnarten")).map((x: { id: string }) => x.id)).toEqual(["chef", "planer", "geselle", "helfer"]);
const m = (await hole("mitarbeiter")).find((x: { kontakt_id: string }) => x.kontakt_id === ges.id);
expect((await app.inject({ method: "PATCH", url: `/api/mitarbeiter/${m.id}`, payload: { funktion: "vorarbeiter" } })).statusCode).toBe(200);
// gleiches „gilt ab“ zweimal geht nicht
expect((await app.inject({ method: "POST", url: "/api/stundensaetze", payload: { name: "x", gilt_ab: v2.gilt_ab, daten: d } })).statusCode).toBe(409);
});
});