diff --git a/src/domain/terminplan.ts b/src/domain/terminplan.ts new file mode 100644 index 0000000..c03dcb4 --- /dev/null +++ b/src/domain/terminplan.ts @@ -0,0 +1,149 @@ +// Terminplanung mit Verknüpfungen (T3, T5): ein Vorgang darf mehrere Vorgänger haben. +// Regeln wie in V70 (reqOf/reschedAll): EA, AA, EE, AE mit Verzögerung in Arbeitstagen. +// Nachfolger werden nach hinten geschoben, wenn ein Vorgänger sich verlängert oder später +// liegt. Nach vorn rücken nur Nachfolger, die vorher direkt am Vorgänger hingen („eng“). + +import { type Datum } from "./datum.js"; +import { type Arbeitswoche, endeNachDauer, naechsterArbeitstag, verschiebeArbeitstage } from "./kalender.js"; + +export type Art = "EA" | "AA" | "EE" | "AE"; + +export interface PlanVorgang { + id: string; + start: Datum; + /** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */ + dauer: number; +} + +export interface Verknuepfung { + vorgang_id: string; + vorgaenger_id: string; + art: Art; + /** Arbeitstage, darf negativ sein */ + verzoegerung: number; +} + +const tage = (v: PlanVorgang) => Math.ceil(v.dauer); + +export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum { + return naechsterArbeitstag(v.start, woche); +} + +export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum { + return endeNachDauer(v.start, tage(v), woche); +} + +/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */ +function versatz(d: Datum, n: number, woche: Arbeitswoche): Datum { + return n === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, n, woche); +} + +/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet. */ +function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche): Datum { + const e = naechsterArbeitstag(endeAm, woche); + return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), woche); +} + +/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */ +export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum { + const lg = k.verzoegerung; + const meilenstein = tage(v) === 0; + switch (k.art) { + case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, woche); + case "AA": return versatz(anfang(vorgaenger, woche), lg, woche); + case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, woche), woche); + case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, woche), woche); + } +} + +/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */ +export function fruehesterStart(v: PlanVorgang, alle: Map, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined { + let s: Datum | undefined; + for (const k of links) { + if (k.vorgang_id !== v.id) continue; + const p = alle.get(k.vorgaenger_id); + if (!p) continue; + const x = startNachVerknuepfung(v, p, k, woche); + if (!s || x > s) s = x; + } + return s; +} + +/** Vorgänge, die genau an ihrem frühesten Start liegen; sie rücken mit, wenn der Vorgänger früher fertig wird. */ +export function engeVorgaenge(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche): Set { + const alle = new Map(vorgaenge.map((v) => [v.id, v])); + const eng = new Set(); + for (const v of vorgaenge) { + const f = fruehesterStart(v, alle, links, woche); + if (f && f === anfang(v, woche)) eng.add(v.id); + } + return eng; +} + +/** true, wenn die neue Verknüpfung einen Kreis bilden würde (Vorgänger hängt schon am Vorgang). */ +export function bildetKreis(neu: Pick, links: Verknuepfung[]): boolean { + if (neu.vorgang_id === neu.vorgaenger_id) return true; + const nachfolger = new Map(); + for (const k of links) nachfolger.set(k.vorgaenger_id, [...(nachfolger.get(k.vorgaenger_id) ?? []), k.vorgang_id]); + const offen = [neu.vorgang_id]; + const gesehen = new Set(); + while (offen.length) { + const x = offen.pop()!; + if (x === neu.vorgaenger_id) return true; + if (gesehen.has(x)) continue; + gesehen.add(x); + offen.push(...(nachfolger.get(x) ?? [])); + } + return false; +} + +/** Reihenfolge, in der Vorgänger vor ihren Nachfolgern kommen. Wirft bei einem Kreis. */ +function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorgang[] { + const ids = new Set(vorgaenge.map((v) => v.id)); + const rest = new Map(vorgaenge.map((v) => [v.id, 0])); + const nach = new Map(); + for (const k of links) { + if (!ids.has(k.vorgang_id) || !ids.has(k.vorgaenger_id)) continue; + rest.set(k.vorgang_id, rest.get(k.vorgang_id)! + 1); + nach.set(k.vorgaenger_id, [...(nach.get(k.vorgaenger_id) ?? []), k.vorgang_id]); + } + const byId = new Map(vorgaenge.map((v) => [v.id, v])); + const bereit = vorgaenge.filter((v) => rest.get(v.id) === 0).map((v) => v.id); + const aus: PlanVorgang[] = []; + while (bereit.length) { + const id = bereit.shift()!; + aus.push(byId.get(id)!); + for (const n of nach.get(id) ?? []) { + rest.set(n, rest.get(n)! - 1); + if (rest.get(n) === 0) bereit.push(n); + } + } + if (aus.length !== vorgaenge.length) throw new Error("Die Verknüpfungen bilden einen Kreis."); + return aus; +} + +export interface Ergebnis { + /** neuer Start je verschobenem Vorgang */ + starts: Map; +} + +/** + * Plant alle Nachfolger neu. `eng` sind die Vorgänge, die vor der Änderung direkt am Vorgänger hingen + * (engeVorgaenge auf dem alten Stand); nur sie dürfen nach vorn rücken. `fest` werden nicht bewegt + * (der Vorgang, den der Benutzer gerade gezogen hat, wird vorher auf seinen frühesten Start begrenzt). + */ +export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set = new Set()): Ergebnis { + const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }])); + const starts = new Map(); + for (const v of topologisch(vorgaenge, links)) { + const x = stand.get(v.id)!; + const f = fruehesterStart(x, stand, links, woche); + if (!f) continue; + const a = anfang(x, woche); + if (f > a || (f < a && eng.has(v.id))) { + x.start = f; + starts.set(v.id, f); + } + } + return { starts }; +} diff --git a/src/server/app.ts b/src/server/app.ts index 1707564..682349b 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -4,7 +4,8 @@ import { fileURLToPath } from "node:url"; import path from "node:path"; import { existsSync } from "node:fs"; import { z, ZodError } from "zod"; -import { type Pool, transaktion } from "./db.js"; +import { type Client, type Pool, transaktion } from "./db.js"; +import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js"; import { TABELLEN } from "./tabellen.js"; import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; import { liquiditaet } from "../domain/liquiditaet.js"; @@ -52,6 +53,14 @@ export async function baueApp(o: Optionen): Promise { return { ok: true, version: VERSION }; }); + // Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu + const PLAN = new Set(["vorgang", "vorgang_vorgaenger"]); + async function geplant(c: Client, tabelle: string, fn: () => Promise, bewegt: string[] = []): Promise { + if (!PLAN.has(tabelle)) return fn(); + const e = await ladeEinstellungen(); + return (await mitNeuplanung(c, { tage: e.arbeitstage }, fn, bewegt)).ergebnis; + } + for (const t of TABELLEN) { const felder = Object.keys(t.schema.shape); const teil = t.schema.partial(); @@ -67,14 +76,16 @@ export async function baueApp(o: Optionen): Promise { app.post(`/api/${t.pfad}`, async (req, reply) => { const daten = t.schema.parse(req.body) as Record; const spalten = felder.filter((f) => daten[f] !== undefined); - const row = await transaktion(pool, benutzer(req), async (c) => - (await c.query( - spalten.length - ? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *` - : `insert into ${t.name} default values returning *`, - spalten.map((s) => daten[s]), - )).rows[0], - ); + const row = await transaktion(pool, benutzer(req), async (c) => { + if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string }); + return geplant(c, t.name, async () => + (await c.query( + spalten.length + ? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *` + : `insert into ${t.name} default values returning *`, + spalten.map((s) => daten[s]), + )).rows[0]); + }); return reply.status(201).send(row); }); @@ -83,18 +94,24 @@ export async function baueApp(o: Optionen): Promise { const daten = teil.parse(req.body) as Record; const spalten = felder.filter((f) => daten[f] !== undefined); if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); - const row = await transaktion(pool, benutzer(req), async (c) => - (await c.query( - `update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`, - [id, ...spalten.map((s) => daten[s])], - )).rows[0], - ); + const row = await transaktion(pool, benutzer(req), async (c) => { + if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) { + const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0]; + if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id); + } + return geplant(c, t.name, async () => + (await c.query( + `update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`, + [id, ...spalten.map((s) => daten[s])], + )).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : []); + }); return row ?? reply.status(404).send({ fehler: "Nicht gefunden" }); }); app.delete(`/api/${t.pfad}/:id`, async (req, reply) => { const { id } = IdParam.parse(req.params); - const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount); + const n = await transaktion(pool, benutzer(req), async (c) => + geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount)); return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" }); }); } @@ -144,6 +161,11 @@ export async function baueApp(o: Optionen): Promise { return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust }); }); + app.get("/api/terminplan", async () => { + const e = await ladeEinstellungen(); + return terminplan(pool, { tage: e.arbeitstage }); + }); + // Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm app.post("/api/import/v70", async (req, reply) => { let u; @@ -152,7 +174,9 @@ export async function baueApp(o: Optionen): Promise { } catch (err) { return reply.status(400).send({ fehler: (err as Error).message }); } - const anzahl = await transaktion(pool, benutzer(req), (c) => speichereUebernahme(c, u)); + const e = await ladeEinstellungen(); + // nach der Übernahme gelten die Verknüpfungen: Nachfolger rücken hinter ihre Vorgänger wie in V70 + const anzahl = await transaktion(pool, benutzer(req), async (c) => (await mitNeuplanung(c, { tage: e.arbeitstage }, () => speichereUebernahme(c, u))).ergebnis); return reply.status(201).send({ anzahl, hinweise: u.hinweise }); }); diff --git a/src/server/migrations/003_vorgangsnummer.sql b/src/server/migrations/003_vorgangsnummer.sql new file mode 100644 index 0000000..0167c80a --- /dev/null +++ b/src/server/migrations/003_vorgangsnummer.sql @@ -0,0 +1,8 @@ +-- Nummer je Vorgang wie in V70 (dort "no"), damit Vorgänger per Nummer eingetragen werden können +create sequence vorgang_nummer_seq start 1001; +alter table vorgang add column nummer integer; +update vorgang set nummer = nextval('vorgang_nummer_seq'); +alter table vorgang alter column nummer set default nextval('vorgang_nummer_seq'); +alter table vorgang alter column nummer set not null; +alter table vorgang add constraint vorgang_nummer_eindeutig unique (nummer); +alter sequence vorgang_nummer_seq owned by vorgang.nummer; diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 5413020..67de740 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -71,6 +71,7 @@ export const TABELLEN: Tabelle[] = [ sortierung: "abschnitt_id, reihenfolge, start", schema: z.object({ abschnitt_id: id, + nummer: z.number().int().positive().optional(), name: text, start: datum, dauer: z.number().min(0).optional(), diff --git a/src/server/terminplan.ts b/src/server/terminplan.ts new file mode 100644 index 0000000..da94f72 --- /dev/null +++ b/src/server/terminplan.ts @@ -0,0 +1,67 @@ +// Terminplan auf dem Server: Laden für das Gantt und Neuplanung der Nachfolger nach jeder +// Änderung an Vorgängen oder Verknüpfungen, in derselben Transaktion. +import type { Client, Pool } from "./db.js"; +import type { Arbeitswoche } from "../domain/kalender.js"; +import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVorgaenge, planeNeu } from "../domain/terminplan.js"; + +export class PlanFehler extends Error { + statusCode = 409; +} + +async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: PlanVorgang[]; links: Verknuepfung[] }> { + const [v, k] = await Promise.all([ + c.query("select id, start, dauer from vorgang"), + c.query("select vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"), + ]); + return { vorgaenge: v.rows, links: k.rows }; +} + +/** + * Führt eine Änderung aus und plant danach die Nachfolger neu. Vorgänge, die vorher direkt an ihrem + * Vorgänger hingen, rücken auch nach vorn, außer sie wurden gerade selbst verschoben (`bewegt`). + * Gibt die IDs der verschobenen Vorgänge zurück. + */ +export async function mitNeuplanung( + c: Client, woche: Arbeitswoche, aenderung: () => Promise, bewegt: string[] = [], +): Promise<{ ergebnis: T; verschoben: string[] }> { + const vorher = await ladeStand(c); + const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche); + // wer von Hand verschoben wurde, bleibt dort (höchstens bis zum frühesten Start zurückgesetzt) + for (const id of bewegt) eng.delete(id); + const ergebnis = await aenderung(); + const nachher = await ladeStand(c); + let starts; + try { + ({ starts } = planeNeu(nachher.vorgaenge, nachher.links, woche, eng)); + } catch (e) { + throw new PlanFehler((e as Error).message); + } + for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]); + return { ergebnis, verschoben: [...starts.keys()] }; +} + +/** Prüft eine neue Verknüpfung vor dem Speichern. */ +export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; vorgaenger_id: string }, ausser?: string): Promise { + const r = await c.query("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"); + if (bildetKreis(neu, r.rows.filter((k) => k.id !== ausser))) { + throw new PlanFehler("Diese Verknüpfung ergäbe einen Kreis: der Vorgänger hängt schon (über andere Vorgänge) an diesem Vorgang."); + } +} + +/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */ +export async function terminplan(pool: Pool, woche: Arbeitswoche) { + const [projekte, abschnitte, vorgaenge, links] = await Promise.all([ + pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, k.name as bauherr + from projekt p left join kontakt k on k.id = p.bauherr_id order by p.reihenfolge, p.nummer`), + pool.query("select id, projekt_id, name, ist_meilenstein, reihenfolge from abschnitt order by reihenfolge, name"), + pool.query("select id, abschnitt_id, nummer, name, start, dauer, stunden, personen, kontakt_id, fortschritt, reihenfolge from vorgang order by reihenfolge, nummer"), + pool.query("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"), + ]); + return { + projekte: projekte.rows, + abschnitte: abschnitte.rows, + vorgaenge: vorgaenge.rows.map((v) => ({ ...v, anfang: anfang(v, woche), ende: ende(v, woche) })), + verknuepfungen: links.rows, + arbeitstage: woche.tage, + }; +} diff --git a/src/server/v70import.ts b/src/server/v70import.ts index 519e397..ac02f9d 100644 --- a/src/server/v70import.ts +++ b/src/server/v70import.ts @@ -36,8 +36,11 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise v.reihenfolge)); + await c.query("select setval('vorgang_nummer_seq', $1)", [hoechste]); for (const { schluessel, abschnitt, ...v } of u.vorgaenge) { - id.set(schluessel, await einfuegen(c, "vorgang", { ...v, abschnitt_id: ref(abschnitt) })); + id.set(schluessel, await einfuegen(c, "vorgang", { ...v, nummer: v.reihenfolge > 0 ? v.reihenfolge : undefined, abschnitt_id: ref(abschnitt) })); } for (const k of u.verknuepfungen) { await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung }); diff --git a/src/web/app.ts b/src/web/app.ts index da67641..b5a1775 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -3,6 +3,7 @@ import { formatEuro, parseEuro } from "../domain/geld.js"; import { formatDatum } from "../domain/datum.js"; +import { terminplanSeite } from "./gantt.js"; type Zeile = Record; @@ -214,8 +215,7 @@ async function projekte(): Promise { } async function terminplan(): Promise { - seite("Terminplan"); - inhalt.insertAdjacentHTML("beforeend", `

Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.

