Files
Betriebsf-hrungssoftware/src/web/gantt.ts
Claude feb19241c5
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.19.0: einzelne Freitage je Vorgang freigeben
Nur für diesen Vorgang zählt der Freitag als Arbeitstag (Dauer, Ende, Nachfolger,
Auslastung, Kalender-Abo, Wer macht was, Einsätze am Handy).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-21 16:34:10 +00:00

1266 lines
87 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.
// Bearbeitet wird wie in MS Project direkt in der Tabelle links (Henning, 20.10.2026), damit die
// anderen Vorgänge sichtbar bleiben; die Bearbeitungsspalten lassen sich ausblenden.
// Die Neuplanung der Nachfolger macht der Server.
import { formatEuro, parseEuro } from "../domain/geld.js";
import { bezugText, leseBezug } from "../domain/bezug.js";
import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js";
import { wer } from "../domain/einsatz.js";
import { gesamtFortschritt, imVerzug, sollFortschritt } from "../domain/fortschritt.js";
import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag, wocheVon } 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;
/** Filtermenü und gespeicherte Ansicht wie in den Tabellen (liste.ts) */
filterMenue(anker: HTMLElement, o: { titel: string; werte: FilterWert[]; aus: string[]; fertig: (aus: string[]) => void }): void;
filterText(werte: FilterWert[], aus: string[]): string;
ansicht: { lies(schluessel: string): GanttAnsicht; setze(schluessel: string, a: GanttAnsicht): void };
auge: [string, string];
}
interface FilterWert { wert: string; text: string; anzahl: number }
interface GanttAnsicht { sort: [string, "auf" | "ab"][]; filter: Record<string, string[]>; zeit: Record<string, string>; aus: string[] }
/** Nur beauftragte und laufende Projekte zeigen „im Verzug“ */
const LAUFEND = new Set(["auftrag", "ausfuehrung"]);
/** Ausgeblendete Zeilen gerade zeigen (bis zum Neuladen der Seite) */
let ausZeigen = false;
const OHNE = "(ohne Besetzung)";
interface Plan {
projekte: Zeile[];
abschnitte: Zeile[];
vorgaenge: Zeile[];
verknuepfungen: Zeile[];
besetzungen: Zeile[];
leute: Zeile[];
ueberschneidungen: Zeile[];
zahlungen: Zeile[];
/** Ausgaben (Kosten) und Aufgaben der Projekte, im Abschnitt „Zahlungen“ und „Aufgaben“ */
kosten?: Zeile[];
aufgaben?: Zeile[];
arbeitstage: number[];
/** 0.15: Kolonnen mit ihren Mitgliedern (Kontakt-IDs) */
kolonnen?: Zeile[];
team?: string[];
auslastung?: { ab: Datum; geplant: number; verfuegbar: number; personen: { kontakt_id: string; geplant: number; verfuegbar: number }[] }[];
}
const ZOOM: Record<string, number> = { tag: 24, woche: 10, monat: 4 };
// Zoom wie in MS Project: Ziehen an der Zeitskala; Regler und −/+ auf Hennings Wunsch entfernt (Henning, 20.10.2026), Pixel je Tag
const ZOOM_MIN = 2, ZOOM_MAX = 48;
const zoomGrenzen = (w: number) => Math.round(Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, w)) * 10) / 10;
/** Welcher Tag beim Zoomen an welcher Stelle (Pixel ab dem Zeitbereich) stehen bleibt */
let zoomAnker: { tag: number; px: number } | null = null;
const ZEILE = 42;
/** senkrechte Mitte der Balken in der Zeile; darüber steht der Name */
const BALKEN_MITTE = 28;
const LINKS_MIN = 60;
// Spaltenbreiten links, am Spaltenkopf ziehbar und gemerkt (Henning, 20.10.2026); auf kleineren Bildschirmen schmaler
const SPALTEN = ["nr", "name", "dauer", "vg", "anfang", "ende", "erl", "res"] as const;
type Spalte = (typeof SPALTEN)[number];
const BREITE_GROSS: Record<Spalte, number> = { nr: 40, name: 260, dauer: 70, vg: 70, anfang: 96, ende: 96, erl: 58, res: 140 };
const BREITE_KLEIN: Record<Spalte, number> = { nr: 32, name: 170, dauer: 56, vg: 48, anfang: 84, ende: 84, erl: 50, res: 100 };
const SPALTE_MIN = 16;
const WOCHENTAGE = ["Son", "Mon", "Die", "Mit", "Don", "Fre", "Sam"];
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;
}
/** „22.10.“, „22.10.26“, „22.10.2026“ oder „2026-10-22“; das Jahr ohne Angabe kommt aus `bezug`. */
export function leseDatum(text: string, bezug: Datum): Datum {
const t = text.trim().replace(/^[a-zäöü]{2,3}\.?,?\s+/i, "");
if (/^\d{4}-\d{2}-\d{2}$/.test(t)) return t;
const m = /^(\d{1,2})\.(\d{1,2})\.?(\d{2}|\d{4})?$/.exec(t);
if (!m) throw new Error(`„${t}“ ist kein Datum. Beispiel: 22.10.26`);
const jahr = m[3] ? (m[3].length === 2 ? 2000 + Number(m[3]) : Number(m[3])) : Number(bezug.slice(0, 4));
const d = `${jahr}-${m[2]!.padStart(2, "0")}-${m[1]!.padStart(2, "0")}`;
const probe = new Date(`${d}T00:00:00Z`);
if (Number.isNaN(probe.getTime()) || probe.toISOString().slice(0, 10) !== d) throw new Error(`Den ${t} gibt es nicht.`);
return d;
}
const kurzDatum = (d: Datum) => formatDatum(d).slice(0, 6) + d.slice(2, 4);
/** „Mit 12.08.26“ wie die Spalten Anfang und Ende in MS Project */
const tabellenDatum = (d: Datum) => `${WOCHENTAGE[wochentag(d) % 7]} ${kurzDatum(d)}`;
/** „12.08“ an den Balken */
const balkenDatum = (d: Datum) => formatDatum(d).slice(0, 5);
export const dauerText = (n: number) => `${n} ${n === 1 ? "Tag" : "Tage"}`;
/** Nach dem Speichern und Neuzeichnen hier weiter bearbeiten (Enter: nächste Zeile, Tab: nächste Spalte) */
let weiter: { id: string; feld: string } | null = null;
/** In welcher Spalte ein Feld steht; Enter springt in dieselbe Spalte der nächsten Zeile */
const SPALTE_VON: Record<string, Spalte> = {
name: "name", dauer: "dauer", vg: "vg", start: "anfang", ende: "ende", erl: "erl",
"t-text": "name", "t-vg": "vg", "t-datum": "anfang",
"z-name": "name", "z-vg": "vg", "z-datum": "anfang", "z-betrag": "res",
"k-name": "name", "k-vg": "vg", "k-datum": "anfang", "k-betrag": "res",
};
/** Zahlungen, Kosten und Aufgaben im Terminplan (Henning, 20.10.2026): Art im Plan → Pfad der API und Datumsfeld */
const POSTEN: Record<"t" | "z" | "k", { pfad: string; datum: string }> = {
t: { pfad: "aufgaben", datum: "faellig_am" }, z: { pfad: "zahlungen", datum: "termin" }, k: { pfad: "kosten", datum: "termin" },
};
const GRUPPE_NAME: Record<string, string> = { aufg: "Aufgaben", aus: "Ausgaben" };
/** „5, 7AA+2“ (Zeilennummern) → Liste von Verknüpfungen; wirft, wenn in der Zeile kein Vorgang steht. */
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: 5, 5AA, 5EA+2`);
const id = nummern.get(Number(m[1]));
if (!id) throw new Error(`In Zeile ${m[1]} steht kein Vorgang. Vorgänger kann nur ein Vorgang sein, kein Projekt oder Abschnitt.`);
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(", ");
}
// Rückgängig (Henning, 20.10.2026): Strg+Z oder der Knopf „Rückgängig“ nimmt die letzten Änderungen im
// Terminplan zurück, z. B. eine verschobene Rate oder einen gezogenen Balken. Gilt bis zum Neuladen der Seite.
type Schritt = { pfad: string; vorher: Record<string, unknown>; aktion: number };
const verlauf: Schritt[] = [];
let aktion = 0, letzteAenderung = 0;
let zuruecknehmen: (() => Promise<void>) | null = null;
let tasteDa = false;
const TABELLE_IM_PLAN = ["vorgaenge", "abschnitte", "zahlungen", "kosten", "aufgaben", "besetzungen", "verknuepfungen", "projekte"] as const;
export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void> {
const { esc, inhalt } = h;
// erst laden, dann die Seite leeren: so springt die Ansicht beim Speichern nicht nach oben;
// beim Zoomen wird der schon geladene Plan nur neu gezeichnet
const plan = vorhanden ?? await h.api<Plan>("terminplan");
// jede Änderung merkt sich die alten Werte; was kurz nacheinander gespeichert wird, gilt als ein Schritt
const api: Hilfen["api"] = async (pfad, methode, body) => {
const [tabelle, id] = pfad.split("/");
if (methode === "PATCH" && body && typeof body === "object" && (TABELLE_IM_PLAN as readonly string[]).includes(tabelle!)) {
const alt = ((plan as unknown as Record<string, Zeile[] | undefined>)[tabelle!] ?? []).find((x) => x.id === id);
if (alt) {
const vorher = Object.fromEntries(Object.entries(body as Record<string, unknown>).map(([k, neu]) => {
const a = alt[k] ?? null;
return [k, typeof neu === "number" && typeof a === "string" && a !== "" && !Number.isNaN(Number(a)) ? Number(a) : a];
}));
if (Date.now() - letzteAenderung > 800) aktion++;
letzteAenderung = Date.now();
verlauf.push({ pfad, vorher, aktion });
}
}
return h.api(pfad, methode, body);
};
const leiste = h.seite("Terminplan");
const woche: Arbeitswoche = { tage: plan.arbeitstage };
const W = zoomGrenzen(merke<number>("gantt-w") ?? ZOOM[merke<string>("gantt-zoom") ?? "tag"] ?? 24);
const zu = new Set<string>(merke<string[]>("gantt-zu") ?? []);
const mitFertigen = merke<boolean>("gantt-fertige") ?? false;
// Ü5: nur die Vorgänge einer Person, eines Subunternehmers oder einer Kolonne zeigen
const personen = new Map<string, string>();
for (const k of plan.leute) personen.set(k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name);
for (const b of plan.besetzungen) { const w = wer(b); if (w && !personen.has(w)) personen.set(w, b.anzeige); }
// eine Kolonne zählt im Filter auch für jedes ihrer Mitglieder
const werAlle = (b: Zeile): (string | undefined)[] => [wer(b), ...((b.mitglieder as string[] | undefined) ?? [])];
// Filtern und Ausblenden wie in den Tabellen; die Reihenfolge bleibt die gezogene (Henning, 20.10.2026)
const ansicht = h.ansicht.lies("terminplan");
const personAus = ansicht.filter.person ?? [], projektAus = ansicht.filter.projekt ?? [];
const ausgeblendet = new Set(ansicht.aus);
const filter = personAus.length > 0;
const passt = (v: Zeile) => {
if (!filter) return true;
const leute = plan.besetzungen.filter((b) => b.vorgang_id === v.id).flatMap(werAlle);
return leute.length ? leute.some((p) => p && !personAus.includes(p)) : !personAus.includes(OHNE);
};
const sichtbarZeile = (id: string) => ausZeigen || !ausgeblendet.has(id);
const setzeAnsicht = (neu: Partial<GanttAnsicht>) => { h.ansicht.setze("terminplan", { ...ansicht, ...neu }); void terminplanSeite(h, plan); };
const projekteAlle = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen");
const personWerte: FilterWert[] = [...[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => ({ wert: id, text: name, anzahl: new Set(plan.besetzungen.filter((b) => werAlle(b).includes(id)).map((b) => b.vorgang_id)).size })),
{ wert: OHNE, text: OHNE, anzahl: plan.vorgaenge.filter((v) => !plan.besetzungen.some((b) => b.vorgang_id === v.id)).length }];
const projektWerte: FilterWert[] = projekteAlle.map((p) => ({ wert: p.id, text: `${p.nummer} ${p.bezeichnung}`, anzahl: 0 }));
const filterWerte: Record<string, FilterWert[]> = { person: personWerte, projekt: projektWerte };
const filterKnopf = (id: string, titel: string, aus: string[]) => aus.length
? `<span class="chip"><button class="chip-text" data-filter="${id}" title="${titel} filtern">${esc(titel)}: ${esc(h.filterText(filterWerte[id]!, aus))}</button><button data-filter-weg="${id}" aria-label="Filter ${titel} entfernen">✕</button></span>`
: `<button class="neben" data-filter="${id}" aria-haspopup="true">${titel} ▾</button>`;
const alleIds = new Set([...plan.projekte, ...plan.abschnitte, ...plan.vorgaenge, ...(plan.aufgaben ?? []), ...(plan.zahlungen ?? []), ...(plan.kosten ?? [])].map((x) => x.id as string));
for (const p of plan.projekte) for (const g of Object.keys(GRUPPE_NAME)) alleIds.add(`${g}:${p.id}`);
const anzahlAus = ansicht.aus.filter((id) => alleIds.has(id)).length;
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${ZOOM[z] === W ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
<button class="neben" data-a="heute">Heute</button>
<button class="neben" data-a="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>
${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("person", "Personal", personAus)}
${anzahlAus ? `<span class="g-aus">${anzahlAus} ausgeblendet · <button class="verweis" data-a="aus-zeigen">${ausZeigen ? "wieder verbergen" : "einblenden"}</button>${ausZeigen ? ' · <button class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}</span>` : ""}
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
<span class="hinweis">In eine Zelle klicken zum Bearbeiten: Enter speichert und geht eine Zeile tiefer, Tab eine Spalte weiter, Esc bricht ab. Zeile an der Nummer anfassen und verschieben. Spaltenbreite am Spaltenkopf ziehen, die Trennleiste blendet Spalten aus, an der Zeitskala ziehen zoomt. Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve; einzelne Freitage gibst du je Vorgang frei: Klick in „% erl.“ oder Rechtsklick auf den Balken.</span>
<span class="fehler g-meldung" role="status"></span>`;
const projekte = projekteAlle.filter((p) => !projektAus.includes(p.id));
const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]);
// Zeilennummern wie die Nr. in MS Project (Henning, 20.10.2026): fortlaufend über Projekte, Abschnitte
// und Vorgänge; Zuklappen, Filter und Ausblenden ändern sie nicht, Verschieben schon.
// Ausgeblendete abgeschlossene Projekte zählen hinten weiter, damit Verknüpfungen dorthin lesbar bleiben.
const postenVon = (pid: string) => ({
aufgaben: (plan.aufgaben ?? []).filter((t) => t.projekt_id === pid),
raten: (plan.zahlungen ?? []).filter((z) => z.projekt_id === pid),
kosten: (plan.kosten ?? []).filter((k) => k.projekt_id === pid),
});
const postenListe = (art: string) => (art === "t" ? plan.aufgaben : art === "z" ? plan.zahlungen : plan.kosten) ?? [];
const postenDatum = (art: string, o: Zeile): Datum | undefined => (art === "t" ? o.faellig_am : o.termin) ?? undefined;
const zeilenNr = new Map<string, number>();
let zaehler = 0;
for (const p of [...projekteAlle, ...plan.projekte.filter((p) => !projekteAlle.includes(p))]) {
zeilenNr.set(p.id, ++zaehler);
for (const a of plan.abschnitte.filter((a) => a.projekt_id === p.id)) {
zeilenNr.set(a.id, ++zaehler);
for (const v of plan.vorgaenge.filter((v) => v.abschnitt_id === a.id)) zeilenNr.set(v.id, ++zaehler);
}
const pp = postenVon(p.id);
zeilenNr.set(`aufg:${p.id}`, ++zaehler);
for (const t of pp.aufgaben) zeilenNr.set(t.id, ++zaehler);
}
const idVon = new Map<number, string>(plan.vorgaenge.map((v) => [zeilenNr.get(v.id)!, v.id]));
const linksVon = (id: string) => plan.verknuepfungen.filter((k) => k.vorgang_id === id);
// 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)));
const postenDaten = filter ? [] : projekte.flatMap((p) => { const pp = postenVon(p.id); return [...pp.aufgaben.map((t) => t.faellig_am), ...pp.raten.map((z) => z.termin), ...pp.kosten.map((k) => k.termin)]; }).filter(Boolean) as Datum[];
let von = montagDerWoche(plusTage([...sichtbar.map((v) => v.anfang as Datum), ...postenDaten].reduce((m, d) => (d < m ? d : m), heute), -7));
let bis = plusTage([...sichtbar.map((v) => v.ende as Datum), ...postenDaten].reduce((m, d) => (d > m ? d : m), plusTage(heute, 30)), 21);
// die Zeitskala füllt auch weit herausgezoomt die Breite
const minTage = Math.ceil(1600 / W);
if (tageZwischen(von, bis) + 1 < minTage) bis = plusTage(von, minTage - 1);
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]));
// T15: berechnete Dauer markieren; bei fester Dauer die Abweichung zur Besetzung zeigen
const zahlText = (n: number) => String(n).replace(".", ",");
const dauerHinweis = (o: Zeile) => {
if (o.dauer_besetzung == null || Number(o.dauer) === 0) return "";
if (!o.dauer_fest) return ' <small class="d-auto" aria-label="berechnet">⚙</small>';
return Math.ceil(o.dauer_besetzung) !== Math.ceil(o.dauer) ? ` <small class="d-abw">(${zahlText(o.dauer_besetzung)})</small>` : "";
};
const dauerTitel = (o: Zeile) => o.dauer_besetzung == null ? "Dauer in Arbeitstagen, 0 = Meilenstein"
: !o.dauer_fest ? `Aus ${zahlText(Number(o.stunden))} Std. und der Besetzung berechnet: ${zahlText(o.dauer_besetzung)} Arbeitstage. Eine eigene Zahl legt die Dauer fest.`
: `Dauer fest. Nach ${zahlText(Number(o.stunden))} Std. und der Besetzung wären es ${zahlText(o.dauer_besetzung)} Arbeitstage.`;
// T16: Tage mit weniger Leuten als eingeteilt heller
const reduziertHtml = (o: Zeile, links0: number) => (o.reduziert ?? []).map((d: Datum) =>
`<i class="reduziert" style="left:${x(d) - links0}px;width:${W}px" title="${formatDatum(d)}: nicht alle Eingeteilten verfügbar"></i>`).join("");
// Freitage, an denen dieser Vorgang ausgeführt wird, als Arbeitstag im Balken; die übrigen Freitage im Balken sind Reserve
const freitagHtml = (o: Zeile, links0: number) => (o.freitage ?? []).filter((d: Datum) => d >= o.anfang && d <= o.ende).map((d: Datum) =>
`<i class="freitag-an" style="left:${x(d) - links0}px;width:${W}px" title="Freitag ${formatDatum(d)}: für diesen Vorgang freigegeben"></i>`).join("");
// Zeilen aufbauen
type Reihe = { art: "p" | "a" | "v" | "g" | "t" | "z" | "k"; 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) && passt(v));
if (filter && !vs.length) return;
if (!sichtbarZeile(p.id)) return;
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);
if (filter && !av.length) continue;
if (!sichtbarZeile(a.id)) continue;
reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) });
if (zu.has(a.id)) continue;
for (const v of av) if (sichtbarZeile(v.id)) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende });
}
// unter dem Bauablauf: Aufgaben und Zahlungen (Einnahmen, Ausgaben); mit Personenfilter nicht
if (filter) return;
const pp = postenVon(p.id);
const spanneDaten = (l: (Datum | undefined)[]) => { const d = l.filter(Boolean).sort() as Datum[]; return d.length ? { von: d[0], bis: d.at(-1) } : {}; };
const gruppe = (g: string, art: "t" | "z" | "k", l: Zeile[]) => {
if (!sichtbarZeile(`${g}:${p.id}`)) return;
reihen.push({ art: "g", obj: { id: `${g}:${p.id}`, gruppe: g, name: GRUPPE_NAME[g], posten: l }, projekt: p, farbe: f, ...spanneDaten(l.map((x) => postenDatum(art, x))) });
if (zu.has(`${g}:${p.id}`)) return;
for (const x of l) if (sichtbarZeile(x.id)) reihen.push({ art, obj: x, projekt: p, farbe: f, von: postenDatum(art, x), bis: postenDatum(art, x) });
};
gruppe("aufg", "t", pp.aufgaben);
// Raten und Ausgaben stehen als €-Zeichen in der Projektzeile (Henning, 20.10.2026 und 21.10.2026), keine eigenen Zeilen
});
const zeileVon = new Map<string, number>();
reihen.forEach((r, i) => zeileVon.set(r.obj.id, i));
// Zeitskala in zwei Zeilen wie MS Project: oben Monate, unten der Montag jeder Woche;
// nah herangezoomt oben Wochen und unten Tage, weit herausgezoomt oben Jahre und unten Monate
const stufe = W >= 18 ? "tag" : W >= 3.5 ? "woche" : "monat";
let oben = "", unten = "", schatten = "";
const abschnitt = (n: number, text: string, titel = "") => `<div style="width:${n * W}px"${titel ? ` title="${esc(titel)}"` : ""}>${text ? `<span>${text}</span>` : ""}</div>`;
for (let i = 0, oStart = 0, uStart = 0; i < tage; i++) {
const d = plusTage(von, i);
const n1 = plusTage(d, 1);
const letzter = i === tage - 1;
const neueWoche = wochentag(n1) === 1, neuerMonat = n1.slice(0, 7) !== d.slice(0, 7), neuesJahr = n1.slice(0, 4) !== d.slice(0, 4);
const monatKurz = `${MONATE[Number(d.slice(5, 7)) - 1]} '${d.slice(2, 4)}`;
if (stufe === "tag" ? neueWoche || letzter : stufe === "woche" ? neuerMonat || letzter : neuesJahr || letzter) {
const n = i - oStart + 1, s = plusTage(von, oStart);
const text = stufe === "tag" ? (n * W > 130 ? `KW ${kalenderwoche(s)} · ${Number(s.slice(8))}. ${MONATE[Number(s.slice(5, 7)) - 1]} '${s.slice(2, 4)}` : n * W > 40 ? `KW ${kalenderwoche(s)}` : "")
: stufe === "woche" ? (n * W > 44 ? monatKurz : "") : (n * W > 34 ? d.slice(0, 4) : "");
oben += abschnitt(n, text);
oStart = i + 1;
}
if (stufe === "tag") {
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" : "";
unten += `<div class="${klasse}" style="width:${W}px"${titel ? ` title="${esc(titel)}"` : ""}>${W >= 30 ? `${WOCHENTAGE[wochentag(d) % 7]!.slice(0, 2)} ${Number(d.slice(8))}` : Number(d.slice(8))}</div>`;
} else if (stufe === "woche" ? neueWoche || letzter : neuerMonat || letzter) {
const n = i - uStart + 1, s = plusTage(von, uStart);
unten += stufe === "woche"
? abschnitt(n, n * W > 16 ? s.slice(8) : "", `KW ${kalenderwoche(s)}, ab ${formatDatum(s)}`)
: abschnitt(n, n * W > 24 ? MONATE[Number(d.slice(5, 7)) - 1]! : n * W > 9 ? MONATE[Number(d.slice(5, 7)) - 1]![0]! : "", `${MONATE[Number(d.slice(5, 7)) - 1]} ${d.slice(0, 4)}`);
uStart = i + 1;
}
// Wochenenden, Freitage und Feiertage schattieren; weit herausgezoomt nur Feiertage, sonst wird es unruhig
const ft = feiertag(d);
const klasse = ft ? "feiertag" : wochentag(d) === 5 ? "reserve" : !istArbeitstag(d, woche) ? "frei" : "";
if (klasse && (W >= 12 || ft)) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
// gepunktete Linie an jedem Monatsanfang
if (neuerMonat && !letzter) schatten += `<i class="monat" style="left:${(i + 1) * W}px"></i>`;
}
if (heute >= von && heute <= bis) schatten += `<i class="heute" style="left:${x(heute) + W / 2}px"></i>`;
// Beschriftung am Balken wie MS Project: Name darüber, Anfang links, Ende rechts
const beschriftung = (links: number, rechts: number, name: string, a: Datum | undefined, e: Datum | undefined, nachEnde = "") =>
`<span class="b-name" style="left:${(links + rechts) / 2}px">${name}</span>`
+ (a ? `<span class="b-von" style="left:${links - 4}px">${balkenDatum(a)}</span>` : "")
+ (e ? `<span class="b-bis" style="left:${rechts + 4}px">${balkenDatum(e)}${nachEnde}</span>` : "");
const fv = (v: Zeile) => ({ anfang: v.anfang as Datum, ende: v.ende as Datum, dauer: Number(v.dauer), stunden: v.stunden == null ? null : Number(v.stunden), fortschritt: Number(v.fortschritt) || 0, freitage: v.freitage as Datum[] | undefined });
// Stand von Projekt und Abschnitt: nach Stunden gewichtet (ohne Stunden nach Dauer)
const vorgaengeVon = (r: Reihe) => (r.art === "p" ? plan.vorgaenge.filter((v) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === r.obj.id))
: plan.vorgaenge.filter((v) => v.abschnitt_id === r.obj.id)).map(fv);
const standZelle = (r: Reihe) => {
const vs = vorgaengeVon(r);
const g = gesamtFortschritt(vs);
if (g === null) return "<span></span>";
const verzug = LAUFEND.has(r.projekt.status) && vs.some((v) => imVerzug(v, heute, woche));
return `<span class="zahl erl summe${g >= 100 ? " fertig" : verzug ? " verzug" : ""}" data-erl-summe="${r.art}:${r.obj.id}" title="${g} % erledigt, nach Stunden gewichtet${verzug ? " · mindestens ein Vorgang im Verzug" : ""} · klicken: alles bis heute als erledigt markieren">${g >= 100 ? "✓ " : ""}${g} %</span>`;
};
// Tabelle links und Balken je Zeile
const zeilenHtml = reihen.map((r, i) => {
const o = r.obj;
let links = "", balken = "";
const nr = ["p", "a", "v", "z"].includes(r.art) ? `<span class="nr" data-zieh="${r.art}:${o.id}" title="Anfassen und ziehen, um die Zeile zu verschieben">${zeilenNr.get(o.id)}</span>`
: `<span class="nr">${zeilenNr.get(o.id)}</span>`;
// freigegebene Freitage der Vorgänge zählen in der Summe mit
const dauerZelle = () => `<span class="zahl">${r.von ? dauerText(arbeitstageZwischen(r.von, r.bis!, wocheVon({ freitage: vorgaengeVon(r).flatMap((v) => v.freitage ?? []) }, woche))) : ""}</span>`;
const datumZelle = (d?: Datum) => `<span class="zahl">${d ? tabellenDatum(d) : ""}</span>`;
const klapp = `<button class="klapp" data-klapp="${o.id}" aria-label="${zu.has(o.id) ? "Aufklappen" : "Zuklappen"}">${zu.has(o.id) ? "▷" : "◢"}</button>`;
const sammel = () => (r.von ? `<div class="balken sammel" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px"></div>` : "");
if (r.art === "p") {
const raten = (plan.zahlungen ?? []).filter((z) => z.projekt_id === o.id);
const ausgaben = postenVon(o.id).kosten;
const ausText = ausgaben.length ? ` <button class="verweis g-raten aus" data-raten="${o.id}" title="Eingangsrechnungen im Zahlungsplan öffnen">${ausgaben.length} ${ausgaben.length === 1 ? "Ausgabe" : "Ausgaben"}</button>` : "";
links = `${nr}<span class="name ebene0" style="box-shadow:inset 4px 0 0 ${r.farbe}">${klapp}<span class="text" title="${esc(o.bezeichnung)}">${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button></span></span>
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}${standZelle(r)}
<span>${raten.length ? `<button class="verweis g-raten" data-raten="${o.id}" title="Zahlungsplan öffnen">€ ${raten.length} ${raten.length === 1 ? "Rate" : "Raten"}</button>`
: Number(o.umsatz_netto) > 0 && o.zahlungsplan === "fest"
? `<button class="verweis g-raten" data-zahlungsplan="${o.id}" title="Standard-Zahlungsplan 30/40/20/10 als Meilensteine anlegen">€ Plan anlegen</button>`
: Number(o.umsatz_netto) > 0 ? "" : `<button class="verweis g-raten leise" data-raten="${o.id}" title="Mit dem Auftragswert entsteht der Zahlungsplan automatisch als €-Meilensteine">€ Auftragswert fehlt</button>`}${ausText}</span>`;
if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, `${esc(o.nummer)} ${esc(o.bezeichnung)}`, r.von, r.bis);
// Abschlagsrechnungen als Meilensteine (P9): geplant hohl, gestellt halb, bezahlt voll
balken += raten.map((z) => `<div class="zahlung-ms ${esc(z.status ?? "geplant")}" data-ms="z:${z.id}" style="left:${x(z.termin) + W / 2 - 9}px;--farbe:${r.farbe}" title="${esc(z.bezeichnung)} · ${formatEuro(Number(z.netto))} netto · fällig ${formatDatum(z.termin)} · ${esc(z.status ?? "geplant")}${z.status === "geplant" ? " · ziehen zum Verschieben, klicken öffnet den Zahlungsplan" : ""}">€</div>`).join("");
// Ausgaben (Eingangsrechnungen) ebenso, in Rot: geplant hohl, bestellt halb, bezahlt voll
balken += ausgaben.filter((k) => k.termin).map((k) => `<div class="zahlung-ms aus ${k.status === "bestellt" ? "gestellt" : esc(k.status ?? "geplant")}" data-ms="k:${k.id}" style="left:${x(k.termin) + W / 2 - 9}px" title="Ausgabe: ${esc(k.bezeichnung)} · −${formatEuro(Number(k.netto))} netto · ${formatDatum(k.termin)} · ${esc(k.status ?? "geplant")}${k.status === "bezahlt" ? "" : " · ziehen zum Verschieben, klicken öffnet den Zahlungsplan"}">€</div>`).join("");
} else if (r.art === "a") {
links = `${nr}<span class="name ebene1">${klapp}<span class="text zelle" data-id="${o.id}" data-feld="abschnitt" title="Klicken zum Umbenennen">${esc(o.name)}</span>
<span class="aktionen"><button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="abschnitte/${o.id}" title="Abschnitt mit allen Vorgängen löschen">✕</button></span></span>
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}${standZelle(r)}<span></span>`;
if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, esc(o.name), r.von, r.bis);
} else if (r.art === "g") {
// Abschnitte „Aufgaben“ und „Ausgaben“
const g = o.gruppe as string, l = o.posten as Zeile[];
const ein = l.filter((x) => (plan.zahlungen ?? []).includes(x)).reduce((n, x) => n + Number(x.netto), 0);
const aus = l.filter((x) => (plan.kosten ?? []).includes(x)).reduce((n, x) => n + Number(x.netto), 0);
const neu = g === "aufg" ? "t" : g === "ein" ? "z" : g === "aus" ? "k" : "";
const titelNeu = g === "aufg" ? "Aufgabe hinzufügen" : g === "ein" ? "Einnahme (Rate) hinzufügen" : "Ausgabe hinzufügen";
const res = g === "aufg" ? `${l.filter((t) => !t.erledigt_am).length} offen`
: g === "zahl" ? `<span class="betrag ein">+${formatEuro(ein)}</span> <span class="betrag aus">−${formatEuro(aus)}</span>`
: !l.length ? "" : g === "ein" ? `<span class="betrag ein">+${formatEuro(ein)}</span>` : `<span class="betrag aus">−${formatEuro(aus)}</span>`;
links = `${nr}<span class="name ebene1">${klapp}<span class="text">${esc(o.name)}</span>
<span class="aktionen">${neu ? `<button class="plus" data-neu-posten="${neu}:${r.projekt.id}" title="${titelNeu}">+</button>` : ""}<button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button></span></span>
<span></span><span></span>${datumZelle(r.von)}${datumZelle(r.bis)}<span></span><span class="res-betrag">${res}</span>`;
} else if (r.art === "t" || r.art === "z" || r.art === "k") {
const art = r.art;
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" data-spalte="${SPALTE_VON[feld]}" data-art="${art}" title="${titel}">${inhaltHtml}</span>`;
const d = postenDatum(art, o);
const fertig = art === "t" ? !!o.erledigt_am : art === "z" ? o.status !== "geplant" : o.status === "bezahlt";
const vgTitel = "Hängt an Zeile: z. B. 4 (am Ende), 4EE+3 (3 Arbeitstage nach dem Ende), 4AA-5 (5 Arbeitstage vor dem Anfang). Leer: fester Termin";
const weg = `<button class="weg" data-weg="${POSTEN[art].pfad}/${o.id}" title="Löschen">✕</button>`;
const auge = `<button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button>`;
const betrag = art === "t" ? "" : `${art === "z" ? "+" : "−"}${formatEuro(Number(o.netto))}`;
if (art === "t") {
links = `${nr}<span class="name ebene2"><input type="checkbox" class="t-haken" data-erledigt="${o.id}"${fertig ? " checked" : ""} aria-label="Erledigt">${zelle("t-text", `text${fertig ? " erledigt" : ""}`, esc(o.text), "Aufgabe")}
<span class="aktionen">${auge}${weg}</span></span>
<span></span>${zelle("t-vg", "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle("t-datum", "zahl", d ? tabellenDatum(d) : '<span class="leer">Datum</span>', "Fällig am")}<span></span><span></span>
<span class="leise-text" title="Kategorie">${esc(o.kategorie ?? "")}</span>`;
} else {
const statusText = art === "z" ? ({ geplant: "geplant", gestellt: "Rechnung gestellt", bezahlt: "bezahlt" } as Record<string, string>)[o.status] ?? o.status
: ({ geplant: "geplant", bestellt: "bestellt", bezahlt: "bezahlt" } as Record<string, string>)[o.status] ?? o.status;
links = `${nr}<span class="name ebene2">${zelle(`${art}-name`, "text", `${esc(o.bezeichnung)} <small>${esc(statusText)}${o.rest ? " · Rest" : ""}</small>`, "Bezeichnung")}
<span class="aktionen">${auge}${weg}</span></span>
<span></span>${zelle(`${art}-vg`, "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle(`${art}-datum`, "zahl", d ? tabellenDatum(d) : "", art === "z" ? "Fällig am" : "Termin")}<span></span><span></span>
${zelle(`${art}-betrag`, `betrag ${art === "z" ? "ein" : "aus"}`, betrag, art === "z" && o.art === "schluss" ? "Betrag netto; leer lassen = Rest aus Auftragswert und den anderen Raten" : "Betrag netto")}`;
}
if (d) {
const cx = x(d) + W / 2;
const spaet = art === "t" && !fertig && d < heute;
const klasse = `posten-ms ${art}${fertig ? " fertig" : ""}${spaet ? " spaet" : ""}${art === "z" ? ` ${esc(o.status ?? "geplant")}` : ""}`;
const fest = fertig && art !== "t";
const name = art === "t" ? o.text : o.bezeichnung;
balken = `<div class="${klasse}" data-ms="${art}:${o.id}" style="left:${cx - 8}px" title="${esc(name)} · ${formatDatum(d)}${betrag ? ` · ${betrag} netto` : ""}${fest ? " · steht fest" : " · ziehen verschiebt"}">${art === "t" && fertig ? "✓" : ""}</div>`
+ beschriftung(cx, cx + 8, esc(name), undefined, d, betrag ? ` <span class="b-betrag ${art === "z" ? "ein" : "aus"}">${betrag}</span>` : "");
}
} else {
const ms = Number(o.dauer) === 0;
// Abarbeitungsgrad: Balken füllt sich, fertig grün mit Haken, im Verzug rot
const ist = Number(o.fortschritt) || 0;
const verzug = LAUFEND.has(r.projekt.status) && imVerzug(fv(o), heute, woche);
const soll = sollFortschritt(fv(o), heute, woche);
const standTitel = `${ist} % erledigt${verzug ? ` · im Verzug: nach dem Kalender etwa ${soll} %` : ""} · klicken zum Ändern (0, 25, 50, 75, 100 %)`;
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" data-spalte="${SPALTE_VON[feld]}" title="${titel}">${inhaltHtml}</span>`;
links = `${nr}<span class="name ebene2">${zelle("name", "text", esc(o.name), "Bezeichnung")}
<span class="aktionen"><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)) + dauerHinweis(o), dauerTitel(o))}
${zelle("vg", "vg", esc(vorgaengerText(linksVon(o.id), zeilenNr)), "Vorgänger: Zeilennummer, z. B. 5 oder 5AA+2")}
${zelle("start", "zahl", tabellenDatum(o.anfang), "Anfang")}${zelle("ende", "zahl", tabellenDatum(o.ende), "Ende")}
<span class="zahl erl${verzug ? " verzug" : ist >= 100 ? " fertig" : ""}" data-erl="${o.id}" title="${esc(standTitel)}">${ist >= 100 ? "✓ " : ""}${ist} %</span>
<span class="leute" data-besetzung="${o.id}" title="Besetzung bearbeiten">${leuteHtml(o.id) || '<span class="leer">+ Personal</span>'}</span>`;
const links0 = x(o.anfang), breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
const leute = leuteHtml(o.id) ? ` <span class="b-leute">${leuteHtml(o.id)}</span>` : "";
balken = ms
? `<div class="balken meilenstein${ist >= 100 ? " fertig" : verzug ? " verzug" : ""}" data-bar="${o.id}" style="left:${links0 + W / 2 - 6}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} · ${esc(standTitel)}"></div>`
+ beschriftung(links0 + W / 2, links0 + W / 2 + 6, esc(o.name), undefined, o.anfang, leute)
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}${ist >= 100 ? " fertig" : verzug ? " verzug" : ""}" data-bar="${o.id}" style="left:${links0}px;width:${breite}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${dauerText(Math.ceil(o.dauer))}${(o.freitage ?? []).length ? ` · ${o.freitage.length === 1 ? "1 Freitag" : `${o.freitage.length} Freitage`} freigegeben` : ""} · ${esc(standTitel)} · Rechtsklick: % erledigt und Freitage">${ist > 0 && ist < 100 ? `<i class="erledigt" style="width:${ist}%"></i>` : ""}${reduziertHtml(o, links0)}${freitagHtml(o, links0)}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`
+ beschriftung(links0, links0 + breite, `${ist >= 100 ? "✓ " : ""}${esc(o.name)}${verzug ? ' <b class="b-verzug">im Verzug</b>' : ""}`, o.anfang, o.ende, leute);
}
return `<div class="g-zeile ${r.art}${ausgeblendet.has(o.id) ? " ausgeblendet" : ""}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
}).join("");
// T16: Auslastung des eigenen Teams je Woche unter dem Plan; mit Personenfilter nur diese Person
const team = plan.team ?? [];
const nameVon = new Map(plan.leute.map((k) => [k.id, k.name]));
const gezeigtePersonen = [...personen.keys()].filter((p) => !personAus.includes(p));
const nurPerson = filter && gezeigtePersonen.length === 1 && team.includes(gezeigtePersonen[0]!) ? gezeigtePersonen[0]! : "";
const auslastungHtml = team.length && reihen.length ? (() => {
const std = (n: number) => zahlText(Math.round(n * 10) / 10);
const bloecke = (plan.auslastung ?? []).filter((w) => w.ab >= von && w.ab <= bis).map((w) => {
const z = nurPerson ? w.personen.find((p) => p.kontakt_id === nurPerson)! : w;
const klasse = z.geplant > z.verfuegbar + 0.01 ? "ueber" : z.verfuegbar - z.geplant >= 8 ? "leer" : "voll";
const breite = woche.tage.length * W;
const titel = `KW ${kalenderwoche(w.ab)}: ${std(z.geplant)} von ${std(z.verfuegbar)} Std. eingeplant`
+ (nurPerson ? "" : w.personen.map((p) => `\n${nameVon.get(p.kontakt_id) ?? ""}: ${std(p.geplant)} von ${std(p.verfuegbar)}${p.geplant > p.verfuegbar + 0.01 ? " (überplant)" : ""}`).join(""));
return `<div class="last ${klasse}" style="left:${x(w.ab)}px;width:${breite}px" title="${esc(titel)}">${breite >= 58 ? `${std(z.geplant)}/${std(z.verfuegbar)}` : ""}</div>`;
}).join("");
return `<div class="g-zeile auslastung" style="top:${reihen.length * ZEILE}px"><div class="g-links"><span class="nr"></span><span class="name ebene0" title="Stunden je Woche: eingeplant / verfügbar. Rot = überplant, grau = Leerlauf">Auslastung ${nurPerson ? esc(nameVon.get(nurPerson)) : "Team"} <small>Std./Woche</small></span></div></div>
<div class="g-balken" style="top:${reihen.length * ZEILE}px">${bloecke}</div>`;
})() : "";
// 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 + BALKEN_MITTE, y2 = yb * ZEILE + BALKEN_MITTE;
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("") + reihen.filter((r) => (r.art === "t" || r.art === "z" || r.art === "k") && r.obj.vorgang_id && r.von).map((r) => {
// Zahlungen, Kosten und Aufgaben: gestrichelt vom Anfang (AA) oder Ende (EE) des Vorgangs zur Raute
const a = plan.vorgaenge.find((v) => v.id === r.obj.vorgang_id);
const ya = zeileVon.get(r.obj.vorgang_id), yb = zeileVon.get(r.obj.id);
if (!a || ya === undefined || yb === undefined) return "";
const x1 = r.obj.bezug_art === "AA" ? x(a.anfang) : x(a.ende) + W, x2 = x(r.von!) + W / 2;
const y1 = ya * ZEILE + BALKEN_MITTE + 7, y2 = yb * ZEILE + BALKEN_MITTE;
// in Höhe der Raute von der Seite, damit die Linie die Beschriftung nicht kreuzt
const rand = x1 > x2 ? x2 + 9 : x2 - 9;
return `<path class="bezug" d="M${x1} ${y1}V${y2}H${rand}"/>`;
}).join("");
// Spaltenbreiten und Breite der Tabelle links (Trennleiste), beides gemerkt
const breiten: Record<Spalte, number> = { ...(window.innerWidth < 1400 ? BREITE_KLEIN : BREITE_GROSS), ...merke<Partial<Record<Spalte, number>>>("gantt-spalten") };
const summeBreiten = () => SPALTEN.reduce((s, k) => s + breiten[k], 0);
const hoehe = (reihen.length + (auslastungHtml ? 1 : 0)) * ZEILE;
const rahmen = document.createElement("div");
rahmen.className = "g-rahmen";
for (const k of SPALTEN) rahmen.style.setProperty(`--sp-${k}`, `${breiten[k]}px`);
rahmen.innerHTML = `<div class="gantt"><div class="g-inhalt" style="width:calc(var(--links) + ${tage * W}px)">
<div class="g-kopf"><div class="g-links kopf">${([["nr", "", "nr"], ["name", "Vorgangsname", "name"], ["dauer", "Dauer", "zahl"], ["vg", "Vorgänger", ""], ["anfang", "Anfang", "zahl"], ["ende", "Ende", "zahl"], ["erl", "% erl.", "zahl"], ["res", "Ressourcen / Betrag", ""]] as const)
.map(([k, titel, klasse]) => `<span class="${klasse}" title="${titel}">${titel}<i class="sp-griff" data-spalte="${k}" title="Ziehen ändert die Spaltenbreite"></i></span>`).join("")}</div>
<div class="g-zeit"><div class="reihe">${oben}</div><div class="reihe unten s-${stufe}">${unten}</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}${auslastungHtml}
</div></div>
${reihen.length ? "" : `<p class="hinweis" style="padding:16px">${filter || projektAus.length || anzahlAus ? "Nichts passt zu den Filtern. Oben unter Projekte und Personal lassen sie sich wieder entfernen." : "Noch keine Projekte im Terminplan."}</p>`}</div>
<div class="g-trenner" role="separator" aria-orientation="vertical" aria-label="Trennleiste zwischen Tabelle und Zeitplan" title="Ziehen: Spalten ein- oder ausblenden; Doppelklick: alle Spalten zeigen"></div>`;
const box = rahmen.querySelector<HTMLElement>(".gantt")!;
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(rahmen);
// Standard: alle Spalten zeigen, aber höchstens gut die Hälfte der Breite; am Handy nur Nr. und Name
const linksStandard = () => (rahmen.clientWidth < 700 ? breiten.nr + Math.min(breiten.name, 150) : Math.min(summeBreiten(), Math.round(rahmen.clientWidth * 0.6)));
rahmen.style.setProperty("--links", `${Math.round(Math.min(merke<number>("gantt-tabelle") ?? linksStandard(), rahmen.clientWidth - 80))}px`);
// Spaltenbreite am rechten Rand des Spaltenkopfs ziehen (wie MS Project); stand die Trennleiste am Tabellenende, geht sie mit
box.querySelector<HTMLElement>(".g-links.kopf")!.addEventListener("pointerdown", (ev) => {
const griff = (ev.target as HTMLElement).closest<HTMLElement>("[data-spalte]");
if (!griff || ev.button !== 0) return;
ev.preventDefault();
ev.stopPropagation();
const k = griff.dataset.spalte as Spalte;
griff.setPointerCapture(ev.pointerId);
const startX = ev.clientX, start = breiten[k];
const tabelle = box.querySelector<HTMLElement>(".g-kopf .g-links")!;
const mitgehen = tabelle.offsetWidth >= summeBreiten() - 2;
const zieh = (e: PointerEvent) => {
breiten[k] = Math.max(SPALTE_MIN, Math.round(start + e.clientX - startX));
rahmen.style.setProperty(`--sp-${k}`, `${breiten[k]}px`);
if (mitgehen) rahmen.style.setProperty("--links", `${Math.min(summeBreiten(), rahmen.clientWidth - 80)}px`);
};
const los = () => {
griff.removeEventListener("pointermove", zieh);
merke("gantt-spalten", breiten);
if (mitgehen) merke("gantt-tabelle", Math.min(summeBreiten(), rahmen.clientWidth - 80));
};
griff.addEventListener("pointermove", zieh);
griff.addEventListener("pointerup", los, { once: true });
griff.addEventListener("pointercancel", los, { once: true });
});
// Doppelklick auf die Trennleiste: alle Spalten zeigen
rahmen.querySelector<HTMLElement>(".g-trenner")!.addEventListener("dblclick", () => {
const b = Math.min(summeBreiten(), rahmen.clientWidth - 80);
rahmen.style.setProperty("--links", `${b}px`);
merke("gantt-tabelle", b);
});
// Trennleiste ziehen (wie MS Project): nach links verschwinden Dauer, Daten und Personal
rahmen.querySelector<HTMLElement>(".g-trenner")!.addEventListener("pointerdown", (ev) => {
if (ev.button !== 0) return;
ev.preventDefault();
const t = ev.currentTarget as HTMLElement;
if (ev.detail > 1) return;
t.setPointerCapture(ev.pointerId);
t.classList.add("zieht");
const startX = ev.clientX, start = box.querySelector<HTMLElement>(".g-kopf .g-links")!.offsetWidth;
const grenze = (b: number) => Math.round(Math.max(LINKS_MIN, Math.min(b, rahmen.clientWidth - 80)));
const zieh = (e: PointerEvent) => rahmen.style.setProperty("--links", `${grenze(start + e.clientX - startX)}px`);
const los = (e: PointerEvent) => {
t.removeEventListener("pointermove", zieh);
t.classList.remove("zieht");
merke("gantt-tabelle", grenze(start + e.clientX - startX));
};
t.addEventListener("pointermove", zieh);
t.addEventListener("pointerup", los, { once: true });
t.addEventListener("pointercancel", los, { once: true });
});
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 (zoomAnker) box.scrollLeft = Math.max(0, zoomAnker.tag * W - zoomAnker.px);
else if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute();
box.scrollTop = merke<number>("gantt-scroll-oben") ?? 0;
box.addEventListener("scroll", () => { merke("gantt-scroll", box.scrollLeft); merke("gantt-scroll-oben", box.scrollTop); }, { passive: true });
const neuLaden = () => terminplanSeite(h);
const meldung = leiste.querySelector<HTMLElement>(".g-meldung")!;
zuruecknehmen = async () => {
const letzte = verlauf.at(-1)?.aktion;
if (letzte === undefined) { meldung.textContent = "Nichts zum Zurücknehmen."; return; }
const schritte = verlauf.filter((x) => x.aktion === letzte).reverse();
verlauf.splice(verlauf.length - schritte.length);
try {
for (const x of schritte) await h.api(x.pfad, "PATCH", x.vorher);
meldung.textContent = "";
} catch (e) { meldung.textContent = `Zurücknehmen ging nicht: ${(e as Error).message}`; }
await neuLaden();
};
if (!tasteDa) {
tasteDa = true;
document.addEventListener("keydown", (ev) => {
if (!(ev.ctrlKey || ev.metaKey) || ev.key.toLowerCase() !== "z" || ev.shiftKey) return;
if (!document.querySelector(".gantt") || (ev.target as HTMLElement).closest("input, textarea, select")) return;
ev.preventDefault();
void zuruecknehmen?.();
});
}
if (weiter) {
const z = box.querySelector<HTMLElement>(`.zelle[data-id="${weiter.id}"][data-feld="${weiter.feld}"]`);
weiter = null;
if (z) { z.closest(".g-zeile")?.scrollIntoView({ block: "nearest" }); bearbeite(z); }
}
// Zoomen hält den Tag in der Mitte (oder unter dem Mauszeiger) fest und zeichnet nur neu
const zeitBreite = () => box.clientWidth - linksBreite();
const zoome = (neuW: number, px = zeitBreite() / 2) => {
neuW = zoomGrenzen(neuW);
zoomAnker = { tag: (box.scrollLeft + px) / W, px };
merke("gantt-w", neuW);
if (neuW !== W) void terminplanSeite(h, plan).finally(() => (zoomAnker = null));
else zoomAnker = null;
};
leiste.addEventListener("click", (ev) => {
const b = (ev.target as HTMLElement).closest("button");
if (b?.dataset.zoom) zoome(ZOOM[b.dataset.zoom]!);
if (b?.dataset.a === "heute") nachHeute();
if (b?.dataset.a === "zurueck") void zuruecknehmen?.();
if (b?.dataset.filter) {
const id = b.dataset.filter;
h.filterMenue(b, { titel: id === "person" ? "Personal" : "Projekte", werte: filterWerte[id]!, aus: ansicht.filter[id] ?? [],
fertig: (aus) => setzeAnsicht({ filter: { ...ansicht.filter, [id]: aus } }) });
}
if (b?.dataset.filterWeg) setzeAnsicht({ filter: { ...ansicht.filter, [b.dataset.filterWeg]: [] } });
if (b?.dataset.a === "aus-zeigen") { ausZeigen = !ausZeigen; void terminplanSeite(h, plan); }
if (b?.dataset.a === "alle-ein") { ausZeigen = false; setzeAnsicht({ aus: ansicht.aus.filter((id) => !alleIds.has(id)) }); }
});
// an der Zeitskala ziehen: nach rechts größer, nach links kleiner
box.querySelector<HTMLElement>(".g-zeit")!.addEventListener("pointerdown", (ev) => {
if (ev.button !== 0) return;
ev.preventDefault();
const rand = box.getBoundingClientRect().left + linksBreite();
const px = ev.clientX - rand, start = { x: ev.clientX, w: W, tag: (box.scrollLeft + px) / W };
let offen = 0, ziel = W;
const zieh = (e: PointerEvent) => {
ziel = zoomGrenzen(start.w * Math.exp((e.clientX - start.x) / 160));
if (offen) return;
offen = requestAnimationFrame(() => {
offen = 0;
zoomAnker = { tag: start.tag, px };
merke("gantt-w", ziel);
void terminplanSeite(h, plan);
});
};
const los = () => { document.removeEventListener("pointermove", zieh); document.removeEventListener("pointerup", los); setTimeout(() => (zoomAnker = null), 50); };
document.addEventListener("pointermove", zieh);
document.addEventListener("pointerup", los);
});
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;
const auge = t.closest<HTMLElement>("[data-ausblenden]");
if (auge) {
const id = auge.dataset.ausblenden!;
return setzeAnsicht({ aus: ausgeblendet.has(id) ? ansicht.aus.filter((x) => x !== id) : [...ansicht.aus, id] });
}
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 reihenfolge = Math.max(0, ...plan.abschnitte.filter((a) => a.projekt_id === t.dataset.neuAbschnitt).map((a) => a.reihenfolge)) + 1;
const a = await api<Zeile>("abschnitte", "POST", { projekt_id: t.dataset.neuAbschnitt, name: "Neuer Abschnitt", reihenfolge });
zu.delete(t.dataset.neuAbschnitt);
merke("gantt-zu", [...zu]);
weiter = { id: a.id, feld: "abschnitt" };
return neuLaden();
}
if (t.dataset.neuVorgang) return neuerVorgang(t.dataset.neuVorgang);
if (t.dataset.neuPosten) {
const [art, pid] = t.dataset.neuPosten.split(":") as ["t" | "z" | "k", string];
try { return await neuerPosten(art, pid); } catch (e) { meldung.textContent = (e as Error).message; return; }
}
if (t.dataset.raten) { location.hash = `projekt-${t.dataset.raten}-zahlungen`; return; }
if (t.dataset.zahlungsplan) {
try { await api(`projekte/${t.dataset.zahlungsplan}/zahlungsplan`, "POST"); } catch (e) { meldung.textContent = (e as Error).message; return; }
return neuLaden();
}
// Löschen mit zweitem Klick bestätigen
if (t.dataset.weg) {
if (!t.classList.contains("sicher")) {
box.querySelectorAll(".weg.sicher").forEach((x) => { x.classList.remove("sicher"); x.textContent = "✕"; });
t.classList.add("sicher");
t.textContent = "Löschen?";
return;
}
try { await api(t.dataset.weg, "DELETE"); } catch (e) { meldung.textContent = (e as Error).message; return; }
return neuLaden();
}
const erl = t.closest<HTMLElement>("[data-erl]");
if (erl) return standMenue(erl, erl.dataset.erl!);
const summe = t.closest<HTMLElement>("[data-erl-summe]");
if (summe) return summenMenue(summe);
const besetzungId = t.closest<HTMLElement>("[data-besetzung]")?.dataset.besetzung;
if (besetzungId) return besetzungDialog(plan.vorgaenge.find((v) => v.id === besetzungId)!);
const zelle = t.closest<HTMLElement>(".zelle");
if (zelle && !zelle.querySelector("input")) bearbeite(zelle);
});
// ---------- Bearbeiten in der Tabelle (wie MS Project) ----------
/** wohin nach Enter (nächste Zeile, gleiche Spalte) oder Tab (nächste Zelle der Zeile) */
function naechsteZelle(zelle: HTMLElement, richtung: "runter" | "rechts" | "links"): { id: string; feld: string } | null {
const ziel = (z: HTMLElement | undefined) => (z ? { id: z.dataset.id!, feld: z.dataset.feld! } : null);
const zeile = zelle.closest<HTMLElement>(".g-zeile")!;
if (richtung !== "runter") {
const zellen = [...zeile.querySelectorAll<HTMLElement>(".zelle[data-spalte]")];
return ziel(zellen[zellen.indexOf(zelle) + (richtung === "rechts" ? 1 : -1)]);
}
const zeilen = [...box.querySelectorAll<HTMLElement>(".g-zeile[data-zeile]")];
for (const z of zeilen.slice(zeilen.indexOf(zeile) + 1)) {
const n = z.querySelector<HTMLElement>(`.zelle[data-spalte="${zelle.dataset.spalte}"]`);
if (n) return ziel(n);
}
return null;
}
function rohwert(v: Zeile | undefined, feld: string, id: string): string {
if (feld === "abschnitt") return plan.abschnitte.find((a) => a.id === id)!.name;
const [art, teil] = feld.includes("-") ? feld.split("-") as [string, string] : ["", ""];
if (art) {
const o = postenListe(art).find((x) => x.id === id);
if (!o) return "";
if (teil === "text") return o.text;
if (teil === "name") return o.bezeichnung;
if (teil === "vg") return bezugText(o, zeilenNr);
if (teil === "datum") { const d = postenDatum(art, o); return d ? kurzDatum(d) : ""; }
if (teil === "betrag") return o.rest && o.status === "geplant" ? "" : formatEuro(Number(o.netto), false);
}
if (!v) return "";
if (feld === "name") return v.name;
if (feld === "start") return kurzDatum(v.anfang);
if (feld === "ende") return kurzDatum(v.ende);
if (feld === "dauer") return dauerText(Math.ceil(v.dauer));
return vorgaengerText(linksVon(v.id), zeilenNr);
}
function bearbeite(zelle: HTMLElement): void {
const id = zelle.dataset.id!, feld = zelle.dataset.feld!;
const v = plan.vorgaenge.find((x) => x.id === id);
const alt = rohwert(v, feld, id);
const vorher = zelle.innerHTML;
zelle.innerHTML = `<input class="g-eingabe" aria-label="${esc(zelle.title || feld)}" value="${esc(alt)}">`;
zelle.classList.add("bearbeitet");
const ein = zelle.querySelector("input")!;
ein.focus();
ein.select();
let fertig = false;
const zurueck = () => { fertig = true; zelle.innerHTML = vorher; zelle.classList.remove("bearbeitet"); };
const sichern = async (richtung: "runter" | "rechts" | "links" | null) => {
if (fertig) return;
fertig = true;
// wohin danach: Enter eine Zeile tiefer, Tab eine Spalte weiter
let ziel: { id: string; feld: string } | null = null;
if (richtung && feld !== "abschnitt") ziel = naechsteZelle(zelle, richtung);
const wert = ein.value.trim();
try {
if (wert === alt) {
zurueck();
if (ziel) { const z = box.querySelector<HTMLElement>(`.zelle[data-id="${ziel.id}"][data-feld="${ziel.feld}"]`); if (z) bearbeite(z); }
return;
}
await speichere(id, feld, wert, v);
meldung.textContent = "";
weiter = ziel;
neuLaden();
} catch (e) {
fertig = false;
meldung.textContent = (e as Error).message;
ein.focus();
}
};
ein.addEventListener("keydown", (ev) => {
if (ev.key === "Enter") { ev.preventDefault(); sichern("runter"); }
else if (ev.key === "Tab") { ev.preventDefault(); sichern(ev.shiftKey ? "links" : "rechts"); }
else if (ev.key === "Escape") { ev.preventDefault(); meldung.textContent = ""; zurueck(); }
});
ein.addEventListener("blur", () => { if (!fertig) sichern(null); });
}
async function speichere(id: string, feld: string, wert: string, v: Zeile | undefined): Promise<void> {
if (feld.includes("-")) return speicherePosten(id, feld, wert);
if (feld === "abschnitt" || feld === "name") {
if (!wert) throw new Error("Die Bezeichnung darf nicht leer sein.");
await api(feld === "abschnitt" ? `abschnitte/${id}` : `vorgaenge/${id}`, "PATCH", { name: wert });
} else if (feld === "start") {
await api(`vorgaenge/${id}`, "PATCH", { start: naechsterArbeitstag(leseDatum(wert, v!.anfang), wocheVon(v!, woche)) });
} else if (feld === "ende") {
const ende = leseDatum(wert, v!.ende);
if (ende < v!.anfang) throw new Error("Das Ende liegt vor dem Start.");
await api(`vorgaenge/${id}`, "PATCH", { dauer: Math.max(1, arbeitstageZwischen(v!.anfang, ende, wocheVon(v!, woche))) });
} else if (feld === "dauer") {
// „3“, „3 Tage“, „1 Tag“ oder „3t“
const dauer = Number(wert.replace(/\s*(tage?|at|t)\.?$/i, "").replace(",", "."));
if (!Number.isFinite(dauer) || dauer < 0) throw new Error("Die Dauer ist eine Zahl von Arbeitstagen, 0 für einen Meilenstein.");
await api(`vorgaenge/${id}`, "PATCH", { dauer: Math.round(dauer) });
} else {
await speichereVorgaenger(id, leseVorgaenger(wert, idVon));
}
}
// Aufgaben, Zahlungen und Ausgaben: Text, Bezug zum Vorgang, Datum, Betrag
async function speicherePosten(id: string, feld: string, wert: string): Promise<void> {
const [art, teil] = feld.split("-") as ["t" | "z" | "k", string];
const o = postenListe(art).find((x) => x.id === id)!;
const pfad = `${POSTEN[art].pfad}/${id}`;
if (teil === "text" || teil === "name") {
if (!wert) throw new Error("Die Bezeichnung darf nicht leer sein.");
await api(pfad, "PATCH", teil === "text" ? { text: wert } : { bezeichnung: wert });
} else if (teil === "vg") {
const b = leseBezug(wert, idVon);
// ohne Bezug bleibt der Termin, wo er gerade ist
await api(pfad, "PATCH", b.vorgang_id ? b : { vorgang_id: null });
} else if (teil === "datum") {
const d = postenDatum(art, o) ?? heute;
if (!wert && art === "t") { await api(pfad, "PATCH", { faellig_am: null, vorgang_id: null }); return; }
await api(pfad, "PATCH", { [POSTEN[art].datum]: leseDatum(wert, d) });
} else if (teil === "betrag") {
if (!wert && art === "z" && o.art === "schluss") { await api(pfad, "PATCH", { rest: true, netto: 0 }); return; }
if (!wert) throw new Error("Bitte einen Betrag eintragen, z. B. 12.500" + (art === "z" ? ". Nur bei der Schlussrechnung heißt leer: Rest aus Auftragswert und den anderen Raten." : "."));
const netto = parseEuro(wert.replace(/^[+−-]\s*/, "").replace(/\s*€$/, ""));
await api(pfad, "PATCH", art === "z" ? { netto, rest: false } : { netto });
}
}
// Neue Aufgabe, Einnahme oder Ausgabe im Projekt; danach gleich die Bezeichnung tippen
async function neuerPosten(art: "t" | "z" | "k", pid: string): Promise<void> {
const termin = naechsterArbeitstag(heute, woche);
const neu = art === "t" ? await api<Zeile>("aufgaben", "POST", { text: "Neue Aufgabe", projekt_id: pid, faellig_am: termin })
: art === "z" ? await api<Zeile>("zahlungen", "POST", { projekt_id: pid, art: "abschlag", bezeichnung: "Neue Rate", netto: 0, termin, status: "geplant", reihenfolge: postenVon(pid).raten.length })
: await api<Zeile>("kosten", "POST", { projekt_id: pid, art: "material", bezeichnung: "Neue Ausgabe", netto: 0, termin, status: "geplant" });
for (const g of [`zahl:${pid}`, art === "t" ? `aufg:${pid}` : art === "z" ? `ein:${pid}` : `aus:${pid}`, pid]) zu.delete(g);
merke("gantt-zu", [...zu]);
weiter = { id: neu.id, feld: art === "t" ? "t-text" : `${art}-name` };
neuLaden();
}
// Verknüpfungen abgleichen: entfernte löschen, geänderte anpassen, neue anlegen
async function speichereVorgaenger(id: string, neu: { vorgaenger_id: string; art: string; verzoegerung: number }[]): Promise<void> {
const alt = 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 });
}
}
// Neuer Vorgang hinter dem letzten des Abschnitts, mit ihm verknüpft; danach gleich die Bezeichnung tippen
async function neuerVorgang(abschnittId: string): Promise<void> {
const geschwister = plan.vorgaenge.filter((x) => x.abschnitt_id === abschnittId);
const letzter = geschwister[geschwister.length - 1];
const start = letzter ? naechsterArbeitstag(plusTage(letzter.ende, 1), woche) : naechsterArbeitstag(heute, woche);
const v = await api<Zeile>("vorgaenge", "POST", { abschnitt_id: abschnittId, name: "Neuer Vorgang", start, dauer: 1, reihenfolge: geschwister.length + 1 });
if (letzter) await api("verknuepfungen", "POST", { vorgang_id: v.id, vorgaenger_id: letzter.id, art: "EA", verzoegerung: 0 });
zu.delete(abschnittId);
merke("gantt-zu", [...zu]);
weiter = { id: v.id, feld: "name" };
neuLaden();
}
// % erledigt: Schnellwahl 0/25/50/75/100 oder eigene Zahl; per Klick in die Spalte oder Rechtsklick auf den Balken
function standMenue(anker: HTMLElement, id: string, punkt?: { x: number; y: number }): void {
document.querySelector(".erl-menue")?.remove();
const v = plan.vorgaenge.find((x) => x.id === id);
if (!v) return;
const ist = Number(v.fortschritt) || 0;
const m = document.createElement("div");
m.className = "erl-menue";
m.setAttribute("role", "menu");
// Freitage im Zeitraum des Vorgangs (ohne Feiertage) und die schon freigegebenen
const frei: Datum[] = [...(v.freitage ?? [])];
if (Number(v.dauer) > 0) for (let d = v.anfang as Datum; d <= v.ende; d = plusTage(d, 1)) if (wochentag(d) === 5 && !feiertag(d) && !frei.includes(d)) frei.push(d);
frei.sort();
const freitage = Number(v.dauer) > 0 ? `<b>Freitag arbeiten</b>${frei.length
? `<div class="fr-wahl">${frei.map((d) => `<label class="schalter"><input type="checkbox" data-freitag="${d}"${(v.freitage ?? []).includes(d) ? " checked" : ""}> Fr ${formatDatum(d).slice(0, 6)}</label>`).join("")}</div>`
: ""}<small class="hinweis">${frei.length ? "Nur für diesen Vorgang, sonst bleibt der Freitag Reserve." : "Im Zeitraum dieses Vorgangs liegt kein Freitag."}</small>` : "";
m.innerHTML = `<b>${esc(v.name)}: erledigt</b><div>${[0, 25, 50, 75, 100].map((n) => `<button class="neben${n === ist ? " an" : ""}" data-wert="${n}">${n === 100 ? "✓ 100" : n} %</button>`).join("")}</div>
<label>Andere Zahl <input inputmode="numeric" value="${ist}" aria-label="Prozent erledigt"> %</label>${freitage}`;
document.body.appendChild(m);
const r = anker.getBoundingClientRect();
const x0 = punkt?.x ?? r.left, y0 = punkt?.y ?? r.bottom + 2;
m.style.left = `${Math.max(8, Math.min(x0, window.innerWidth - m.offsetWidth - 8))}px`;
m.style.top = `${Math.min(y0, window.innerHeight - m.offsetHeight - 8)}px`;
const zu = () => { m.remove(); document.removeEventListener("pointerdown", aussen, true); };
const aussen = (e: Event) => { if (!m.contains(e.target as Node)) zu(); };
setTimeout(() => document.addEventListener("pointerdown", aussen, true));
const setze = async (n: number) => {
zu();
if (!(n >= 0 && n <= 100)) { meldung.textContent = "Bitte eine Zahl von 0 bis 100 eingeben."; return; }
try { await api(`vorgaenge/${id}`, "PATCH", { fortschritt: Math.round(n) }); meldung.textContent = ""; } catch (e) { meldung.textContent = (e as Error).message; }
neuLaden();
};
m.addEventListener("click", (e) => { const w = (e.target as HTMLElement).closest<HTMLElement>("[data-wert]")?.dataset.wert; if (w) void setze(Number(w)); });
m.addEventListener("change", async (e) => {
const k = (e.target as HTMLElement).closest<HTMLInputElement>("[data-freitag]");
if (!k) return;
const neu = [...m.querySelectorAll<HTMLInputElement>("[data-freitag]:checked")].map((x) => x.dataset.freitag!).sort();
zu();
try { await api(`vorgaenge/${id}`, "PATCH", { freitage: neu }); meldung.textContent = ""; } catch (err) { meldung.textContent = (err as Error).message; }
neuLaden();
});
const ein = m.querySelector<HTMLInputElement>("input[inputmode]")!;
ein.addEventListener("keydown", (e) => {
if (e.key === "Enter") void setze(Number(ein.value.replace(",", ".").replace("%", "").trim()));
if (e.key === "Escape") zu();
});
m.querySelector<HTMLButtonElement>(".an")?.focus();
}
// Projekt oder Abschnitt: alles, was bis gestern geendet hat, auf 100 %
function summenMenue(anker: HTMLElement): void {
document.querySelector(".erl-menue")?.remove();
const [art, id] = anker.dataset.erlSumme!.split(":");
const vs = plan.vorgaenge.filter((v) => (art === "p" ? plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === id) : v.abschnitt_id === id));
const offen = vs.filter((v) => v.ende < heute && (Number(v.fortschritt) || 0) < 100);
const m = document.createElement("div");
m.className = "erl-menue";
m.innerHTML = offen.length
? `<b>${offen.length} ${offen.length === 1 ? "Vorgang ist" : "Vorgänge sind"} vor heute zu Ende, aber nicht auf 100 %</b><div><button class="haupt" data-alle>Alle als erledigt markieren</button><button class="neben" data-zu>Abbrechen</button></div>`
: '<b>Alles, was vor heute endet, ist erledigt.</b><div><button class="neben" data-zu>OK</button></div>';
document.body.appendChild(m);
const r = anker.getBoundingClientRect();
m.style.left = `${Math.max(8, Math.min(r.left, window.innerWidth - m.offsetWidth - 8))}px`;
m.style.top = `${Math.min(r.bottom + 2, window.innerHeight - m.offsetHeight - 8)}px`;
m.addEventListener("click", async (e) => {
const b = e.target as HTMLElement;
if (b.hasAttribute("data-zu")) m.remove();
if (!b.hasAttribute("data-alle")) return;
m.remove();
try { for (const v of offen) await api(`vorgaenge/${v.id}`, "PATCH", { fortschritt: 100 }); } catch (err) { meldung.textContent = (err as Error).message; }
neuLaden();
});
}
box.addEventListener("contextmenu", (ev) => {
const bar = (ev.target as HTMLElement).closest<HTMLElement>("[data-bar]");
if (!bar) return;
ev.preventDefault();
standMenue(bar, bar.dataset.bar!, { x: ev.clientX, y: ev.clientY });
});
// Besetzung bearbeiten: Liste mit Freigabe, darunter Person oder Platzhalter hinzufügen
function besetzungDialog(v: Zeile): void {
const leuteName = (id: string) => { const k = plan.leute.find((x) => x.id === id); return k ? (k.rolle === "subunternehmer" && k.firma ? k.firma : k.name) : "?"; };
const mitgliederText = (ids: string[]) => (ids.length ? ids.map(leuteName).join(", ") : "noch ohne Mitglieder");
const mitSub = (b: Zeile) => (b.mitglieder ?? []).some((id: string) => plan.leute.find((k) => k.id === id)?.rolle === "subunternehmer");
const huelle = document.getElementById("dialog-huelle")!;
const zeichne = () => {
const liste = besetzungVon(v.id);
const vv = plan.vorgaenge.find((x) => x.id === v.id) ?? v;
const zahl = (n: number) => String(n).replace(".", ",");
// T15: Stunden und Besetzung ergeben die Dauer
const ergebnis = vv.dauer_besetzung != null
? `Nach Stunden und Besetzung ${dauerText(vv.dauer_besetzung).replace(".", ",")}${vv.dauer_fest ? `, eingetragen ${dauerText(Number(vv.dauer)).replace(".", ",")}` : ""}.`
: Number(vv.stunden) > 0 ? "Sobald jemand eingeteilt ist, ergibt sich daraus die Dauer." : "Ohne Stunden bleibt die Dauer so, wie du sie einträgst.";
huelle.innerHTML = `<div class="dialog besetzung"><h2>Besetzung: ${esc(vv.name)}</h2>
<p class="hinweis">${formatDatum(vv.anfang)} – ${formatDatum(vv.ende)}</p>
<div class="b-dauer"><label for="b-stunden">Arbeitsstunden für diesen Vorgang</label><input id="b-stunden" inputmode="decimal" value="${vv.stunden != null ? zahl(Number(vv.stunden)) : ""}" placeholder="z. B. 32">
<label class="schalter"><input type="checkbox" id="b-auto"${vv.dauer_fest ? "" : " checked"}> Dauer aus Stunden und Besetzung berechnen</label>
<p class="hinweis">${ergebnis} Urlaub, Teilzeit und Feiertage zählen mit, der Freitag nicht.</p></div>
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}${b.kolonne_id ? ` <small class="hinweis">Kolonne: ${esc(mitgliederText(b.mitglieder ?? []))}</small>` : ""}</td>
<td class="zahl">${b.kolonne_id ? `${(b.mitglieder ?? []).length} P.` : `${String(b.personen).replace(".", ",")} P.`}</td>
<td>${b.rolle === "mitarbeiter" || (b.kolonne_id && !mitSub(b)) ? "" : `<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("")}
${(plan.kolonnen ?? []).filter((o) => o.aktiv).map((o) => `<option value="kolonne:${o.id}">${esc(o.name)} (Kolonne, ${o.mitglieder.length} ${o.mitglieder.length === 1 ? "Person" : "Personen"})</option>`).join("")}
<option value="platzhalter">Platzhalter, z. B. N.N. …</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, Platzhalter und Kolonnen mit Subunternehmern sind vorgemerkt, bis du sie freigibst. Kolonnen und Subunternehmer legst du unter Personal 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";
// Kolonne: zählt mit ihren Mitgliedern; Subunternehmer kommt mit seiner üblichen Kolonnengröße
const pers = huelle.querySelector<HTMLInputElement>("#b-personen")!;
pers.disabled = wahl.value.startsWith("kolonne:");
const k = plan.leute.find((x) => x.id === wahl.value);
pers.value = k?.kolonnengroesse ? String(Number(k.kolonnengroesse)).replace(".", ",") : "1";
};
};
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, ...(w === "platzhalter" ? { platzhalter, personen } : w.startsWith("kolonne:") ? { kolonne_id: w.slice(8) } : { kontakt_id: w, personen }) });
return neu();
}
} catch (e) {
huelle.querySelector("#b-fehler")!.textContent = (e as Error).message;
}
};
huelle.onchange = async (ev) => {
const t = ev.target as HTMLInputElement;
try {
if (t.dataset.frei) { await api(`besetzungen/${t.dataset.frei}`, "PATCH", { freigegeben: t.checked }); await neu(); }
if (t.id === "b-auto") { await api(`vorgaenge/${v.id}`, "PATCH", { dauer_fest: !t.checked }); await neu(); }
if (t.id === "b-stunden") {
const roh = t.value.trim().replace(",", ".");
const stunden = roh ? Number(roh) : null;
if (stunden !== null && !(stunden >= 0)) throw new Error("Die Stunden sind eine Zahl, z. B. 32.");
await api(`vorgaenge/${v.id}`, "PATCH", { stunden });
await neu();
}
} catch (e) {
huelle.querySelector("#b-fehler")!.textContent = (e as Error).message;
}
};
}
// 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) {
const z = box.querySelector<HTMLElement>(`.zelle[data-id="${v.id}"][data-feld="name"]`);
if (!bewegt && z) bearbeite(z);
return;
}
if (dauerAendern) {
const neuesEnde = plusTage(v.ende, n);
const dauer = Math.max(1, arbeitstageZwischen(v.anfang, neuesEnde < v.anfang ? v.anfang : neuesEnde, wocheVon(v, 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, wocheVon(v, woche)) : vorherigerArbeitstag(ziel, wocheVon(v, woche)) });
}
neuLaden();
};
bar.addEventListener("pointermove", zieh);
bar.addEventListener("pointerup", los, { once: true });
});
// Rauten von Aufgaben, Zahlungen und Ausgaben ziehen (Henning, 20.10.2026): neues Datum; hängt die Raute
// an einem Vorgang, ändert sich der Versatz und sie wandert weiter mit ihm. Gestellte oder bezahlte stehen fest.
box.addEventListener("pointerdown", (ev) => {
const ms = (ev.target as HTMLElement).closest<HTMLElement>("[data-ms]");
if (!ms || ev.button !== 0) return;
const [art, id] = ms.dataset.ms!.split(":") as ["t" | "z" | "k", string];
const o = postenListe(art).find((x) => x.id === id)!;
const fest = art === "z" ? o.status !== "geplant" : art === "k" ? o.status === "bezahlt" : false;
ev.preventDefault();
const startX = ev.clientX, links0 = ms.offsetLeft;
let bewegt = false;
ms.setPointerCapture(ev.pointerId);
const tage = (e: PointerEvent) => Math.round((e.clientX - startX) / W);
const zieh = (e: PointerEvent) => {
if (fest) return;
const n = tage(e);
if (n !== 0) { bewegt = true; ms.classList.add("zieht"); }
ms.style.left = `${links0 + n * W}px`;
};
const los = async (e: PointerEvent) => {
ms.removeEventListener("pointermove", zieh);
ms.classList.remove("zieht");
const n = tage(e);
if (!bewegt || n === 0) {
if (fest && Math.abs(e.clientX - startX) > 4) meldung.textContent = art === "z" ? "Diese Rate ist schon gestellt oder bezahlt; ihr Termin steht fest." : "Diese Ausgabe ist bezahlt; ihr Termin steht fest.";
const z = box.querySelector<HTMLElement>(`.zelle[data-id="${id}"][data-feld="${art}-datum"],.zelle[data-id="${id}"][data-feld="t-datum"]`);
if (!bewegt && !fest && z) bearbeite(z);
else if (!bewegt && (art === "z" || art === "k")) location.hash = `projekt-${o.projekt_id}-zahlungen`;
return;
}
const ziel = plusTage(postenDatum(art, o)!, n);
try {
await api(`${POSTEN[art].pfad}/${id}`, "PATCH", { [POSTEN[art].datum]: n > 0 ? naechsterArbeitstag(ziel, woche) : vorherigerArbeitstag(ziel, woche) });
meldung.textContent = "";
} catch (err) { meldung.textContent = (err as Error).message; }
neuLaden();
};
ms.addEventListener("pointermove", zieh);
ms.addEventListener("pointerup", los, { once: true });
});
// Aufgabe abhaken: gilt auch in der Aufgabenliste und der Übersicht
box.addEventListener("change", async (ev) => {
const t = ev.target as HTMLInputElement;
if (!t.dataset.erledigt) return;
try { await api(`aufgaben/${t.dataset.erledigt}`, "PATCH", { erledigt_am: t.checked ? new Date().toISOString() : null }); } catch (e) { meldung.textContent = (e as Error).message; t.checked = !t.checked; return; }
neuLaden();
});
// Zeilen am Griff ⋮⋮ verschieben (Henning, 20.10.2026): Projekte, Abschnitte (auch in ein anderes Projekt)
// und Vorgänge (auch in einen anderen Abschnitt). Mit Zeigerereignissen, damit es auch am Tablet geht.
const koerper = box.querySelector<HTMLElement>(".g-koerper")!;
const linie = document.createElement("div");
linie.className = "g-einfuege";
linie.hidden = true;
koerper.appendChild(linie);
const naechsteAb = (i: number, arten: string[]) => { let j = i + 1; while (j < reihen.length && !arten.includes(reihen[j]!.art)) j++; return j; };
type Ziel = { zeile: number; eltern: string; vor?: string; nach?: string };
function zielFuer(art: string, id: string, ev: PointerEvent): Ziel | null {
const y = ev.clientY - koerper.getBoundingClientRect().top;
const i = Math.max(0, Math.min(reihen.length - 1, Math.floor(y / ZEILE)));
const unten = y - i * ZEILE > ZEILE / 2 || y >= reihen.length * ZEILE;
const r = reihen[i]!;
// Raten nur innerhalb der Einnahmen ihres Projekts (Reihenfolge wie im Zahlungsplan)
if (art === "z") {
const eigen = reihen.find((x) => x.obj.id === id)!.projekt.id as string;
if (r.projekt.id !== eigen) return null;
if (r.art === "g" && r.obj.gruppe === "ein") return { zeile: i + 1, eltern: eigen, vor: postenVon(eigen).raten[0]?.id };
if (r.art !== "z" || r.obj.id === id) return null;
return unten ? { zeile: i + 1, eltern: eigen, nach: r.obj.id } : { zeile: i, eltern: eigen, vor: r.obj.id };
}
if (art !== "p" && !["p", "a", "v"].includes(r.art)) return null;
if (art === "p") {
const tp = r.projekt.id as string;
if (tp === id) return null;
const start = reihen.findIndex((x) => x.art === "p" && x.obj.id === tp);
return r.art === "p" && !unten ? { zeile: start, eltern: "", vor: tp } : { zeile: naechsteAb(start, ["p"]), eltern: "", nach: tp };
}
if (art === "a") {
if (r.art === "p") return { zeile: i + 1, eltern: r.obj.id, vor: plan.abschnitte.find((x) => x.projekt_id === r.obj.id)?.id };
const ab = r.art === "a" ? r.obj : plan.abschnitte.find((x) => x.id === r.obj.abschnitt_id)!;
if (ab.id === id) return null;
const start = reihen.findIndex((x) => x.art === "a" && x.obj.id === ab.id);
return r.art === "a" && !unten ? { zeile: start, eltern: ab.projekt_id, vor: ab.id } : { zeile: naechsteAb(start, ["a", "p"]), eltern: ab.projekt_id, nach: ab.id };
}
if (r.art === "p") return null;
if (r.art === "a") return { zeile: i + 1, eltern: r.obj.id, vor: plan.vorgaenge.find((x) => x.abschnitt_id === r.obj.id)?.id };
if (r.obj.id === id) return null;
return unten ? { zeile: i + 1, eltern: r.obj.abschnitt_id, nach: r.obj.id } : { zeile: i, eltern: r.obj.abschnitt_id, vor: r.obj.id };
}
async function verschiebe(art: string, id: string, z: Ziel) {
const [pfad, elternFeld, liste] = art === "p" ? ["projekte", "", plan.projekte]
: art === "z" ? ["zahlungen", "", plan.zahlungen.filter((x) => x.projekt_id === z.eltern)]
: art === "a" ? ["abschnitte", "projekt_id", plan.abschnitte.filter((x) => x.projekt_id === z.eltern)]
: ["vorgaenge", "abschnitt_id", plan.vorgaenge.filter((x) => x.abschnitt_id === z.eltern)];
const ids = (liste as Zeile[]).map((x) => x.id as string).filter((x) => x !== id);
const pos = z.vor ? ids.indexOf(z.vor) : z.nach ? ids.indexOf(z.nach) + 1 : 0;
ids.splice(pos < 0 ? ids.length : pos, 0, id);
const alle = art === "p" ? plan.projekte : art === "z" ? plan.zahlungen : art === "a" ? plan.abschnitte : plan.vorgaenge;
for (const [i, x] of ids.entries()) {
const alt = alle.find((y) => y.id === x)!;
const aenderung: Zeile = {};
if (alt.reihenfolge !== i) aenderung.reihenfolge = i;
if (x === id && elternFeld && alt[elternFeld] !== z.eltern) aenderung[elternFeld] = z.eltern;
if (Object.keys(aenderung).length) await api(`${pfad}/${x}`, "PATCH", aenderung);
}
}
box.addEventListener("pointerdown", (ev) => {
const griff = (ev.target as HTMLElement).closest<HTMLElement>("[data-zieh]");
if (!griff || ev.button !== 0) return;
ev.preventDefault();
const [art, id] = griff.dataset.zieh!.split(":") as [string, string];
const zeile = griff.closest<HTMLElement>(".g-zeile")!;
griff.setPointerCapture(ev.pointerId);
let ziel: Ziel | null = null, bewegt = false;
const startY = ev.clientY;
const zieh = (e: PointerEvent) => {
if (!bewegt && Math.abs(e.clientY - startY) < 4) return;
bewegt = true;
zeile.classList.add("gezogen");
ziel = zielFuer(art, id, e);
linie.hidden = !ziel;
if (ziel) linie.style.top = `${ziel.zeile * ZEILE - 1}px`;
// am Rand mitscrollen
const r = box.getBoundingClientRect();
if (e.clientY < r.top + 90) box.scrollTop -= 12; else if (e.clientY > r.bottom - 30) box.scrollTop += 12;
};
const los = async () => {
griff.removeEventListener("pointermove", zieh);
griff.removeEventListener("pointerup", los);
griff.removeEventListener("pointercancel", los);
zeile.classList.remove("gezogen");
linie.hidden = true;
// nur geklickt: Zeile markieren wie in MS Project
if (!bewegt) {
const war = zeile.classList.contains("gewaehlt");
box.querySelectorAll(".g-zeile.gewaehlt").forEach((z) => z.classList.remove("gewaehlt"));
zeile.classList.toggle("gewaehlt", !war);
return;
}
if (!ziel) return;
try { await verschiebe(art, id, ziel); } catch (e) { meldung.textContent = (e as Error).message; }
neuLaden();
};
griff.addEventListener("pointermove", zieh);
griff.addEventListener("pointerup", los);
griff.addEventListener("pointercancel", los);
});
}
function vorherigerArbeitstag(d: Datum, woche: Arbeitswoche): Datum {
let x = d;
while (!istArbeitstag(x, woche)) x = plusTage(x, -1);
return x;
}
export 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);
}