Terminplan als Gantt: Verknüpfungen mit mehreren Vorgängern, Neuplanung der Nachfolger, Vorgangsnummern

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-19 18:54:51 +00:00
parent cc1116a540
commit 57b9ff5d26
11 changed files with 770 additions and 20 deletions

149
src/domain/terminplan.ts Normal file
View File

@@ -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<string, PlanVorgang>, 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<string> {
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
const eng = new Set<string>();
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<Verknuepfung, "vorgang_id" | "vorgaenger_id">, links: Verknuepfung[]): boolean {
if (neu.vorgang_id === neu.vorgaenger_id) return true;
const nachfolger = new Map<string, string[]>();
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<string>();
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<string, string[]>();
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<string, Datum>;
}
/**
* 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<string> = new Set()): Ergebnis {
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
const starts = new Map<string, Datum>();
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 };
}