Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
1644 lines
118 KiB
TypeScript
1644 lines
118 KiB
TypeScript
// 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("Haken „zählt“: Posten bleibt in der Liste, zählt aber nicht mehr mit", async () => {
|
||
const p = await anlegen("projekte", { nummer: "28-001", bezeichnung: "Zählt-Test" });
|
||
const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 100_000, termin: "2028-05-02", zahlungsziel_tage: 0 });
|
||
const k = await anlegen("kosten", { projekt_id: p.id, art: "material", bezeichnung: "Holz", netto: 10_000, termin: "2028-05-03", zahlungsziel_tage: 0 });
|
||
const l = await anlegen("laufende-kosten", { bezeichnung: "Zählt-Miete", betrag: 1_000, rhythmus: "monatlich", start: "2028-05-04", ende: "2028-06-30" });
|
||
const mai = async () => (await app.inject("/api/liquiditaet?ansicht=monat&start=2028-05-01&anzahl=1")).json()[0];
|
||
const vorher = await mai();
|
||
const setze = (liste: { quelle: string; zaehlt: boolean }[]) => app.inject({ method: "POST", url: "/api/liquiditaet/zaehlt", payload: liste });
|
||
expect((await setze([{ quelle: `zahlung:${z.id}`, zaehlt: false }, { quelle: `kosten:${k.id}`, zaehlt: false },
|
||
{ quelle: `lk:${l.id}:2028-05-04`, zaehlt: false }, { quelle: `pauschale:${p.id}:material`, zaehlt: false }])).statusCode).toBe(200);
|
||
const nachher = await mai();
|
||
expect(nachher.einnahmen).toBe(vorher.einnahmen - 119_000);
|
||
expect(nachher.ausgaben).toBe(vorher.ausgaben + 11_900 + 1_000);
|
||
expect(nachher.ohne.map((x: { quelle: string }) => x.quelle).sort()).toEqual([`kosten:${k.id}`, `lk:${l.id}:2028-05-04`, `zahlung:${z.id}`].sort());
|
||
expect((await app.inject(`/api/zahlungen/${z.id}`)).json().zaehlt).toBe(false);
|
||
expect((await app.inject(`/api/projekte/${p.id}`)).json().liqui_ohne).toEqual(["material"]);
|
||
// doppelt abschalten bleibt einmal, Juni zählt weiter
|
||
await setze([{ quelle: `pauschale:${p.id}:material`, zaehlt: false }, { quelle: `lk:${l.id}:2028-05-04`, zaehlt: false }]);
|
||
expect((await app.inject(`/api/laufende-kosten/${l.id}`)).json().ohne_termine).toEqual(["2028-05-04"]);
|
||
// alle wieder zählen
|
||
await setze([{ quelle: `zahlung:${z.id}`, zaehlt: true }, { quelle: `kosten:${k.id}`, zaehlt: true }, { quelle: `lk:${l.id}:2028-05-04`, zaehlt: true }, { quelle: `pauschale:${p.id}:material`, zaehlt: true }]);
|
||
expect(await mai()).toEqual(vorher);
|
||
expect((await app.inject(`/api/projekte/${p.id}`)).json().liqui_ohne).toEqual([]);
|
||
expect((await setze([{ quelle: "projekt:x", zaehlt: false }])).statusCode).toBe(400);
|
||
});
|
||
|
||
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);
|
||
});
|
||
|
||
it("schlägt Adressen aus Kontakten, Projekten und der Karte vor", async () => {
|
||
await anlegen("kontakte", { name: "Adr Kunde", rolle: "bauherr", strasse: "Lindenweg 4", plz: "23909", ort: "Ratzeburg" });
|
||
await anlegen("projekte", { nummer: "P-26-901", bezeichnung: "Adr Carport", status: "auftrag", baustelle_strasse: "Lindenweg 12", baustelle_plz: "23909", baustelle_ort: "Ratzeburg" });
|
||
const gefragt: string[] = [];
|
||
const abruf = (async (u: URL) => {
|
||
gefragt.push(String(u));
|
||
return new Response(JSON.stringify({ features: [
|
||
{ properties: { street: "Lindenweg", housenumber: "4", postcode: "23909", city: "Ratzeburg" } },
|
||
{ properties: { street: "Lindenweg", housenumber: "20", postcode: "23911", city: "Mölln", name: "Bäckerei" } },
|
||
{ properties: { name: "Ratzeburg", osm_key: "place" } },
|
||
] }), { headers: { "content-type": "application/json" } });
|
||
}) as unknown as typeof fetch;
|
||
const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion", adressKarte: abruf });
|
||
try {
|
||
const r = await t.inject({ method: "GET", url: "/api/adressen?q=linden%20ratz", headers: { "x-benutzer": "henning" } });
|
||
expect(r.statusCode, r.body).toBe(200);
|
||
const tr = r.json().treffer as { strasse: string; quelle: string; titel: string; plz: string }[];
|
||
// eigene zuerst, Lindenweg 4 aus der Karte nicht doppelt, Orte ohne Straße fallen weg
|
||
expect(tr.map((x) => `${x.quelle}:${x.strasse}`)).toEqual(["kontakt:Lindenweg 4", "projekt:Lindenweg 12", "karte:Lindenweg 20"]);
|
||
expect(tr[2]).toMatchObject({ plz: "23911", titel: "Bäckerei" });
|
||
expect(gefragt[0]).toContain("q=linden+ratz");
|
||
// zu kurz: nichts, auch keine Anfrage an die Karte
|
||
expect((await t.inject({ method: "GET", url: "/api/adressen?q=l", headers: { "x-benutzer": "henning" } })).json()).toEqual({ treffer: [] });
|
||
expect(gefragt).toHaveLength(1);
|
||
} finally { await t.close(); }
|
||
// Karte nicht erreichbar: eigene Vorschläge kommen trotzdem
|
||
const kaputt = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion", adressKarte: (async () => { throw new Error("offline"); }) as unknown as typeof fetch });
|
||
try {
|
||
const r = await kaputt.inject({ method: "GET", url: "/api/adressen?q=lindenweg", headers: { "x-benutzer": "henning" } });
|
||
expect(r.json().treffer.map((x: { quelle: string }) => x.quelle)).toEqual(["kontakt", "projekt"]);
|
||
} finally { await kaputt.close(); }
|
||
});
|
||
});
|
||
|
||
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);
|
||
// vorerst ohne Kontostand (Henning, 23.10.2026): keine Kontostand-Warnung, dafür Geldfluss je Woche
|
||
// überfällige Aufgaben stehen in der Zahlenleiste, nicht mehr unter den Warnungen (UX-Prüfung, 08.11.2026)
|
||
expect(arten).not.toContain("aufgabe");
|
||
expect(arten).not.toContain("kontostand");
|
||
expect(u.brennt.map((b: { art: string }) => b.art)).not.toContain("kontostand");
|
||
expect(u.geld).toEqual(expect.objectContaining({ von: expect.any(String), bis: expect.any(String), betrag: expect.any(Number) }));
|
||
expect((await app.inject("/api/liquiditaet/lage?wochen=4")).json().mitKontostand).toBe(false);
|
||
expect(u.fluss[0]).toEqual(expect.objectContaining({ einnahmen: expect.any(Number), projektkosten: expect.any(Number), laufend: expect.any(Number), ust: expect.any(Number) }));
|
||
const e = (await app.inject("/api/einstellungen")).json();
|
||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, liquiditaetMitKontostand: true } });
|
||
const mit = (await app.inject(`/api/uebersicht?heute=${t.ueberschneidungen[0].ab}`)).json();
|
||
expect(mit.brennt.find((w: { art: string }) => w.art === "kontostand")).toMatchObject({ text: "Kontostand nicht eingetragen", ziel: "einstellungen-programmteile" });
|
||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
|
||
expect(u.einsatz.tage).toHaveLength(8);
|
||
// am Handy bis zu vier Wochen und eine Auswahl aller Mitarbeiter, Kolonnen und Subunternehmer
|
||
expect(u.einsatzHandy.tage.length).toBeGreaterThanOrEqual(15);
|
||
expect(u.einsatzHandy.auswahl.some((a: { anzeige: string; art: string }) => a.anzeige === "Henning Schaarschmidt" && a.art === "mitarbeiter")).toBe(true);
|
||
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: Zahl der Raten nach Auftragswert, Staffel in den Einstellungen (Henning, 09.11.2026)", 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-097", bezeichnung: "Carport Staffel", umsatz_netto: 1_500_000 });
|
||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
|
||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-09", dauer: 1 });
|
||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Abnahme", start: "2026-11-16", dauer: 1 });
|
||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["abschlag", 750_000], ["schluss", 750_000]]);
|
||
// kleiner geworden: eine Schlussrechnung
|
||
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 900_000 } });
|
||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["schluss", 900_000]]);
|
||
// eigene Staffel: schon ab 5.000 € zwei Raten 30/70
|
||
const e = (await app.inject("/api/einstellungen")).json();
|
||
expect(e.zahlungsStaffel).toHaveLength(3);
|
||
const staffel = [e.zahlungsStaffel[0], { ab: 500_000, raten: [
|
||
{ bezeichnung: "Anzahlung", prozent: 30, ziel: "auftrag" }, { bezeichnung: "Schluss", prozent: 70, ziel: "schluss" }] }];
|
||
expect((await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, zahlungsStaffel: staffel } })).statusCode).toBe(200);
|
||
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 1_000_000 } });
|
||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["anzahlung", 300_000], ["schluss", 700_000]]);
|
||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
|
||
});
|
||
|
||
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");
|
||
// „Bezahlt am“ eingetragen: Status geht von selbst auf bezahlt; zurück auf gestellt nimmt das Datum weg (Henning, 26.10.2026)
|
||
expect((await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { bezahlt_am: "2026-11-20" } })).json().status).toBe("bezahlt");
|
||
const zurueck = (await app.inject({ method: "PATCH", url: `/api/zahlungen/${r1.id}`, payload: { status: "gestellt" } })).json();
|
||
expect([zurueck.status, zurueck.bezahlt_am]).toEqual(["gestellt", null]);
|
||
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("internes Projekt landet in 05 Intern (Henning, 24.10.2026)", async () => {
|
||
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "I-26-001", bezeichnung: "Werkstatt", status: "intern" } })).json();
|
||
expect(p.status).toBe("intern");
|
||
expect(p.nextcloud_link).toBe("05 Intern/I-26-001 Werkstatt");
|
||
});
|
||
|
||
it("Projektnummern: doppelte abgelehnt, Buchstabe nach Status, Aufräumen (Henning, 26.10.2026)", async () => {
|
||
const post = (payload: object) => app.inject({ method: "POST", url: "/api/projekte", payload });
|
||
const doppelt = await post({ nummer: "A26-21", bezeichnung: "Zweiter Carport", status: "angebot" });
|
||
expect(doppelt.statusCode).toBe(409);
|
||
expect(doppelt.json().fehler).toBe("Die Nummer 26-021 hat schon „Carport Most“ (P-26-021). Nächste freie: A-26-022.");
|
||
const p = (await post({ nummer: "26-090", bezeichnung: "Vordach", status: "angebot" })).json();
|
||
expect(p.nummer).toBe("A-26-090");
|
||
const gw = (await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { status: "gewaehrleistung" } })).json();
|
||
expect(gw).toMatchObject({ nummer: "G-26-090", nextcloud_link: "03 Gewährl.-Projekte/G-26-090 Vordach" });
|
||
const intern = (await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { status: "intern" } })).json();
|
||
expect(intern.nummer).toBe("I-26-002");
|
||
// Altbestand: falscher Buchstabe und doppelte Zahl; das jüngere Projekt weicht aus
|
||
await pool.query("insert into projekt (nummer, bezeichnung, status, angelegt_am) values ('A-26-095', 'Altbau', 'auftrag', now() - interval '2 days'), ('P-26-95', 'Neubau', 'angebot', now())");
|
||
expect((await app.inject({ method: "POST", url: "/api/projekte/nummern-aufraeumen" })).json().geaendert).toBe(2);
|
||
const n = (await pool.query("select bezeichnung, nummer from projekt where bezeichnung in ('Altbau', 'Neubau') order by bezeichnung")).rows;
|
||
expect(n).toEqual([{ bezeichnung: "Altbau", nummer: "P-26-095" }, { bezeichnung: "Neubau", nummer: "A-26-096" }]);
|
||
expect((await app.inject({ method: "POST", url: "/api/projekte/nummern-aufraeumen" })).json().geaendert).toBe(0);
|
||
});
|
||
|
||
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);
|
||
});
|
||
it("Programmteile: die Sitzung sagt, welche eingeschaltet sind", async () => {
|
||
expect((await app.inject("/api/sitzung")).json().module).toEqual({ angebote: true, zeiterfassung: true, stundensaetze: true, jahresplanung: true });
|
||
const e = (await app.inject("/api/einstellungen")).json();
|
||
const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, module: { ...e.module, angebote: false, zeiterfassung: false } } });
|
||
expect(r.statusCode, r.body).toBe(200);
|
||
expect((await app.inject("/api/sitzung")).json().module).toMatchObject({ angebote: false, zeiterfassung: false, stundensaetze: true });
|
||
});
|
||
});
|
||
|
||
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", "05 Intern"] });
|
||
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)] });
|
||
// der Terminplan bekommt die Abwesenheit mit, abgelehnte nicht
|
||
const abl = (await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "urlaub", von: plus(start, 2), bis: plus(start, 2), status: "abgelehnt" })).json();
|
||
const abw = (await als(inhaber, "GET", "/api/terminplan")).json().abwesenheiten;
|
||
expect(abw).toContainEqual(expect.objectContaining({ id: u.id, kontakt_id: jan, art: "frei", von: plus(start, 1), status: "genehmigt" }));
|
||
expect(abw.some((a: { id: string }) => a.id === abl.id)).toBe(false);
|
||
await als(inhaber, "DELETE", `/api/abwesenheiten/${abl.id}`);
|
||
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(2); // 10.000 € netto: zwei Raten (Staffel 09.11.2026)
|
||
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("Zahlungsplan im Angebot: Vorschlag nach Angebotssumme, je Angebot änderbar, beim Annehmen ins Projekt (Henning, 09.11.2026)", async () => {
|
||
const p = await neu("projekte", { nummer: "A-26-141", bezeichnung: "Vordach Zahlungsplan" });
|
||
const a = await neu("angebote/neu", { projekt_id: p.id });
|
||
await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Vordach pauschal", menge: 1, einheit: "psch", ep_fest: 1_500_000 });
|
||
let voll = await hole(`angebote/${a.id}/voll`);
|
||
expect(voll.ergebnis.netto).toBe(1_500_000);
|
||
expect(voll.zahlungsplan).toMatchObject({ eigen: false, raten: [{ prozent: 50, ziel: "richten", netto: 750_000 }, { prozent: 50, ziel: "schluss", netto: 750_000 }] });
|
||
expect(voll.zahlungsplan.raten.reduce((x: number, r: { brutto: number }) => x + r.brutto, 0)).toBe(voll.ergebnis.brutto);
|
||
// eigener Plan: 30 % Anzahlung, Rest Schluss
|
||
const eigen = [{ bezeichnung: "Anzahlung", prozent: 30, ziel: "auftrag" }, { bezeichnung: "Schlussrechnung", prozent: 70, ziel: "schluss" }];
|
||
const pa = await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { zahlungsplan: eigen } });
|
||
expect(pa.statusCode, pa.body).toBe(200);
|
||
voll = await hole(`angebote/${a.id}/voll`);
|
||
expect(voll.zahlungsplan.eigen).toBe(true);
|
||
expect(voll.zahlungsplan.raten.map((r: { netto: number }) => r.netto)).toEqual([450_000, 1_050_000]);
|
||
await post(`angebote/${a.id}/annehmen`, { start: "2027-03-01" });
|
||
expect((await hole(`projekte/${p.id}`)).zahlungsplan_raten).toEqual(eigen);
|
||
const raten = (await hole("zahlungen")).filter((z: { projekt_id: string }) => z.projekt_id === p.id)
|
||
.sort((x: { reihenfolge: number }, y: { reihenfolge: number }) => x.reihenfolge - y.reihenfolge);
|
||
expect(raten.map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["anzahlung", 450_000], ["schluss", 1_050_000]]);
|
||
});
|
||
|
||
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", status: "angebot" });
|
||
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);
|
||
});
|
||
});
|