Files
Betriebsf-hrungssoftware/src/web/gantt.ts

409 lines
25 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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[];
besetzungen: Zeile[];
leute: Zeile[];
ueberschneidungen: 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;
// Besetzung (T14): Kürzel je Vorgang, vorgemerkte (noch nicht freigegebene) gestrichelt
const besetzungVon = (id: string) => plan.besetzungen.filter((b) => b.vorgang_id === id);
const leuteHtml = (id: string) => besetzungVon(id).map((b) =>
`<span class="person${b.freigegeben ? "" : " vorgemerkt"}" title="${esc(b.anzeige)}${Number(b.personen) !== 1 ? `, ${String(b.personen).replace(".", ",")} Personen` : ""}${b.freigegeben ? "" : " (vorgemerkt, noch nicht freigegeben)"}">${esc(b.kurz)}${Number(b.personen) !== 1 ? ` ×${String(b.personen).replace(".", ",")}` : ""}</span>`).join("");
const imKonflikt = new Set(plan.ueberschneidungen.flatMap((u) => [u.vorgang_a, u.vorgang_b]));
// 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><span></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><span></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 class="leute" data-besetzung="${o.id}" title="Besetzung bearbeiten">${leuteHtml(o.id) || '<span class="leer">+ Personal</span>'}</span><span></span>`;
const breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
const konflikt = imKonflikt.has(o.id) ? " konflikt" : "";
const nachBalken = leuteHtml(o.id) ? `<div class="balken-leute" style="left:${x(o.ende) + W + 6}px">${leuteHtml(o.id)}</div>` : "";
balken = nachBalken + (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${konflikt}" 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>Personal</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>'}`;
if (plan.ueberschneidungen.length) {
const vName = (id: string) => {
const v = plan.vorgaenge.find((x) => x.id === id)!;
const p = plan.projekte.find((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id));
return `${p ? p.nummer + " " : ""}${v.name}`;
};
inhalt.insertAdjacentHTML("beforeend", `<div class="warnung"><b>Terminüberschneidung</b><ul>${plan.ueberschneidungen.map((u) =>
`<li>${esc(u.name)} ab ${formatDatum(u.ab)}: ${esc(vName(u.vorgang_a))} und ${esc(vName(u.vorgang_b))}</li>`).join("")}</ul></div>`);
}
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 besetzungId = t.closest<HTMLElement>("[data-besetzung]")?.dataset.besetzung;
if (besetzungId) return besetzungDialog(plan.vorgaenge.find((v) => v.id === besetzungId)!);
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);
});
// Besetzung bearbeiten: Liste mit Freigabe, darunter Person oder Platzhalter hinzufügen
function besetzungDialog(v: Zeile): void {
const huelle = document.getElementById("dialog-huelle")!;
const zeichne = () => {
const liste = besetzungVon(v.id);
huelle.innerHTML = `<div class="dialog besetzung"><h2>Besetzung: ${esc(v.name)}</h2>
<p class="hinweis">${formatDatum(v.anfang)} – ${formatDatum(v.ende)}</p>
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}</td>
<td class="zahl">${String(b.personen).replace(".", ",")} P.</td>
<td>${b.rolle === "mitarbeiter" ? "" : `<label class="schalter"><input type="checkbox" data-frei="${b.id}"${b.freigegeben ? " checked" : ""}> freigegeben</label>`}</td>
<td><button class="neben" data-weg="${b.id}" title="Entfernen">×</button></td></tr>`).join("")}</tbody></table>` : '<p class="hinweis">Noch niemand eingeteilt.</p>'}
<label for="b-wer">Hinzufügen</label>
<select id="b-wer"><option value="">– auswählen –</option>
${plan.leute.map((k) => `<option value="${k.id}">${esc(k.rolle === "subunternehmer" && k.firma ? k.firma : k.name)} (${k.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"})</option>`).join("")}
<option value="platzhalter">Platzhalter, z. B. N.N. oder Kolonne 2 …</option></select>
<input id="b-platzhalter" placeholder="Name des Platzhalters" hidden>
<label for="b-personen">Personen</label><input id="b-personen" value="1" inputmode="decimal">
<p class="hinweis">Subunternehmer und Platzhalter sind vorgemerkt, bis du sie freigibst. Mitarbeiter und Subunternehmer legst du unter Kontakte an.</p>
<p class="fehler" id="b-fehler"></p>
<div class="knoepfe"><button class="neben" data-a="zu">Fertig</button><button class="haupt" data-a="dazu">Hinzufügen</button></div></div>`;
huelle.hidden = false;
const wahl = huelle.querySelector<HTMLSelectElement>("#b-wer")!;
wahl.onchange = () => (huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.hidden = wahl.value !== "platzhalter");
};
const neu = async () => { Object.assign(plan, await api<Plan>("terminplan")); zeichne(); };
zeichne();
const schliessen = () => { huelle.hidden = true; huelle.innerHTML = ""; huelle.onclick = huelle.onchange = null; neuLaden(); };
huelle.onclick = async (ev) => {
const t = ev.target as HTMLElement;
try {
if (t.dataset.a === "zu") return schliessen();
if (t.dataset.weg) { await api(`besetzungen/${t.dataset.weg}`, "DELETE"); return neu(); }
if (t.dataset.a === "dazu") {
const w = huelle.querySelector<HTMLSelectElement>("#b-wer")!.value;
const platzhalter = huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.value.trim();
const personen = Number(huelle.querySelector<HTMLInputElement>("#b-personen")!.value.replace(",", "."));
if (!w || (w === "platzhalter" && !platzhalter)) throw new Error("Bitte eine Person oder einen Platzhalter wählen.");
if (!(personen > 0)) throw new Error("Personen muss größer als 0 sein.");
await api("besetzungen", "POST", { vorgang_id: v.id, personen, ...(w === "platzhalter" ? { platzhalter } : { kontakt_id: w }) });
return neu();
}
} catch (e) {
huelle.querySelector("#b-fehler")!.textContent = (e as Error).message;
}
};
huelle.onchange = async (ev) => {
const t = ev.target as HTMLInputElement;
if (t.dataset.frei) { await api(`besetzungen/${t.dataset.frei}`, "PATCH", { freigegeben: t.checked }); neu(); }
};
}
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);
}