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

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

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

@@ -0,0 +1,149 @@
// Terminplanung mit Verknüpfungen (T3, T5): ein Vorgang darf mehrere Vorgänger haben.
// Regeln wie in V70 (reqOf/reschedAll): EA, AA, EE, AE mit Verzögerung in Arbeitstagen.
// Nachfolger werden nach hinten geschoben, wenn ein Vorgänger sich verlängert oder später
// liegt. Nach vorn rücken nur Nachfolger, die vorher direkt am Vorgänger hingen („eng“).
import { type Datum } from "./datum.js";
import { type Arbeitswoche, endeNachDauer, naechsterArbeitstag, verschiebeArbeitstage } from "./kalender.js";
export type Art = "EA" | "AA" | "EE" | "AE";
export interface PlanVorgang {
id: string;
start: Datum;
/** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */
dauer: number;
}
export interface Verknuepfung {
vorgang_id: string;
vorgaenger_id: string;
art: Art;
/** Arbeitstage, darf negativ sein */
verzoegerung: number;
}
const tage = (v: PlanVorgang) => Math.ceil(v.dauer);
export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum {
return naechsterArbeitstag(v.start, woche);
}
export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum {
return endeNachDauer(v.start, tage(v), woche);
}
/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */
function versatz(d: Datum, n: number, woche: Arbeitswoche): Datum {
return n === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, n, woche);
}
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet. */
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche): Datum {
const e = naechsterArbeitstag(endeAm, woche);
return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), woche);
}
/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
const lg = k.verzoegerung;
const meilenstein = tage(v) === 0;
switch (k.art) {
case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, woche);
case "AA": return versatz(anfang(vorgaenger, woche), lg, woche);
case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, woche), woche);
case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, woche), woche);
}
}
/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */
export function fruehesterStart(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined {
let s: Datum | undefined;
for (const k of links) {
if (k.vorgang_id !== v.id) continue;
const p = alle.get(k.vorgaenger_id);
if (!p) continue;
const x = startNachVerknuepfung(v, p, k, woche);
if (!s || x > s) s = x;
}
return s;
}
/** Vorgänge, die genau an ihrem frühesten Start liegen; sie rücken mit, wenn der Vorgänger früher fertig wird. */
export function engeVorgaenge(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche): Set<string> {
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
const eng = new Set<string>();
for (const v of vorgaenge) {
const f = fruehesterStart(v, alle, links, woche);
if (f && f === anfang(v, woche)) eng.add(v.id);
}
return eng;
}
/** true, wenn die neue Verknüpfung einen Kreis bilden würde (Vorgänger hängt schon am Vorgang). */
export function bildetKreis(neu: Pick<Verknuepfung, "vorgang_id" | "vorgaenger_id">, links: Verknuepfung[]): boolean {
if (neu.vorgang_id === neu.vorgaenger_id) return true;
const nachfolger = new Map<string, string[]>();
for (const k of links) nachfolger.set(k.vorgaenger_id, [...(nachfolger.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
const offen = [neu.vorgang_id];
const gesehen = new Set<string>();
while (offen.length) {
const x = offen.pop()!;
if (x === neu.vorgaenger_id) return true;
if (gesehen.has(x)) continue;
gesehen.add(x);
offen.push(...(nachfolger.get(x) ?? []));
}
return false;
}
/** Reihenfolge, in der Vorgänger vor ihren Nachfolgern kommen. Wirft bei einem Kreis. */
function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorgang[] {
const ids = new Set(vorgaenge.map((v) => v.id));
const rest = new Map(vorgaenge.map((v) => [v.id, 0]));
const nach = new Map<string, string[]>();
for (const k of links) {
if (!ids.has(k.vorgang_id) || !ids.has(k.vorgaenger_id)) continue;
rest.set(k.vorgang_id, rest.get(k.vorgang_id)! + 1);
nach.set(k.vorgaenger_id, [...(nach.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
}
const byId = new Map(vorgaenge.map((v) => [v.id, v]));
const bereit = vorgaenge.filter((v) => rest.get(v.id) === 0).map((v) => v.id);
const aus: PlanVorgang[] = [];
while (bereit.length) {
const id = bereit.shift()!;
aus.push(byId.get(id)!);
for (const n of nach.get(id) ?? []) {
rest.set(n, rest.get(n)! - 1);
if (rest.get(n) === 0) bereit.push(n);
}
}
if (aus.length !== vorgaenge.length) throw new Error("Die Verknüpfungen bilden einen Kreis.");
return aus;
}
export interface Ergebnis {
/** neuer Start je verschobenem Vorgang */
starts: Map<string, Datum>;
}
/**
* Plant alle Nachfolger neu. `eng` sind die Vorgänge, die vor der Änderung direkt am Vorgänger hingen
* (engeVorgaenge auf dem alten Stand); nur sie dürfen nach vorn rücken. `fest` werden nicht bewegt
* (der Vorgang, den der Benutzer gerade gezogen hat, wird vorher auf seinen frühesten Start begrenzt).
*/
export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set<string> = new Set()): Ergebnis {
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
const starts = new Map<string, Datum>();
for (const v of topologisch(vorgaenge, links)) {
const x = stand.get(v.id)!;
const f = fruehesterStart(x, stand, links, woche);
if (!f) continue;
const a = anfang(x, woche);
if (f > a || (f < a && eng.has(v.id))) {
x.start = f;
starts.set(v.id, f);
}
}
return { starts };
}

View File

@@ -4,7 +4,8 @@ import { fileURLToPath } from "node:url";
import path from "node:path"; import path from "node:path";
import { existsSync } from "node:fs"; import { existsSync } from "node:fs";
import { z, ZodError } from "zod"; import { z, ZodError } from "zod";
import { type Pool, transaktion } from "./db.js"; import { type Client, type Pool, transaktion } from "./db.js";
import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js";
import { TABELLEN } from "./tabellen.js"; import { TABELLEN } from "./tabellen.js";
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
import { liquiditaet } from "../domain/liquiditaet.js"; import { liquiditaet } from "../domain/liquiditaet.js";
@@ -52,6 +53,14 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
return { ok: true, version: VERSION }; return { ok: true, version: VERSION };
}); });
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
const PLAN = new Set(["vorgang", "vorgang_vorgaenger"]);
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = []): Promise<T> {
if (!PLAN.has(tabelle)) return fn();
const e = await ladeEinstellungen();
return (await mitNeuplanung(c, { tage: e.arbeitstage }, fn, bewegt)).ergebnis;
}
for (const t of TABELLEN) { for (const t of TABELLEN) {
const felder = Object.keys(t.schema.shape); const felder = Object.keys(t.schema.shape);
const teil = t.schema.partial(); const teil = t.schema.partial();
@@ -67,14 +76,16 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
app.post(`/api/${t.pfad}`, async (req, reply) => { app.post(`/api/${t.pfad}`, async (req, reply) => {
const daten = t.schema.parse(req.body) as Record<string, unknown>; const daten = t.schema.parse(req.body) as Record<string, unknown>;
const spalten = felder.filter((f) => daten[f] !== undefined); const spalten = felder.filter((f) => daten[f] !== undefined);
const row = await transaktion(pool, benutzer(req), async (c) => const row = await transaktion(pool, benutzer(req), async (c) => {
(await c.query( if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string });
spalten.length return geplant(c, t.name, async () =>
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *` (await c.query(
: `insert into ${t.name} default values returning *`, spalten.length
spalten.map((s) => daten[s]), ? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
)).rows[0], : `insert into ${t.name} default values returning *`,
); spalten.map((s) => daten[s]),
)).rows[0]);
});
return reply.status(201).send(row); return reply.status(201).send(row);
}); });
@@ -83,18 +94,24 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const daten = teil.parse(req.body) as Record<string, unknown>; const daten = teil.parse(req.body) as Record<string, unknown>;
const spalten = felder.filter((f) => daten[f] !== undefined); const spalten = felder.filter((f) => daten[f] !== undefined);
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
const row = await transaktion(pool, benutzer(req), async (c) => const row = await transaktion(pool, benutzer(req), async (c) => {
(await c.query( if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`, const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0];
[id, ...spalten.map((s) => daten[s])], if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id);
)).rows[0], }
); return geplant(c, t.name, async () =>
(await c.query(
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
[id, ...spalten.map((s) => daten[s])],
)).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : []);
});
return row ?? reply.status(404).send({ fehler: "Nicht gefunden" }); return row ?? reply.status(404).send({ fehler: "Nicht gefunden" });
}); });
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => { app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params); const { id } = IdParam.parse(req.params);
const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount); const n = await transaktion(pool, benutzer(req), async (c) =>
geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount));
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" }); return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
}); });
} }
@@ -144,6 +161,11 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust }); return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
}); });
app.get("/api/terminplan", async () => {
const e = await ladeEinstellungen();
return terminplan(pool, { tage: e.arbeitstage });
});
// Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm // Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm
app.post("/api/import/v70", async (req, reply) => { app.post("/api/import/v70", async (req, reply) => {
let u; let u;
@@ -152,7 +174,9 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
} catch (err) { } catch (err) {
return reply.status(400).send({ fehler: (err as Error).message }); return reply.status(400).send({ fehler: (err as Error).message });
} }
const anzahl = await transaktion(pool, benutzer(req), (c) => speichereUebernahme(c, u)); const e = await ladeEinstellungen();
// nach der Übernahme gelten die Verknüpfungen: Nachfolger rücken hinter ihre Vorgänger wie in V70
const anzahl = await transaktion(pool, benutzer(req), async (c) => (await mitNeuplanung(c, { tage: e.arbeitstage }, () => speichereUebernahme(c, u))).ergebnis);
return reply.status(201).send({ anzahl, hinweise: u.hinweise }); return reply.status(201).send({ anzahl, hinweise: u.hinweise });
}); });

