Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
220 lines
9.5 KiB
TypeScript
220 lines
9.5 KiB
TypeScript
// 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<string, PlanVorgang>, 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<string, PlanVorgang>, 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<string> {
|
|
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
|
|
const eng = new Set<string>();
|
|
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<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>;
|
|
/** Teil des Starttags je verschobenem Vorgang */
|
|
teile: Map<string, number>;
|
|
/** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */
|
|
dauern: Map<string, number>;
|
|
}
|
|
|
|
/**
|
|
* 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<string> = new Set(),
|
|
dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis {
|
|
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
|
|
const starts = new Map<string, Datum>();
|
|
const teile = new Map<string, number>();
|
|
const dauern = new Map<string, number>();
|
|
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 };
|
|
}
|