`); + await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt }); } async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise { diff --git a/src/web/gantt.ts b/src/web/gantt.ts new file mode 100644 index 0000000..e082387 --- /dev/null +++ b/src/web/gantt.ts @@ -0,0 +1,334 @@ +// Terminplan als Gantt wie in V70 (T1–T5): Projekt → Abschnitt → Vorgang, Balken ziehen +// verschiebt, rechter Griff ändert die Dauer, Vorgänger per Nummer mit Art und Verzögerung. +// Die Neuplanung der Nachfolger macht der Server. + +import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js"; +import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag } from "../domain/kalender.js"; + +type Zeile = Record; + +export interface Hilfen { + api(pfad: string, methode?: string, body?: unknown): Promise; + dialog(titel: string, felder: { name: string; titel: string; art?: "text" | "datum" | "zahl" | "auswahl"; optionen?: [string, string][]; pflicht?: boolean }[], werte: Zeile, mitLoeschen: boolean): + Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null>; + esc(v: unknown): string; + seite(titel: string): HTMLElement; + inhalt: HTMLElement; +} + +interface Plan { + projekte: Zeile[]; + abschnitte: Zeile[]; + vorgaenge: Zeile[]; + verknuepfungen: Zeile[]; + arbeitstage: number[]; +} + +const ZOOM: Record = { tag: 24, woche: 10, monat: 4 }; +const ZEILE = 34; +const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"]; +const MONATE = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"]; + +// Ansichtseinstellungen nur für diesen Browser +function merke(schluessel: string, wert?: T): T | undefined { + try { + if (wert === undefined) return JSON.parse(localStorage.getItem(`betrieb-${schluessel}`) ?? "null") ?? undefined; + localStorage.setItem(`betrieb-${schluessel}`, JSON.stringify(wert)); + } catch { /* privates Fenster: dann eben ohne Gedächtnis */ } + return wert; +} + +/** „1003, 1005 AA+2“ → Liste von Verknüpfungen; wirft bei unbekannter Nummer. */ +export function leseVorgaenger(text: string, nummern: Map): { vorgaenger_id: string; art: string; verzoegerung: number }[] { + return text.split(/[,;]/).map((s) => s.trim()).filter(Boolean).map((s) => { + const m = /^(\d+)\s*(EA|AA|EE|AE)?\s*([+-]\s*\d+)?$/i.exec(s); + if (!m) throw new Error(`„${s}“ verstehe ich nicht. Beispiele: 1003, 1003 AA, 1003 EA+2`); + const id = nummern.get(Number(m[1])); + if (!id) throw new Error(`Vorgang ${m[1]} gibt es nicht.`); + return { vorgaenger_id: id, art: (m[2] ?? "EA").toUpperCase(), verzoegerung: m[3] ? Number(m[3].replace(/\s/g, "")) : 0 }; + }); +} + +export function vorgaengerText(links: Zeile[], nummer: Map): string { + return links.map((k) => `${nummer.get(k.vorgaenger_id)}${k.art !== "EA" || k.verzoegerung ? ` ${k.art}` : ""}${k.verzoegerung ? (k.verzoegerung > 0 ? "+" : "") + k.verzoegerung : ""}`).join(", "); +} + +export async function terminplanSeite(h: Hilfen): Promise { + const { api, esc, inhalt } = h; + const leiste = h.seite("Terminplan"); + const plan = await api("terminplan"); + const woche: Arbeitswoche = { tage: plan.arbeitstage }; + let zoom = merke("gantt-zoom") ?? "tag"; + const zu = new Set(merke("gantt-zu") ?? []); + const mitFertigen = merke("gantt-fertige") ?? false; + + leiste.innerHTML = `${Object.keys(ZOOM).map((z) => ``).join("")} + + + Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve.`; + + const nummerVon = new Map(plan.vorgaenge.map((v) => [v.id, v.nummer])); + const idVon = new Map(plan.vorgaenge.map((v) => [v.nummer, v.id])); + const linksVon = (id: string) => plan.verknuepfungen.filter((k) => k.vorgang_id === id); + + const projekte = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen"); + const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]); + + // Zeitraum: vom frühesten Vorgang (oder heute) bis zum spätesten plus Luft + const heute = new Date().toISOString().slice(0, 10); + const sichtbar = plan.vorgaenge.filter((v) => projekte.some((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id))); + let von = montagDerWoche(plusTage(sichtbar.reduce((m, v) => (v.anfang < m ? v.anfang : m), heute), -7)); + let bis = plusTage(sichtbar.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 30)), 21); + const minTage = zoom === "monat" ? 400 : zoom === "woche" ? 160 : 0; + if (tageZwischen(von, bis) + 1 < minTage) bis = plusTage(von, minTage - 1); + const W = ZOOM[zoom]!; + const tage = tageZwischen(von, bis) + 1; + const x = (d: Datum) => tageZwischen(von, d) * W; + + // Zeilen aufbauen + type Reihe = { art: "p" | "a" | "v"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum }; + const reihen: Reihe[] = []; + projekte.forEach((p, i) => { + const f = farbe(p, i); + const abs = plan.abschnitte.filter((a) => a.projekt_id === p.id); + const vs = plan.vorgaenge.filter((v) => abs.some((a) => a.id === v.abschnitt_id)); + const spanne = (l: Zeile[]) => (l.length ? { von: l.reduce((m, v) => (v.anfang < m ? v.anfang : m), l[0]!.anfang), bis: l.reduce((m, v) => (v.ende > m ? v.ende : m), l[0]!.ende) } : {}); + reihen.push({ art: "p", obj: p, projekt: p, farbe: f, ...spanne(vs) }); + if (zu.has(p.id)) return; + for (const a of abs) { + const av = vs.filter((v) => v.abschnitt_id === a.id); + reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) }); + if (zu.has(a.id)) continue; + for (const v of av) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende }); + } + }); + const zeileVon = new Map(); + reihen.forEach((r, i) => zeileVon.set(r.obj.id, i)); + + // Kopf: Monate, Kalenderwochen, Tage + let monate = "", kw = "", tagKopf = "", schatten = ""; + for (let i = 0, mStart = 0, wStart = 0; i < tage; i++) { + const d = plusTage(von, i); + const naechster = plusTage(d, 1); + if (naechster.slice(0, 7) !== d.slice(0, 7) || i === tage - 1) { + const n = i - mStart + 1; + monate += `
${n * W > 50 ? `${MONATE[Number(d.slice(5, 7)) - 1]} ${d.slice(0, 4)}` : ""}
`; + mStart = i + 1; + } + if (wochentag(naechster) === 1 || i === tage - 1) { + const n = i - wStart + 1; + kw += `
${n * W > 34 ? `KW ${kalenderwoche(d)}` : ""}
`; + wStart = i + 1; + } + const ft = feiertag(d); + const frei = !istArbeitstag(d, woche); + const freitag = wochentag(d) === 5 && !ft; + const klasse = ft ? "feiertag" : freitag ? "reserve" : frei ? "frei" : ""; + const titel = ft ? ft.name : freitag ? "Freitag: Reserve und Bürotag" : ""; + tagKopf += `
${W >= 18 ? Number(d.slice(8)) : ""}
`; + if (klasse) schatten += ``; + } + if (heute >= von && heute <= bis) schatten += ``; + + // Linke Spalten und Balken je Zeile + const zeilenHtml = reihen.map((r, i) => { + const o = r.obj; + let links = "", balken = ""; + const datumZelle = (d?: Datum) => `${d ? formatDatum(d).slice(0, 6) + d.slice(2, 4) : "–"}`; + if (r.art === "p") { + links = `⋮⋮ + + ${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` ${esc(o.bauherr)}` : ""} + ${datumZelle(r.von)}${datumZelle(r.bis)}${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""} + `; + if (r.von) balken = `
`; + } else if (r.art === "a") { + links = ` + ${esc(o.name)} + ${datumZelle(r.von)}${datumZelle(r.bis)}${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""} + `; + if (r.von) balken = `
`; + } else { + const ms = Number(o.dauer) === 0; + links = `${o.nummer} + ${esc(o.name)} + ${datumZelle(o.anfang)}${datumZelle(o.ende)}${ms ? "◆" : Math.ceil(o.dauer)} + ${esc(vorgaengerText(linksVon(o.id), nummerVon))}`; + const breite = (tageZwischen(o.anfang, o.ende) + 1) * W; + balken = ms + ? `
` + : `
${breite > 40 ? `${Math.ceil(o.dauer)} AT` : ""}
`; + } + return `
+
${balken}
`; + }).join(""); + + // Pfeile für die Verknüpfungen + const pfeile = plan.verknuepfungen.map((k) => { + const a = plan.vorgaenge.find((v) => v.id === k.vorgaenger_id); + const b = plan.vorgaenge.find((v) => v.id === k.vorgang_id); + const ya = zeileVon.get(k.vorgaenger_id), yb = zeileVon.get(k.vorgang_id); + if (!a || !b || ya === undefined || yb === undefined) return ""; + const vonAnfang = k.art === "AA" || k.art === "AE", zuEnde = k.art === "EE" || k.art === "AE"; + const x1 = vonAnfang ? x(a.anfang) : x(a.ende) + W, x2 = zuEnde ? x(b.ende) + W : x(b.anfang); + const y1 = ya * ZEILE + ZEILE / 2, y2 = yb * ZEILE + ZEILE / 2; + const knick = vonAnfang ? Math.min(x1, x2) - 8 : zuEnde ? Math.max(x1, x2) + 8 : x1 + 6; + const spitze = zuEnde ? `${x2},${y2} ${x2 + 5},${y2 - 3} ${x2 + 5},${y2 + 3}` : `${x2},${y2} ${x2 - 5},${y2 - 3} ${x2 - 5},${y2 + 3}`; + return ``; + }).join(""); + + const hoehe = reihen.length * ZEILE; + const box = document.createElement("div"); + box.className = "gantt"; + box.innerHTML = `
+
+
${monate}
${kw}
${tagKopf}
+
+
${schatten}
+ ${pfeile} + ${zeilenHtml} +
+ ${reihen.length ? "" : '

Noch keine Projekte im Terminplan.

'}`; + inhalt.appendChild(box); + + const linksBreite = () => box.querySelector(".g-kopf .g-links")?.offsetWidth ?? 0; + const nachHeute = () => (box.scrollLeft = Math.max(0, x(heute) - (box.clientWidth - linksBreite()) / 3)); + const gespeichert = merke("gantt-scroll"); + if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute(); + box.addEventListener("scroll", () => merke("gantt-scroll", box.scrollLeft), { passive: true }); + const neuLaden = () => terminplanSeite(h); + + leiste.addEventListener("click", (ev) => { + const b = (ev.target as HTMLElement).closest("button"); + if (b?.dataset.zoom) { merke("gantt-zoom", b.dataset.zoom); merke("gantt-scroll", null as unknown as number); neuLaden(); } + if (b?.dataset.a === "heute") nachHeute(); + }); + leiste.querySelector('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); }; + + // Klicks in der linken Spalte + box.addEventListener("click", async (ev) => { + const t = ev.target as HTMLElement; + if (t.dataset.klapp) { + zu.has(t.dataset.klapp) ? zu.delete(t.dataset.klapp) : zu.add(t.dataset.klapp); + merke("gantt-zu", [...zu]); + return neuLaden(); + } + if (t.dataset.neuAbschnitt) { + const r = await h.dialog("Neuer Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], {}, false); + if (r?.aktion !== "speichern") return; + const reihenfolge = Math.max(0, ...plan.abschnitte.filter((a) => a.projekt_id === t.dataset.neuAbschnitt).map((a) => a.reihenfolge)) + 1; + await api("abschnitte", "POST", { projekt_id: t.dataset.neuAbschnitt, name: r.daten.name, reihenfolge }); + zu.delete(t.dataset.neuAbschnitt); + return neuLaden(); + } + if (t.dataset.neuVorgang) return vorgangDialog(null, t.dataset.neuVorgang); + const abschnittId = t.closest("[data-abschnitt]")?.dataset.abschnitt; + if (abschnittId) { + const a = plan.abschnitte.find((x) => x.id === abschnittId)!; + const r = await h.dialog("Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], a, true); + if (r?.aktion === "loeschen") await api(`abschnitte/${a.id}`, "DELETE"); + else if (r?.aktion === "speichern") await api(`abschnitte/${a.id}`, "PATCH", { name: r.daten.name }); + if (r) neuLaden(); + return; + } + const vorgangId = t.closest("[data-vorgang]")?.dataset.vorgang; + if (vorgangId) vorgangDialog(plan.vorgaenge.find((v) => v.id === vorgangId)!, null); + }); + + async function vorgangDialog(v: Zeile | null, abschnittId: string | null): Promise { + const geschwister = plan.vorgaenge.filter((x) => x.abschnitt_id === (v?.abschnitt_id ?? abschnittId)); + const letzter = geschwister[geschwister.length - 1]; + const vorschlag = letzter ? naechsterArbeitstag(plusTage(letzter.ende, 1), woche) : naechsterArbeitstag(heute, woche); + const werte = v + ? { name: v.name, start: v.anfang, dauer: String(Math.ceil(v.dauer)), vorgaenger: vorgaengerText(linksVon(v.id), nummerVon) } + : { name: "", start: vorschlag, dauer: "5", vorgaenger: letzter ? String(letzter.nummer) : "" }; + const r = await h.dialog(v ? `Vorgang ${v.nummer}` : "Neuer Vorgang", [ + { name: "name", titel: "Bezeichnung", pflicht: true }, + { name: "start", titel: "Start", art: "datum", pflicht: true }, + { name: "dauer", titel: "Dauer in Arbeitstagen (0 = Meilenstein)", art: "zahl", pflicht: true }, + { name: "vorgaenger", titel: "Vorgänger: Nummer, Art und Verzögerung, z. B. 1003, 1005 AA+2" }, + ], werte, !!v); + if (!r) return; + if (r.aktion === "loeschen") { await api(`vorgaenge/${v!.id}`, "DELETE"); return neuLaden(); } + const neu = leseVorgaenger(r.daten.vorgaenger ?? "", idVon); + const dauer = Math.max(0, Math.round(Number(r.daten.dauer))); + let id = v?.id; + if (v) await api(`vorgaenge/${v.id}`, "PATCH", { name: r.daten.name, start: r.daten.start, dauer }); + else id = (await api("vorgaenge", "POST", { abschnitt_id: abschnittId, name: r.daten.name, start: r.daten.start, dauer, reihenfolge: geschwister.length + 1 })).id; + // Verknüpfungen abgleichen: entfernte löschen, geänderte anpassen, neue anlegen + const alt = id ? linksVon(id) : []; + for (const k of alt) if (!neu.some((n) => n.vorgaenger_id === k.vorgaenger_id)) await api(`verknuepfungen/${k.id}`, "DELETE"); + for (const n of neu) { + const k = alt.find((a) => a.vorgaenger_id === n.vorgaenger_id); + if (!k) await api("verknuepfungen", "POST", { vorgang_id: id, ...n }); + else if (k.art !== n.art || k.verzoegerung !== n.verzoegerung) await api(`verknuepfungen/${k.id}`, "PATCH", { art: n.art, verzoegerung: n.verzoegerung }); + } + neuLaden(); + } + + // Balken ziehen: verschieben oder (rechter Griff) Dauer ändern + box.addEventListener("pointerdown", (ev) => { + const t = ev.target as HTMLElement; + const bar = t.closest("[data-bar]"); + if (!bar || ev.button !== 0) return; + const v = plan.vorgaenge.find((x) => x.id === bar.dataset.bar)!; + const dauerAendern = !!t.dataset.dauer; + const startX = ev.clientX; + const links0 = bar.offsetLeft, breite0 = bar.offsetWidth; + let bewegt = false; + bar.setPointerCapture(ev.pointerId); + bar.classList.add("zieht"); + const tage = (e: PointerEvent) => Math.round((e.clientX - startX) / W); + const zieh = (e: PointerEvent) => { + const n = tage(e); + if (n !== 0) bewegt = true; + if (dauerAendern) bar.style.width = `${Math.max(W, breite0 + n * W)}px`; + else bar.style.left = `${links0 + n * W}px`; + }; + const los = async (e: PointerEvent) => { + bar.removeEventListener("pointermove", zieh); + bar.classList.remove("zieht"); + const n = tage(e); + if (!bewegt || n === 0) { if (!bewegt) vorgangDialog(v, null); return; } + if (dauerAendern) { + const neuesEnde = plusTage(v.ende, n); + const dauer = Math.max(1, arbeitstageZwischen(v.anfang, neuesEnde < v.anfang ? v.anfang : neuesEnde, woche)); + await api(`vorgaenge/${v.id}`, "PATCH", { dauer }); + } else { + const ziel = plusTage(v.anfang, n); + await api(`vorgaenge/${v.id}`, "PATCH", { start: n > 0 ? naechsterArbeitstag(ziel, woche) : vorherigerArbeitstag(ziel, woche) }); + } + neuLaden(); + }; + bar.addEventListener("pointermove", zieh); + bar.addEventListener("pointerup", los, { once: true }); + }); + + // Projekte per Drag & Drop umsortieren (T1) + let gezogen: string | null = null; + box.addEventListener("dragstart", (ev) => { gezogen = (ev.target as HTMLElement).dataset.zieh ?? null; }); + box.addEventListener("dragover", (ev) => { if (gezogen && (ev.target as HTMLElement).closest(".g-zeile.p")) ev.preventDefault(); }); + box.addEventListener("drop", async (ev) => { + const ziel = (ev.target as HTMLElement).closest(".g-zeile.p")?.querySelector("[data-zieh]")?.dataset.zieh; + if (!gezogen || !ziel || ziel === gezogen) return; + ev.preventDefault(); + const ids = plan.projekte.map((p) => p.id).filter((id) => id !== gezogen); + ids.splice(ids.indexOf(ziel), 0, gezogen); + await Promise.all(ids.map((id, i) => (plan.projekte.find((p) => p.id === id)!.reihenfolge !== i ? api(`projekte/${id}`, "PATCH", { reihenfolge: i }) : null))); + gezogen = null; + neuLaden(); + }); +} + +function vorherigerArbeitstag(d: Datum, woche: Arbeitswoche): Datum { + let x = d; + while (!istArbeitstag(x, woche)) x = plusTage(x, -1); + return x; +} + +function kalenderwoche(d: Datum): number { + const t = new Date(`${d}T00:00:00Z`); + t.setUTCDate(t.getUTCDate() + 4 - (t.getUTCDay() || 7)); + const jahresanfang = Date.UTC(t.getUTCFullYear(), 0, 1); + return Math.ceil(((t.getTime() - jahresanfang) / 86400000 + 1) / 7); +} diff --git a/src/web/styles.css b/src/web/styles.css index 8a9e3a6..e958060 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -94,3 +94,56 @@ td.zahl { white-space: nowrap; } th, td { padding: 11px 10px; } td .unter { font-size: 12px; } } + +/* Terminplan (Gantt) */ +button.neben.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; } +.schalter { display: inline-flex; align-items: center; gap: 6px; color: var(--leise); font-size: 14px; } +.leiste .hinweis { font-size: 13px; margin-left: auto; } +.gantt { --links: 520px; overflow: auto; max-height: calc(100vh - 150px); background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; position: relative; } +.g-inhalt { position: relative; } +.g-kopf { position: sticky; top: 0; z-index: 4; display: flex; background: var(--fl); border-bottom: 1px solid var(--linie); } +.g-links { position: sticky; left: 0; z-index: 2; width: var(--links); flex: none; display: grid; grid-template-columns: 44px 22px 1fr 64px 64px 34px 92px 26px; align-items: center; gap: 4px; padding: 0 6px 0 8px; height: 34px; background: var(--fl); border-right: 1px solid var(--linie); font-size: 13px; } +.g-links.kopf { height: 63px; align-items: end; padding-bottom: 6px; font-size: 12px; color: var(--leise); font-weight: 600; z-index: 5; } +.g-zeit .reihe { display: flex; height: 21px; font-size: 11px; color: var(--leise); } +.g-zeit .reihe > div { border-left: 1px solid var(--linie); padding: 3px 4px; white-space: nowrap; overflow: hidden; flex: none; } +.g-zeit .reihe.tage > div { padding: 3px 0; text-align: center; } +.g-zeit .tage .frei, .g-zeit .tage .feiertag { color: var(--warn); } +.g-zeit .tage .reserve { color: var(--holz); } +.g-koerper { position: relative; } +.g-zeile { position: absolute; left: 0; right: 0; height: 34px; border-bottom: 1px solid var(--linie); } +.g-zeile.p .g-links { font-weight: 600; background: var(--bg); } +.g-zeile.p { background: var(--bg); } +.g-zeile .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.g-zeile .name small { font-weight: 400; color: var(--leise); } +.g-zeile.a .name { font-weight: 600; padding-left: 4px; cursor: pointer; } +.g-zeile.v .name { padding-left: 18px; cursor: pointer; } +.g-zeile .name.vorgang:hover, .g-zeile .name.abschnitt:hover { color: var(--akzent); text-decoration: underline; } +.g-zeile .nr { color: var(--leise); font-variant-numeric: tabular-nums; } +.g-zeile .dat, .g-zeile .at { font-variant-numeric: tabular-nums; color: var(--leise); } +.g-zeile .vg { color: var(--leise); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 12px; } +.g-links .klapp, .g-links .plus { background: none; border: 0; color: var(--leise); cursor: pointer; font: inherit; padding: 0; width: 22px; height: 22px; border-radius: 5px; } +.g-links .plus { font-size: 17px; color: var(--akzent); } +.g-links .klapp:hover, .g-links .plus:hover { background: var(--akzent-hell); } +.g-links .griff { cursor: grab; color: var(--leise); user-select: none; text-align: center; } +.g-balken { position: absolute; height: 34px; left: var(--links); right: 0; pointer-events: none; z-index: 1; } +.balken { position: absolute; top: 9px; height: 16px; border-radius: 4px; color: #fff; font-size: 11px; line-height: 16px; padding-left: 5px; white-space: nowrap; overflow: hidden; pointer-events: auto; } +.balken.projekt { top: 14px; height: 6px; padding: 0; pointer-events: none; } +.balken.abschnitt { top: 12px; height: 10px; opacity: 0.55; padding: 0; pointer-events: none; } +.balken.vorgang { cursor: grab; touch-action: none; box-shadow: 0 1px 2px rgb(0 0 0 / 0.2); } +.balken.zieht { cursor: grabbing; opacity: 0.8; outline: 2px solid var(--akzent); } +.balken .griff-rechts { position: absolute; right: 0; top: 0; bottom: 0; width: 7px; cursor: ew-resize; background: rgb(255 255 255 / 0.35); } +.balken.meilenstein { width: 14px; height: 14px; top: 10px; transform: rotate(45deg); border-radius: 2px; padding: 0; cursor: grab; touch-action: none; } +.g-schatten { position: absolute; top: 0; bottom: 0; left: var(--links); } +.g-schatten i { position: absolute; top: 0; bottom: 0; } +.g-schatten .frei { background: rgb(120 130 150 / 0.10); } +.g-schatten .feiertag { background: rgb(180 35 24 / 0.10); } +.g-schatten .reserve { background: repeating-linear-gradient(135deg, rgb(162 110 58 / 0.10) 0 4px, transparent 4px 8px); } +.g-schatten .heute { width: 2px; background: var(--warn); } +.g-pfeile { position: absolute; top: 0; left: var(--links); pointer-events: none; z-index: 1; overflow: visible; } +.g-pfeile path { fill: none; stroke: var(--leise); stroke-width: 1.2; } +.g-pfeile polygon { fill: var(--leise); } +@media (max-width: 800px) { + .gantt { --links: 220px; } + .g-links { grid-template-columns: 22px 1fr 22px; } + .g-links > :nth-child(1), .g-links > :nth-child(4), .g-links > :nth-child(5), .g-links > :nth-child(6), .g-links > :nth-child(7) { display: none; } +} diff --git a/test/api.test.ts b/test/api.test.ts index 2232bad..22800ff 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -149,4 +149,43 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => { expect(kurz(l)).toEqual(kurz(erwartet)); expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true); }); + + 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); + }); }); diff --git a/test/terminplan.test.ts b/test/terminplan.test.ts new file mode 100644 index 0000000..195e5a5 --- /dev/null +++ b/test/terminplan.test.ts @@ -0,0 +1,72 @@ +import { describe, expect, it } from "vitest"; +import { type PlanVorgang, type Verknuepfung, bildetKreis, ende, engeVorgaenge, fruehesterStart, planeNeu, startNachVerknuepfung } from "../src/domain/terminplan.js"; +import { STANDARDWOCHE as W } from "../src/domain/kalender.js"; + +// 19.10.2026 ist ein Montag; gearbeitet wird Mo–Do +const v = (id: string, start: string, dauer: number): PlanVorgang => ({ id, start, dauer }); +const k = (vorgang_id: string, vorgaenger_id: string, art: Verknuepfung["art"] = "EA", verzoegerung = 0): Verknuepfung => ({ vorgang_id, vorgaenger_id, art, verzoegerung }); + +describe("Verknüpfungsarten wie V70", () => { + const a = v("a", "2026-10-19", 3); // Mo–Mi + it("EA: am nächsten Arbeitstag nach dem Ende", () => { + expect(ende(a, W)).toBe("2026-10-21"); + expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a"), W)).toBe("2026-10-22"); + }); + it("EA mit Verzögerung überspringt Freitag und Wochenende", () => { + expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "EA", 1), W)).toBe("2026-10-26"); + }); + it("EA bei Meilenstein: am Ende des Vorgängers", () => { + expect(startNachVerknuepfung(v("m", "2026-10-19", 0), a, k("m", "a"), W)).toBe("2026-10-21"); + }); + it("AA: gleicher Anfang plus Verzögerung", () => { + expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "AA", 2), W)).toBe("2026-10-21"); + }); + it("EE: endet mit dem Vorgänger", () => { + const b = v("b", "2026-10-19", 2); + const s = startNachVerknuepfung(b, a, k("b", "a", "EE"), W); + expect(s).toBe("2026-10-20"); + expect(ende({ ...b, start: s }, W)).toBe("2026-10-21"); + }); + it("AE: endet, wenn der Vorgänger anfängt", () => { + const b = v("b", "2026-10-01", 2); + expect(startNachVerknuepfung(b, a, k("b", "a", "AE"), W)).toBe("2026-10-15"); + }); +}); + +describe("mehrere Vorgänger (T5)", () => { + it("der späteste Vorgänger bestimmt den Start", () => { + const alle = new Map([v("a", "2026-10-19", 2), v("b", "2026-10-19", 4), v("c", "2026-10-19", 1)].map((x) => [x.id, x])); + expect(fruehesterStart(alle.get("c")!, alle, [k("c", "a"), k("c", "b")], W)).toBe("2026-10-26"); + }); +}); + +describe("Neuplanung", () => { + const links = [k("b", "a"), k("c", "b")]; + it("schiebt Nachfolger nach hinten, wenn der Vorgänger länger dauert", () => { + const r = planeNeu([v("a", "2026-10-19", 5), v("b", "2026-10-22", 2), v("c", "2026-10-27", 1)], links, W); + expect(r.starts.get("b")).toBe("2026-10-27"); + expect(r.starts.get("c")).toBe("2026-10-29"); + }); + it("zieht nur enge Nachfolger nach vorn", () => { + const alt = [v("a", "2026-10-19", 3), v("b", "2026-10-22", 2), v("c", "2026-11-02", 1)]; + const eng = engeVorgaenge(alt, links, W); + expect([...eng]).toEqual(["b"]); + const r = planeNeu([v("a", "2026-10-19", 2), alt[1]!, alt[2]!], links, W, eng); + expect(r.starts.get("b")).toBe("2026-10-21"); + expect(r.starts.has("c")).toBe(false); + }); + it("lässt freie Vorgänge ohne Vorgänger in Ruhe", () => { + expect(planeNeu([v("x", "2026-10-19", 2)], [], W).starts.size).toBe(0); + }); +}); + +describe("Kreise", () => { + const links = [k("b", "a"), k("c", "b")]; + it("erkennt einen Kreis über mehrere Glieder", () => { + expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "c" }, links)).toBe(true); + expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "a" }, links)).toBe(true); + }); + it("erlaubt einen zweiten Vorgänger ohne Kreis", () => { + expect(bildetKreis({ vorgang_id: "c", vorgaenger_id: "a" }, links)).toBe(false); + }); +});