View File

@@ -0,0 +1,8 @@
-- Nummer je Vorgang wie in V70 (dort "no"), damit Vorgänger per Nummer eingetragen werden können
create sequence vorgang_nummer_seq start 1001;
alter table vorgang add column nummer integer;
update vorgang set nummer = nextval('vorgang_nummer_seq');
alter table vorgang alter column nummer set default nextval('vorgang_nummer_seq');
alter table vorgang alter column nummer set not null;
alter table vorgang add constraint vorgang_nummer_eindeutig unique (nummer);
alter sequence vorgang_nummer_seq owned by vorgang.nummer;

View File

@@ -71,6 +71,7 @@ export const TABELLEN: Tabelle[] = [
sortierung: "abschnitt_id, reihenfolge, start", sortierung: "abschnitt_id, reihenfolge, start",
schema: z.object({ schema: z.object({
abschnitt_id: id, abschnitt_id: id,
nummer: z.number().int().positive().optional(),
name: text, name: text,
start: datum, start: datum,
dauer: z.number().min(0).optional(), dauer: z.number().min(0).optional(),

67
src/server/terminplan.ts Normal file
View File

@@ -0,0 +1,67 @@
// Terminplan auf dem Server: Laden für das Gantt und Neuplanung der Nachfolger nach jeder
// Änderung an Vorgängen oder Verknüpfungen, in derselben Transaktion.
import type { Client, Pool } from "./db.js";
import type { Arbeitswoche } from "../domain/kalender.js";
import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVorgaenge, planeNeu } from "../domain/terminplan.js";
export class PlanFehler extends Error {
statusCode = 409;
}
async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: PlanVorgang[]; links: Verknuepfung[] }> {
const [v, k] = await Promise.all([
c.query<PlanVorgang>("select id, start, dauer from vorgang"),
c.query<Verknuepfung>("select vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
]);
return { vorgaenge: v.rows, links: k.rows };
}
/**
* Führt eine Änderung aus und plant danach die Nachfolger neu. Vorgänge, die vorher direkt an ihrem
* Vorgänger hingen, rücken auch nach vorn, außer sie wurden gerade selbst verschoben (`bewegt`).
* Gibt die IDs der verschobenen Vorgänge zurück.
*/
export async function mitNeuplanung<T>(
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [],
): Promise<{ ergebnis: T; verschoben: string[] }> {
const vorher = await ladeStand(c);
const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche);
// wer von Hand verschoben wurde, bleibt dort (höchstens bis zum frühesten Start zurückgesetzt)
for (const id of bewegt) eng.delete(id);
const ergebnis = await aenderung();
const nachher = await ladeStand(c);
let starts;
try {
({ starts } = planeNeu(nachher.vorgaenge, nachher.links, woche, eng));
} catch (e) {
throw new PlanFehler((e as Error).message);
}
for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]);
return { ergebnis, verschoben: [...starts.keys()] };
}
/** Prüft eine neue Verknüpfung vor dem Speichern. */
export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; vorgaenger_id: string }, ausser?: string): Promise<void> {
const r = await c.query<Verknuepfung & { id: string }>("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger");
if (bildetKreis(neu, r.rows.filter((k) => k.id !== ausser))) {
throw new PlanFehler("Diese Verknüpfung ergäbe einen Kreis: der Vorgänger hängt schon (über andere Vorgänge) an diesem Vorgang.");
}
}
/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */
export async function terminplan(pool: Pool, woche: Arbeitswoche) {
const [projekte, abschnitte, vorgaenge, links] = await Promise.all([
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, k.name as bauherr
from projekt p left join kontakt k on k.id = p.bauherr_id order by p.reihenfolge, p.nummer`),
pool.query("select id, projekt_id, name, ist_meilenstein, reihenfolge from abschnitt order by reihenfolge, name"),
pool.query("select id, abschnitt_id, nummer, name, start, dauer, stunden, personen, kontakt_id, fortschritt, reihenfolge from vorgang order by reihenfolge, nummer"),
pool.query("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
]);
return {
projekte: projekte.rows,
abschnitte: abschnitte.rows,
vorgaenge: vorgaenge.rows.map((v) => ({ ...v, anfang: anfang(v, woche), ende: ende(v, woche) })),
verknuepfungen: links.rows,
arbeitstage: woche.tage,
};
}

View File

@@ -36,8 +36,11 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
for (const { schluessel, projekt, ...a } of u.abschnitte) { for (const { schluessel, projekt, ...a } of u.abschnitte) {
id.set(schluessel, await einfuegen(c, "abschnitt", { ...a, projekt_id: ref(projekt) })); id.set(schluessel, await einfuegen(c, "abschnitt", { ...a, projekt_id: ref(projekt) }));
} }
// V70-Nummern bleiben, damit Henning seine Vorgänger-Nummern wiederfindet; neue zählen danach weiter
const hoechste = Math.max(1000, ...u.vorgaenge.map((v) => v.reihenfolge));
await c.query("select setval('vorgang_nummer_seq', $1)", [hoechste]);
for (const { schluessel, abschnitt, ...v } of u.vorgaenge) { for (const { schluessel, abschnitt, ...v } of u.vorgaenge) {
id.set(schluessel, await einfuegen(c, "vorgang", { ...v, abschnitt_id: ref(abschnitt) })); id.set(schluessel, await einfuegen(c, "vorgang", { ...v, nummer: v.reihenfolge > 0 ? v.reihenfolge : undefined, abschnitt_id: ref(abschnitt) }));
} }
for (const k of u.verknuepfungen) { for (const k of u.verknuepfungen) {
await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung }); await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung });

View File

@@ -3,6 +3,7 @@
import { formatEuro, parseEuro } from "../domain/geld.js"; import { formatEuro, parseEuro } from "../domain/geld.js";
import { formatDatum } from "../domain/datum.js"; import { formatDatum } from "../domain/datum.js";
import { terminplanSeite } from "./gantt.js";
type Zeile = Record<string, any>; type Zeile = Record<string, any>;
@@ -214,8 +215,7 @@ async function projekte(): Promise<void> {
} }
async function terminplan(): Promise<void> { async function terminplan(): Promise<void> {
seite("Terminplan"); await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.</p>`);
} }
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> { async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {

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

@@ -0,0 +1,334 @@
// Terminplan als Gantt wie in V70 (T1–T5): Projekt → Abschnitt → Vorgang, Balken ziehen
// verschiebt, rechter Griff ändert die Dauer, Vorgänger per Nummer mit Art und Verzögerung.
// Die Neuplanung der Nachfolger macht der Server.
import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js";
import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag } from "../domain/kalender.js";
type Zeile = Record<string, any>;
export interface Hilfen {
api<T = any>(pfad: string, methode?: string, body?: unknown): Promise<T>;
dialog(titel: string, felder: { name: string; titel: string; art?: "text" | "datum" | "zahl" | "auswahl"; optionen?: [string, string][]; pflicht?: boolean }[], werte: Zeile, mitLoeschen: boolean):
Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null>;
esc(v: unknown): string;
seite(titel: string): HTMLElement;
inhalt: HTMLElement;
}
interface Plan {
projekte: Zeile[];
abschnitte: Zeile[];
vorgaenge: Zeile[];
verknuepfungen: Zeile[];
arbeitstage: number[];
}
const ZOOM: Record<string, number> = { tag: 24, woche: 10, monat: 4 };
const ZEILE = 34;
const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
const MONATE = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
// Ansichtseinstellungen nur für diesen Browser
function merke<T>(schluessel: string, wert?: T): T | undefined {
try {
if (wert === undefined) return JSON.parse(localStorage.getItem(`betrieb-${schluessel}`) ?? "null") ?? undefined;
localStorage.setItem(`betrieb-${schluessel}`, JSON.stringify(wert));
} catch { /* privates Fenster: dann eben ohne Gedächtnis */ }
return wert;
}
/** „1003, 1005 AA+2“ → Liste von Verknüpfungen; wirft bei unbekannter Nummer. */
export function leseVorgaenger(text: string, nummern: Map<number, string>): { vorgaenger_id: string; art: string; verzoegerung: number }[] {
return text.split(/[,;]/).map((s) => s.trim()).filter(Boolean).map((s) => {
const m = /^(\d+)\s*(EA|AA|EE|AE)?\s*([+-]\s*\d+)?$/i.exec(s);
if (!m) throw new Error(`„${s}“ verstehe ich nicht. Beispiele: 1003, 1003 AA, 1003 EA+2`);
const id = nummern.get(Number(m[1]));
if (!id) throw new Error(`Vorgang ${m[1]} gibt es nicht.`);
return { vorgaenger_id: id, art: (m[2] ?? "EA").toUpperCase(), verzoegerung: m[3] ? Number(m[3].replace(/\s/g, "")) : 0 };
});
}
export function vorgaengerText(links: Zeile[], nummer: Map<string, number>): string {
return links.map((k) => `${nummer.get(k.vorgaenger_id)}${k.art !== "EA" || k.verzoegerung ? ` ${k.art}` : ""}${k.verzoegerung ? (k.verzoegerung > 0 ? "+" : "") + k.verzoegerung : ""}`).join(", ");
}
export async function terminplanSeite(h: Hilfen): Promise<void> {
const { api, esc, inhalt } = h;
const leiste = h.seite("Terminplan");
const plan = await api<Plan>("terminplan");
const woche: Arbeitswoche = { tage: plan.arbeitstage };
let zoom = merke<string>("gantt-zoom") ?? "tag";
const zu = new Set<string>(merke<string[]>("gantt-zu") ?? []);
const mitFertigen = merke<boolean>("gantt-fertige") ?? false;
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${z === zoom ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
<button class="neben" data-a="heute">Heute</button>
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
<span class="hinweis">Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve.</span>`;
const nummerVon = new Map<string, number>(plan.vorgaenge.map((v) => [v.id, v.nummer]));
const idVon = new Map<number, string>(plan.vorgaenge.map((v) => [v.nummer, v.id]));
const linksVon = (id: string) => plan.verknuepfungen.filter((k) => k.vorgang_id === id);
const projekte = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen");
const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]);
// Zeitraum: vom frühesten Vorgang (oder heute) bis zum spätesten plus Luft
const heute = new Date().toISOString().slice(0, 10);
const sichtbar = plan.vorgaenge.filter((v) => projekte.some((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id)));
let von = montagDerWoche(plusTage(sichtbar.reduce((m, v) => (v.anfang < m ? v.anfang : m), heute), -7));
let bis = plusTage(sichtbar.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 30)), 21);
const minTage = zoom === "monat" ? 400 : zoom === "woche" ? 160 : 0;
if (tageZwischen(von, bis) + 1 < minTage) bis = plusTage(von, minTage - 1);
const W = ZOOM[zoom]!;
const tage = tageZwischen(von, bis) + 1;
const x = (d: Datum) => tageZwischen(von, d) * W;
// Zeilen aufbauen
type Reihe = { art: "p" | "a" | "v"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum };
const reihen: Reihe[] = [];
projekte.forEach((p, i) => {
const f = farbe(p, i);
const abs = plan.abschnitte.filter((a) => a.projekt_id === p.id);
const vs = plan.vorgaenge.filter((v) => abs.some((a) => a.id === v.abschnitt_id));
const spanne = (l: Zeile[]) => (l.length ? { von: l.reduce((m, v) => (v.anfang < m ? v.anfang : m), l[0]!.anfang), bis: l.reduce((m, v) => (v.ende > m ? v.ende : m), l[0]!.ende) } : {});
reihen.push({ art: "p", obj: p, projekt: p, farbe: f, ...spanne(vs) });
if (zu.has(p.id)) return;
for (const a of abs) {
const av = vs.filter((v) => v.abschnitt_id === a.id);
reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) });
if (zu.has(a.id)) continue;
for (const v of av) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende });
}
});
const zeileVon = new Map<string, number>();
reihen.forEach((r, i) => zeileVon.set(r.obj.id, i));
// Kopf: Monate, Kalenderwochen, Tage
let monate = "", kw = "", tagKopf = "", schatten = "";
for (let i = 0, mStart = 0, wStart = 0; i < tage; i++) {
const d = plusTage(von, i);
const naechster = plusTage(d, 1);
if (naechster.slice(0, 7) !== d.slice(0, 7) || i === tage - 1) {
const n = i - mStart + 1;
monate += `<div style="width:${n * W}px">${n * W > 50 ? `${MONATE[Number(d.slice(5, 7)) - 1]} ${d.slice(0, 4)}` : ""}</div>`;
mStart = i + 1;
}
if (wochentag(naechster) === 1 || i === tage - 1) {
const n = i - wStart + 1;
kw += `<div style="width:${n * W}px">${n * W > 34 ? `KW ${kalenderwoche(d)}` : ""}</div>`;
wStart = i + 1;
}
const ft = feiertag(d);
const frei = !istArbeitstag(d, woche);
const freitag = wochentag(d) === 5 && !ft;
const klasse = ft ? "feiertag" : freitag ? "reserve" : frei ? "frei" : "";
const titel = ft ? ft.name : freitag ? "Freitag: Reserve und Bürotag" : "";
tagKopf += `<div class="${klasse}" style="width:${W}px"${titel ? ` title="${esc(titel)}"` : ""}>${W >= 18 ? Number(d.slice(8)) : ""}</div>`;
if (klasse) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
}
if (heute >= von && heute <= bis) schatten += `<i class="heute" style="left:${x(heute) + W / 2}px"></i>`;
// Linke Spalten und Balken je Zeile
const zeilenHtml = reihen.map((r, i) => {
const o = r.obj;
let links = "", balken = "";
const datumZelle = (d?: Datum) => `<span class="dat">${d ? formatDatum(d).slice(0, 6) + d.slice(2, 4) : "–"}</span>`;
if (r.art === "p") {
links = `<span class="griff" draggable="true" data-zieh="${o.id}" title="Ziehen, um die Reihenfolge zu ändern">⋮⋮</span>
<button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
<span class="name" title="${esc(o.bezeichnung)}"><b>${esc(o.nummer)}</b> ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span>
<button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button>`;
if (r.von) balken = `<div class="balken projekt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
} else if (r.art === "a") {
links = `<span></span><button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
<span class="name abschnitt" data-abschnitt="${o.id}" title="Umbenennen">${esc(o.name)}</span>
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span>
<button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button>`;
if (r.von) balken = `<div class="balken abschnitt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
} else {
const ms = Number(o.dauer) === 0;
links = `<span class="nr">${o.nummer}</span><span></span>
<span class="name vorgang" data-vorgang="${o.id}" title="Bearbeiten">${esc(o.name)}</span>
${datumZelle(o.anfang)}${datumZelle(o.ende)}<span class="at">${ms ? "◆" : Math.ceil(o.dauer)}</span>
<span class="vg" title="Vorgänger">${esc(vorgaengerText(linksVon(o.id), nummerVon))}</span><span></span>`;
const breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
balken = ms
? `<div class="balken meilenstein" data-bar="${o.id}" style="left:${x(o.anfang) + W / 2 - 7}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)}"></div>`
: `<div class="balken vorgang" data-bar="${o.id}" style="left:${x(o.anfang)}px;width:${breite}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${Math.ceil(o.dauer)} AT">${breite > 40 ? `${Math.ceil(o.dauer)} AT` : ""}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`;
}
return `<div class="g-zeile ${r.art}" style="top:${i * ZEILE}px"><div class="g-links" style="box-shadow:inset 4px 0 0 ${r.art === "p" ? r.farbe : "transparent"}">${links}</div></div>
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
}).join("");
// Pfeile für die Verknüpfungen
const pfeile = plan.verknuepfungen.map((k) => {
const a = plan.vorgaenge.find((v) => v.id === k.vorgaenger_id);
const b = plan.vorgaenge.find((v) => v.id === k.vorgang_id);
const ya = zeileVon.get(k.vorgaenger_id), yb = zeileVon.get(k.vorgang_id);
if (!a || !b || ya === undefined || yb === undefined) return "";
const vonAnfang = k.art === "AA" || k.art === "AE", zuEnde = k.art === "EE" || k.art === "AE";
const x1 = vonAnfang ? x(a.anfang) : x(a.ende) + W, x2 = zuEnde ? x(b.ende) + W : x(b.anfang);
const y1 = ya * ZEILE + ZEILE / 2, y2 = yb * ZEILE + ZEILE / 2;
const knick = vonAnfang ? Math.min(x1, x2) - 8 : zuEnde ? Math.max(x1, x2) + 8 : x1 + 6;
const spitze = zuEnde ? `${x2},${y2} ${x2 + 5},${y2 - 3} ${x2 + 5},${y2 + 3}` : `${x2},${y2} ${x2 - 5},${y2 - 3} ${x2 - 5},${y2 + 3}`;
return `<path d="M${x1} ${y1}H${knick}V${y2}H${x2}"/><polygon points="${spitze}"/>`;
}).join("");
const hoehe = reihen.length * ZEILE;
const box = document.createElement("div");
box.className = "gantt";
box.innerHTML = `<div class="g-inhalt" style="width:calc(var(--links) + ${tage * W}px)">
<div class="g-kopf"><div class="g-links kopf"><span>Nr.</span><span></span><span>Projekt / Vorgang</span><span>Start</span><span>Ende</span><span>AT</span><span>Vorgänger</span><span></span></div>
<div class="g-zeit"><div class="reihe">${monate}</div><div class="reihe">${kw}</div><div class="reihe tage">${tagKopf}</div></div></div>
<div class="g-koerper" style="height:${hoehe}px">
<div class="g-schatten" style="width:${tage * W}px">${schatten}</div>
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
${zeilenHtml}
</div></div>
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}`;
inhalt.appendChild(box);
const linksBreite = () => box.querySelector<HTMLElement>(".g-kopf .g-links")?.offsetWidth ?? 0;
const nachHeute = () => (box.scrollLeft = Math.max(0, x(heute) - (box.clientWidth - linksBreite()) / 3));
const gespeichert = merke<number>("gantt-scroll");
if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute();
box.addEventListener("scroll", () => merke("gantt-scroll", box.scrollLeft), { passive: true });
const neuLaden = () => terminplanSeite(h);
leiste.addEventListener("click", (ev) => {
const b = (ev.target as HTMLElement).closest("button");
if (b?.dataset.zoom) { merke("gantt-zoom", b.dataset.zoom); merke("gantt-scroll", null as unknown as number); neuLaden(); }
if (b?.dataset.a === "heute") nachHeute();
});
leiste.querySelector<HTMLInputElement>('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); };
// Klicks in der linken Spalte
box.addEventListener("click", async (ev) => {
const t = ev.target as HTMLElement;
if (t.dataset.klapp) {
zu.has(t.dataset.klapp) ? zu.delete(t.dataset.klapp) : zu.add(t.dataset.klapp);
merke("gantt-zu", [...zu]);
return neuLaden();
}
if (t.dataset.neuAbschnitt) {
const r = await h.dialog("Neuer Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], {}, false);
if (r?.aktion !== "speichern") return;
const reihenfolge = Math.max(0, ...plan.abschnitte.filter((a) => a.projekt_id === t.dataset.neuAbschnitt).map((a) => a.reihenfolge)) + 1;
await api("abschnitte", "POST", { projekt_id: t.dataset.neuAbschnitt, name: r.daten.name, reihenfolge });
zu.delete(t.dataset.neuAbschnitt);
return neuLaden();
}
if (t.dataset.neuVorgang) return vorgangDialog(null, t.dataset.neuVorgang);
const abschnittId = t.closest<HTMLElement>("[data-abschnitt]")?.dataset.abschnitt;
if (abschnittId) {
const a = plan.abschnitte.find((x) => x.id === abschnittId)!;
const r = await h.dialog("Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], a, true);
if (r?.aktion === "loeschen") await api(`abschnitte/${a.id}`, "DELETE");
else if (r?.aktion === "speichern") await api(`abschnitte/${a.id}`, "PATCH", { name: r.daten.name });
if (r) neuLaden();
return;
}
const vorgangId = t.closest<HTMLElement>("[data-vorgang]")?.dataset.vorgang;
if (vorgangId) vorgangDialog(plan.vorgaenge.find((v) => v.id === vorgangId)!, null);
});
async function vorgangDialog(v: Zeile | null, abschnittId: string | null): Promise<void> {
const geschwister = plan.vorgaenge.filter((x) => x.abschnitt_id === (v?.abschnitt_id ?? abschnittId));
const letzter = geschwister[geschwister.length - 1];
const vorschlag = letzter ? naechsterArbeitstag(plusTage(letzter.ende, 1), woche) : naechsterArbeitstag(heute, woche);
const werte = v
? { name: v.name, start: v.anfang, dauer: String(Math.ceil(v.dauer)), vorgaenger: vorgaengerText(linksVon(v.id), nummerVon) }
: { name: "", start: vorschlag, dauer: "5", vorgaenger: letzter ? String(letzter.nummer) : "" };
const r = await h.dialog(v ? `Vorgang ${v.nummer}` : "Neuer Vorgang", [
{ name: "name", titel: "Bezeichnung", pflicht: true },
{ name: "start", titel: "Start", art: "datum", pflicht: true },
{ name: "dauer", titel: "Dauer in Arbeitstagen (0 = Meilenstein)", art: "zahl", pflicht: true },
{ name: "vorgaenger", titel: "Vorgänger: Nummer, Art und Verzögerung, z. B. 1003, 1005 AA+2" },
], werte, !!v);
if (!r) return;
if (r.aktion === "loeschen") { await api(`vorgaenge/${v!.id}`, "DELETE"); return neuLaden(); }
const neu = leseVorgaenger(r.daten.vorgaenger ?? "", idVon);
const dauer = Math.max(0, Math.round(Number(r.daten.dauer)));
let id = v?.id;
if (v) await api(`vorgaenge/${v.id}`, "PATCH", { name: r.daten.name, start: r.daten.start, dauer });
else id = (await api<Zeile>("vorgaenge", "POST", { abschnitt_id: abschnittId, name: r.daten.name, start: r.daten.start, dauer, reihenfolge: geschwister.length + 1 })).id;
// Verknüpfungen abgleichen: entfernte löschen, geänderte anpassen, neue anlegen
const alt = id ? linksVon(id) : [];
for (const k of alt) if (!neu.some((n) => n.vorgaenger_id === k.vorgaenger_id)) await api(`verknuepfungen/${k.id}`, "DELETE");
for (const n of neu) {
const k = alt.find((a) => a.vorgaenger_id === n.vorgaenger_id);
if (!k) await api("verknuepfungen", "POST", { vorgang_id: id, ...n });
else if (k.art !== n.art || k.verzoegerung !== n.verzoegerung) await api(`verknuepfungen/${k.id}`, "PATCH", { art: n.art, verzoegerung: n.verzoegerung });
}
neuLaden();
}
// Balken ziehen: verschieben oder (rechter Griff) Dauer ändern
box.addEventListener("pointerdown", (ev) => {
const t = ev.target as HTMLElement;
const bar = t.closest<HTMLElement>("[data-bar]");
if (!bar || ev.button !== 0) return;
const v = plan.vorgaenge.find((x) => x.id === bar.dataset.bar)!;
const dauerAendern = !!t.dataset.dauer;
const startX = ev.clientX;
const links0 = bar.offsetLeft, breite0 = bar.offsetWidth;
let bewegt = false;
bar.setPointerCapture(ev.pointerId);
bar.classList.add("zieht");
const tage = (e: PointerEvent) => Math.round((e.clientX - startX) / W);
const zieh = (e: PointerEvent) => {
const n = tage(e);
if (n !== 0) bewegt = true;
if (dauerAendern) bar.style.width = `${Math.max(W, breite0 + n * W)}px`;
else bar.style.left = `${links0 + n * W}px`;
};
const los = async (e: PointerEvent) => {
bar.removeEventListener("pointermove", zieh);
bar.classList.remove("zieht");
const n = tage(e);
if (!bewegt || n === 0) { if (!bewegt) vorgangDialog(v, null); return; }
if (dauerAendern) {
const neuesEnde = plusTage(v.ende, n);
const dauer = Math.max(1, arbeitstageZwischen(v.anfang, neuesEnde < v.anfang ? v.anfang : neuesEnde, woche));
await api(`vorgaenge/${v.id}`, "PATCH", { dauer });
} else {
const ziel = plusTage(v.anfang, n);
await api(`vorgaenge/${v.id}`, "PATCH", { start: n > 0 ? naechsterArbeitstag(ziel, woche) : vorherigerArbeitstag(ziel, woche) });
}
neuLaden();
};
bar.addEventListener("pointermove", zieh);
bar.addEventListener("pointerup", los, { once: true });
});
// Projekte per Drag & Drop umsortieren (T1)
let gezogen: string | null = null;
box.addEventListener("dragstart", (ev) => { gezogen = (ev.target as HTMLElement).dataset.zieh ?? null; });
box.addEventListener("dragover", (ev) => { if (gezogen && (ev.target as HTMLElement).closest(".g-zeile.p")) ev.preventDefault(); });
box.addEventListener("drop", async (ev) => {
const ziel = (ev.target as HTMLElement).closest(".g-zeile.p")?.querySelector<HTMLElement>("[data-zieh]")?.dataset.zieh;
if (!gezogen || !ziel || ziel === gezogen) return;
ev.preventDefault();
const ids = plan.projekte.map((p) => p.id).filter((id) => id !== gezogen);
ids.splice(ids.indexOf(ziel), 0, gezogen);
await Promise.all(ids.map((id, i) => (plan.projekte.find((p) => p.id === id)!.reihenfolge !== i ? api(`projekte/${id}`, "PATCH", { reihenfolge: i }) : null)));
gezogen = null;
neuLaden();
});
}
function vorherigerArbeitstag(d: Datum, woche: Arbeitswoche): Datum {
let x = d;
while (!istArbeitstag(x, woche)) x = plusTage(x, -1);
return x;
}
function kalenderwoche(d: Datum): number {
const t = new Date(`${d}T00:00:00Z`);
t.setUTCDate(t.getUTCDate() + 4 - (t.getUTCDay() || 7));
const jahresanfang = Date.UTC(t.getUTCFullYear(), 0, 1);
return Math.ceil(((t.getTime() - jahresanfang) / 86400000 + 1) / 7);
}

View File

@@ -94,3 +94,56 @@ td.zahl { white-space: nowrap; }
th, td { padding: 11px 10px; } th, td { padding: 11px 10px; }
td .unter { font-size: 12px; } td .unter { font-size: 12px; }
} }
/* Terminplan (Gantt) */
button.neben.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
.schalter { display: inline-flex; align-items: center; gap: 6px; color: var(--leise); font-size: 14px; }
.leiste .hinweis { font-size: 13px; margin-left: auto; }
.gantt { --links: 520px; overflow: auto; max-height: calc(100vh - 150px); background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; position: relative; }
.g-inhalt { position: relative; }
.g-kopf { position: sticky; top: 0; z-index: 4; display: flex; background: var(--fl); border-bottom: 1px solid var(--linie); }
.g-links { position: sticky; left: 0; z-index: 2; width: var(--links); flex: none; display: grid; grid-template-columns: 44px 22px 1fr 64px 64px 34px 92px 26px; align-items: center; gap: 4px; padding: 0 6px 0 8px; height: 34px; background: var(--fl); border-right: 1px solid var(--linie); font-size: 13px; }
.g-links.kopf { height: 63px; align-items: end; padding-bottom: 6px; font-size: 12px; color: var(--leise); font-weight: 600; z-index: 5; }
.g-zeit .reihe { display: flex; height: 21px; font-size: 11px; color: var(--leise); }
.g-zeit .reihe > div { border-left: 1px solid var(--linie); padding: 3px 4px; white-space: nowrap; overflow: hidden; flex: none; }
.g-zeit .reihe.tage > div { padding: 3px 0; text-align: center; }
.g-zeit .tage .frei, .g-zeit .tage .feiertag { color: var(--warn); }
.g-zeit .tage .reserve { color: var(--holz); }
.g-koerper { position: relative; }
.g-zeile { position: absolute; left: 0; right: 0; height: 34px; border-bottom: 1px solid var(--linie); }
.g-zeile.p .g-links { font-weight: 600; background: var(--bg); }
.g-zeile.p { background: var(--bg); }
.g-zeile .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.g-zeile .name small { font-weight: 400; color: var(--leise); }
.g-zeile.a .name { font-weight: 600; padding-left: 4px; cursor: pointer; }
.g-zeile.v .name { padding-left: 18px; cursor: pointer; }
.g-zeile .name.vorgang:hover, .g-zeile .name.abschnitt:hover { color: var(--akzent); text-decoration: underline; }
.g-zeile .nr { color: var(--leise); font-variant-numeric: tabular-nums; }
.g-zeile .dat, .g-zeile .at { font-variant-numeric: tabular-nums; color: var(--leise); }
.g-zeile .vg { color: var(--leise); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 12px; }
.g-links .klapp, .g-links .plus { background: none; border: 0; color: var(--leise); cursor: pointer; font: inherit; padding: 0; width: 22px; height: 22px; border-radius: 5px; }
.g-links .plus { font-size: 17px; color: var(--akzent); }
.g-links .klapp:hover, .g-links .plus:hover { background: var(--akzent-hell); }
.g-links .griff { cursor: grab; color: var(--leise); user-select: none; text-align: center; }
.g-balken { position: absolute; height: 34px; left: var(--links); right: 0; pointer-events: none; z-index: 1; }
.balken { position: absolute; top: 9px; height: 16px; border-radius: 4px; color: #fff; font-size: 11px; line-height: 16px; padding-left: 5px; white-space: nowrap; overflow: hidden; pointer-events: auto; }
.balken.projekt { top: 14px; height: 6px; padding: 0; pointer-events: none; }
.balken.abschnitt { top: 12px; height: 10px; opacity: 0.55; padding: 0; pointer-events: none; }
.balken.vorgang { cursor: grab; touch-action: none; box-shadow: 0 1px 2px rgb(0 0 0 / 0.2); }
.balken.zieht { cursor: grabbing; opacity: 0.8; outline: 2px solid var(--akzent); }
.balken .griff-rechts { position: absolute; right: 0; top: 0; bottom: 0; width: 7px; cursor: ew-resize; background: rgb(255 255 255 / 0.35); }
.balken.meilenstein { width: 14px; height: 14px; top: 10px; transform: rotate(45deg); border-radius: 2px; padding: 0; cursor: grab; touch-action: none; }
.g-schatten { position: absolute; top: 0; bottom: 0; left: var(--links); }
.g-schatten i { position: absolute; top: 0; bottom: 0; }
.g-schatten .frei { background: rgb(120 130 150 / 0.10); }
.g-schatten .feiertag { background: rgb(180 35 24 / 0.10); }
.g-schatten .reserve { background: repeating-linear-gradient(135deg, rgb(162 110 58 / 0.10) 0 4px, transparent 4px 8px); }
.g-schatten .heute { width: 2px; background: var(--warn); }
.g-pfeile { position: absolute; top: 0; left: var(--links); pointer-events: none; z-index: 1; overflow: visible; }
.g-pfeile path { fill: none; stroke: var(--leise); stroke-width: 1.2; }
.g-pfeile polygon { fill: var(--leise); }
@media (max-width: 800px) {
.gantt { --links: 220px; }
.g-links { grid-template-columns: 22px 1fr 22px; }
.g-links > :nth-child(1), .g-links > :nth-child(4), .g-links > :nth-child(5), .g-links > :nth-child(6), .g-links > :nth-child(7) { display: none; }
}

View File

@@ -149,4 +149,43 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
expect(kurz(l)).toEqual(kurz(erwartet)); expect(kurz(l)).toEqual(kurz(erwartet));
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true); expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
}); });
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
const t = (await app.inject("/api/terminplan")).json();
expect(t.vorgaenge).toHaveLength(13);
expect(t.vorgaenge.every((v: { nummer: number }) => v.nummer > 1000)).toBe(true);
const nr = new Map(t.vorgaenge.map((v: { id: string }) => [v.id, v]));
for (const k of t.verknuepfungen.filter((k: { art: string }) => k.art === "EA")) {
const a = nr.get(k.vorgaenger_id) as { ende: string };
const b = nr.get(k.vorgang_id) as { anfang: string; dauer: number };
if (b.dauer > 0) expect(b.anfang > a.ende, `${a.ende} → ${b.anfang}`).toBe(true);
}
});
it("längerer Vorgang schiebt Nachfolger, Kreis wird abgelehnt", async () => {
const t = (await app.inject("/api/terminplan")).json();
const k = t.verknuepfungen.find((k: { art: string; verzoegerung: number }) => k.art === "EA");
const vor = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgaenger_id);
const nach = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgang_id);
const r = await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) + 10 } });
expect(r.statusCode, r.body).toBe(200);
const t2 = (await app.inject("/api/terminplan")).json();
const nach2 = t2.vorgaenge.find((v: { id: string }) => v.id === nach.id);
const vor2 = t2.vorgaenge.find((v: { id: string }) => v.id === vor.id);
expect(nach2.anfang > vor2.ende).toBe(true);
expect(nach2.anfang > nach.anfang).toBe(true);
const kreis = await app.inject({ method: "POST", url: "/api/verknuepfungen", payload: { vorgang_id: vor.id, vorgaenger_id: nach.id } });
expect(kreis.statusCode).toBe(409);
expect(kreis.json().fehler).toMatch(/Kreis/);
// kürzer machen: der enge Nachfolger rückt wieder nach vorn
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) } });
const t3 = (await app.inject("/api/terminplan")).json();
expect(t3.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang).toBe(nach.anfang);
// von Hand nach hinten gezogen: bleibt dort und zieht den Nachfolger mit
const spaeter = "2027-06-07";
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { start: spaeter } });
const t4 = (await app.inject("/api/terminplan")).json();
expect(t4.vorgaenge.find((v: { id: string }) => v.id === vor.id).anfang).toBe(spaeter);
expect(t4.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang > spaeter).toBe(true);
});
}); });

