// 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, wocheVon } from "./kalender.js"; export type Art = "EA" | "AA" | "EE" | "AE"; export interface PlanVorgang { id: string; start: Datum; /** Arbeitstage in Vierteln (0,25 = Vierteltag); 0 = Meilenstein */ dauer: number; /** Teil des ersten Tages, der vorher schon belegt ist (z. B. 0,5: beginnt mittags) */ start_teil?: number | null; /** Freitage, an denen dieser Vorgang ausnahmsweise ausgeführt wird */ freitage?: Datum[] | null; } export interface Verknuepfung { vorgang_id: string; vorgaenger_id: string; art: Art; /** Arbeitstage, darf negativ sein */ verzoegerung: number; } const tage = (v: PlanVorgang) => Number(v.dauer); export const teilVon = (v: PlanVorgang) => (tage(v) > 0 ? Number(v.start_teil ?? 0) : 0); /** Zeitpunkt im Plan: Tag und wie viel davon schon vorbei ist (0 = Tagesbeginn) */ export interface Lage { tag: Datum; teil: number } const vorLage = (a: Lage, b: Lage) => a.tag < b.tag || (a.tag === b.tag && a.teil < b.teil - 1e-9); const gleich = (a: Lage, b: Lage) => a.tag === b.tag && Math.abs(a.teil - b.teil) < 1e-9; export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum { return naechsterArbeitstag(v.start, wocheVon(v, woche)); } export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum { return endeNachDauer(v.start, tage(v), wocheVon(v, woche), teilVon(v)); } /** Wie viel vom letzten Tag belegt ist (0 < x ≤ 1); Meilensteine zählen als ganzer Tag */ export function endeTeil(v: PlanVorgang): number { if (tage(v) === 0) return 1; const x = teilVon(v) + tage(v); return x - (Math.ceil(x - 1e-9) - 1); } /** Anfang als Lage; der Teil gilt nur, wenn der Starttag ein Arbeitstag ist */ function anfangsLage(v: PlanVorgang, woche: Arbeitswoche): Lage { const a = anfang(v, woche); return { tag: a, teil: a === v.start ? teilVon(v) : 0 }; } /** 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, und zwar nach `teil` dieses Tages (1 = Tagesende). */ function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche, teil = 1): Lage { const w = wocheVon(v, woche); const e = naechsterArbeitstag(endeAm, w); if (e !== endeAm) teil = 1; if (tage(v) === 0) return { tag: e, teil: 0 }; // vom Ende zurückrechnen: Tag e zählt als 0, davor negativ const x = teil - tage(v); const ganz = Math.floor(x + 1e-9); return { tag: ganz === 0 ? e : verschiebeArbeitstage(e, ganz, w), teil: Math.max(0, x - ganz) }; } /** Start an einem Tag nach `teil`; liegt der Tag im Kalender des Nachfolgers nicht, ab dem nächsten Arbeitstag */ function lageAm(d: Datum, teil: number, w: Arbeitswoche): Lage { const t = naechsterArbeitstag(d, w); return t === d ? { tag: d, teil } : { tag: t, teil: 0 }; } /** * Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt, mit dem Teil des Tages: endet der Vorgänger * nach einem Vierteltag, beginnt der Nachfolger am selben Tag danach (Henning, 22.10.2026). */ export function lageNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Lage { const lg = k.verzoegerung; const meilenstein = tage(v) === 0; // gezählt wird im Kalender des Nachfolgers: ein freigegebener Freitag des Nachfolgers kann sein Start sein const w = wocheVon(v, woche); const e = ende(vorgaenger, woche), et = endeTeil(vorgaenger); const a = anfangsLage(vorgaenger, woche); switch (k.art) { case "EA": if (meilenstein) return { tag: versatz(e, lg, w), teil: 0 }; if (et < 1 - 1e-9) return lg === 0 ? lageAm(e, et, w) : { tag: versatz(e, lg, w), teil: et }; return { tag: versatz(e, 1 + lg, w), teil: 0 }; case "AA": return lg === 0 ? lageAm(a.tag, a.teil, w) : { tag: versatz(a.tag, lg, w), teil: a.teil }; case "EE": return startFuerEnde(v, versatz(e, lg, w), woche, et); case "AE": return startFuerEnde(v, versatz(a.tag, lg, w), woche, a.teil > 0 ? a.teil : 1); } } /** Frühester Starttag, den eine Verknüpfung dem Nachfolger erlaubt. */ export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum { return lageNachVerknuepfung(v, vorgaenger, k, woche).tag; } function fruehesteLage(v: PlanVorgang, alle: Map, links: Verknuepfung[], woche: Arbeitswoche): Lage | undefined { let s: Lage | 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 = lageNachVerknuepfung(v, p, k, woche); if (!s || vorLage(s, x)) s = x; } return s; } /** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */ export function fruehesterStart(v: PlanVorgang, alle: Map, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined { return fruehesteLage(v, alle, links, woche)?.tag; } /** 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 = fruehesteLage(v, alle, links, woche); if (f && gleich(f, anfangsLage(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; /** Teil des Starttags je verschobenem Vorgang */ teile: Map; /** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */ dauern: 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). * `dauerFuer` liefert für Vorgänge ohne feste Dauer die Dauer am jeweiligen Start (T15); Start und Dauer * hängen bei EE und AE voneinander ab, deshalb wird bis zu dreimal abgeglichen. */ export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set = new Set(), dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis { const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }])); const starts = new Map(); const teile = new Map(); const dauern = new Map(); for (const v of topologisch(vorgaenge, links)) { const x = stand.get(v.id)!; for (let runde = 0; runde < 3; runde++) { const d = dauerFuer?.(x); if (d !== undefined && d !== Number(x.dauer)) { x.dauer = d; dauern.set(v.id, d); } const f = fruehesteLage(x, stand, links, woche); const a = anfangsLage(x, woche); if (!f || !(vorLage(a, f) || (vorLage(f, a) && eng.has(v.id)))) break; x.start = f.tag; x.start_teil = f.teil; starts.set(v.id, f.tag); teile.set(v.id, f.teil); } } return { starts, teile, dauern }; }