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

334
src/web/gantt.ts Normal file
View File

@@ -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<string, any>;
export interface Hilfen {
api<T = any>(pfad: string, methode?: string, body?: unknown): Promise<T>;
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<string, number> = { 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<T>(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<number, string>): { 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, number>): 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<void> {
const { api, esc, inhalt } = h;
const leiste = h.seite("Terminplan");
const plan = await api<Plan>("terminplan");
const woche: Arbeitswoche = { tage: plan.arbeitstage };
let zoom = merke<string>("gantt-zoom") ?? "tag";
const zu = new Set<string>(merke<string[]>("gantt-zu") ?? []);
const mitFertigen = merke<boolean>("gantt-fertige") ?? false;
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${z === zoom ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
<button class="neben" data-a="heute">Heute</button>
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
<span class="hinweis">Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve.</span>`;
const nummerVon = new Map<string, number>(plan.vorgaenge.map((v) => [v.id, v.nummer]));
const idVon = new Map<number, string>(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<string, number>();
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 += `<div style="width:${n * W}px">${n * W > 50 ? `${MONATE[Number(d.slice(5, 7)) - 1]} ${d.slice(0, 4)}` : ""}</div>`;
mStart = i + 1;
}
if (wochentag(naechster) === 1 || i === tage - 1) {
const n = i - wStart + 1;
kw += `<div style="width:${n * W}px">${n * W > 34 ? `KW ${kalenderwoche(d)}` : ""}</div>`;
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 += `<div class="${klasse}" style="width:${W}px"${titel ? ` title="${esc(titel)}"` : ""}>${W >= 18 ? Number(d.slice(8)) : ""}</div>`;
if (klasse) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
}
if (heute >= von && heute <= bis) schatten += `<i class="heute" style="left:${x(heute) + W / 2}px"></i>`;
// Linke Spalten und Balken je Zeile
const zeilenHtml = reihen.map((r, i) => {
const o = r.obj;
let links = "", balken = "";
const datumZelle = (d?: Datum) => `<span class="dat">${d ? formatDatum(d).slice(0, 6) + d.slice(2, 4) : "–"}</span>`;
if (r.art === "p") {
links = `<span class="griff" draggable="true" data-zieh="${o.id}" title="Ziehen, um die Reihenfolge zu ändern">⋮⋮</span>
<button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
<span class="name" title="${esc(o.bezeichnung)}"><b>${esc(o.nummer)}</b> ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span>
<button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button>`;
if (r.von) balken = `<div class="balken projekt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
} else if (r.art === "a") {
links = `<span></span><button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
<span class="name abschnitt" data-abschnitt="${o.id}" title="Umbenennen">${esc(o.name)}</span>
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span>
<button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button>`;
if (r.von) balken = `<div class="balken abschnitt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
} else {
const ms = Number(o.dauer) === 0;
links = `<span class="nr">${o.nummer}</span><span></span>
<span class="name vorgang" data-vorgang="${o.id}" title="Bearbeiten">${esc(o.name)}</span>
${datumZelle(o.anfang)}${datumZelle(o.ende)}<span class="at">${ms ? "◆" : Math.ceil(o.dauer)}</span>
<span class="vg" title="Vorgänger">${esc(vorgaengerText(linksVon(o.id), nummerVon))}</span><span></span>`;
const breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
balken = ms
? `<div class="balken meilenstein" data-bar="${o.id}" style="left:${x(o.anfang) + W / 2 - 7}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)}"></div>`
: `<div class="balken vorgang" data-bar="${o.id}" style="left:${x(o.anfang)}px;width:${breite}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${Math.ceil(o.dauer)} AT">${breite > 40 ? `${Math.ceil(o.dauer)} AT` : ""}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`;
}
return `<div class="g-zeile ${r.art}" style="top:${i * ZEILE}px"><div class="g-links" style="box-shadow:inset 4px 0 0 ${r.art === "p" ? r.farbe : "transparent"}">${links}</div></div>
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
}).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 `<path d="M${x1} ${y1}H${knick}V${y2}H${x2}"/><polygon points="${spitze}"/>`;
}).join("");
const hoehe = reihen.length * ZEILE;
const box = document.createElement("div");
box.className = "gantt";
box.innerHTML = `<div class="g-inhalt" style="width:calc(var(--links) + ${tage * W}px)">
<div class="g-kopf"><div class="g-links kopf"><span>Nr.</span><span></span><span>Projekt / Vorgang</span><span>Start</span><span>Ende</span><span>AT</span><span>Vorgänger</span><span></span></div>
<div class="g-zeit"><div class="reihe">${monate}</div><div class="reihe">${kw}</div><div class="reihe tage">${tagKopf}</div></div></div>
<div class="g-koerper" style="height:${hoehe}px">
<div class="g-schatten" style="width:${tage * W}px">${schatten}</div>
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
${zeilenHtml}
</div></div>
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}`;
inhalt.appendChild(box);
const linksBreite = () => box.querySelector<HTMLElement>(".g-kopf .g-links")?.offsetWidth ?? 0;
const nachHeute = () => (box.scrollLeft = Math.max(0, x(heute) - (box.clientWidth - linksBreite()) / 3));
const gespeichert = merke<number>("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<HTMLInputElement>('[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<HTMLElement>("[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<HTMLElement>("[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<void> {
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<Zeile>("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<HTMLElement>("[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<HTMLElement>("[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);
}