72
test/terminplan.test.ts Normal file
View File

@@ -0,0 +1,72 @@
import { describe, expect, it } from "vitest";
import { type PlanVorgang, type Verknuepfung, bildetKreis, ende, engeVorgaenge, fruehesterStart, planeNeu, startNachVerknuepfung } from "../src/domain/terminplan.js";
import { STANDARDWOCHE as W } from "../src/domain/kalender.js";
// 19.10.2026 ist ein Montag; gearbeitet wird Mo–Do
const v = (id: string, start: string, dauer: number): PlanVorgang => ({ id, start, dauer });
const k = (vorgang_id: string, vorgaenger_id: string, art: Verknuepfung["art"] = "EA", verzoegerung = 0): Verknuepfung => ({ vorgang_id, vorgaenger_id, art, verzoegerung });
describe("Verknüpfungsarten wie V70", () => {
const a = v("a", "2026-10-19", 3); // Mo–Mi
it("EA: am nächsten Arbeitstag nach dem Ende", () => {
expect(ende(a, W)).toBe("2026-10-21");
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a"), W)).toBe("2026-10-22");
});
it("EA mit Verzögerung überspringt Freitag und Wochenende", () => {
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "EA", 1), W)).toBe("2026-10-26");
});
it("EA bei Meilenstein: am Ende des Vorgängers", () => {
expect(startNachVerknuepfung(v("m", "2026-10-19", 0), a, k("m", "a"), W)).toBe("2026-10-21");
});
it("AA: gleicher Anfang plus Verzögerung", () => {
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "AA", 2), W)).toBe("2026-10-21");
});
it("EE: endet mit dem Vorgänger", () => {
const b = v("b", "2026-10-19", 2);
const s = startNachVerknuepfung(b, a, k("b", "a", "EE"), W);
expect(s).toBe("2026-10-20");
expect(ende({ ...b, start: s }, W)).toBe("2026-10-21");
});
it("AE: endet, wenn der Vorgänger anfängt", () => {
const b = v("b", "2026-10-01", 2);
expect(startNachVerknuepfung(b, a, k("b", "a", "AE"), W)).toBe("2026-10-15");
});
});
describe("mehrere Vorgänger (T5)", () => {
it("der späteste Vorgänger bestimmt den Start", () => {
const alle = new Map([v("a", "2026-10-19", 2), v("b", "2026-10-19", 4), v("c", "2026-10-19", 1)].map((x) => [x.id, x]));
expect(fruehesterStart(alle.get("c")!, alle, [k("c", "a"), k("c", "b")], W)).toBe("2026-10-26");
});
});
describe("Neuplanung", () => {
const links = [k("b", "a"), k("c", "b")];
it("schiebt Nachfolger nach hinten, wenn der Vorgänger länger dauert", () => {
const r = planeNeu([v("a", "2026-10-19", 5), v("b", "2026-10-22", 2), v("c", "2026-10-27", 1)], links, W);
expect(r.starts.get("b")).toBe("2026-10-27");
expect(r.starts.get("c")).toBe("2026-10-29");
});
it("zieht nur enge Nachfolger nach vorn", () => {
const alt = [v("a", "2026-10-19", 3), v("b", "2026-10-22", 2), v("c", "2026-11-02", 1)];
const eng = engeVorgaenge(alt, links, W);
expect([...eng]).toEqual(["b"]);
const r = planeNeu([v("a", "2026-10-19", 2), alt[1]!, alt[2]!], links, W, eng);
expect(r.starts.get("b")).toBe("2026-10-21");
expect(r.starts.has("c")).toBe(false);
});
it("lässt freie Vorgänge ohne Vorgänger in Ruhe", () => {
expect(planeNeu([v("x", "2026-10-19", 2)], [], W).starts.size).toBe(0);
});
});
describe("Kreise", () => {
const links = [k("b", "a"), k("c", "b")];
it("erkennt einen Kreis über mehrere Glieder", () => {
expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "c" }, links)).toBe(true);
expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "a" }, links)).toBe(true);
});
it("erlaubt einen zweiten Vorgänger ohne Kreis", () => {
expect(bildetKreis({ vorgang_id: "c", vorgaenger_id: "a" }, links)).toBe(false);
});
});