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:
149
src/domain/terminplan.ts
Normal file
149
src/domain/terminplan.ts
Normal 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 };
|
||||
}
|
||||
@@ -4,7 +4,8 @@ import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import { existsSync } from "node:fs";
|
||||
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 { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet } from "../domain/liquiditaet.js";
|
||||
@@ -52,6 +53,14 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
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) {
|
||||
const felder = Object.keys(t.schema.shape);
|
||||
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) => {
|
||||
const daten = t.schema.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0],
|
||||
);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) => {
|
||||
if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string });
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0]);
|
||||
});
|
||||
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 spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(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],
|
||||
);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) => {
|
||||
if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
|
||||
const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0];
|
||||
if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id);
|
||||
}
|
||||
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" });
|
||||
});
|
||||
|
||||
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
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" });
|
||||
});
|
||||
}
|
||||
@@ -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 });
|
||||
});
|
||||
|
||||
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
|
||||
app.post("/api/import/v70", async (req, reply) => {
|
||||
let u;
|
||||
@@ -152,7 +174,9 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
} catch (err) {
|
||||
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 });
|
||||
});
|
||||
|
||||
|
||||
8
src/server/migrations/003_vorgangsnummer.sql
Normal file
8
src/server/migrations/003_vorgangsnummer.sql
Normal 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;
|
||||
@@ -71,6 +71,7 @@ export const TABELLEN: Tabelle[] = [
|
||||
sortierung: "abschnitt_id, reihenfolge, start",
|
||||
schema: z.object({
|
||||
abschnitt_id: id,
|
||||
nummer: z.number().int().positive().optional(),
|
||||
name: text,
|
||||
start: datum,
|
||||
dauer: z.number().min(0).optional(),
|
||||
|
||||
67
src/server/terminplan.ts
Normal file
67
src/server/terminplan.ts
Normal 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,
|
||||
};
|
||||
}
|
||||
@@ -36,8 +36,11 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
|
||||
for (const { schluessel, projekt, ...a } of u.abschnitte) {
|
||||
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) {
|
||||
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) {
|
||||
await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung });
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
import { terminplanSeite } from "./gantt.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
|
||||
@@ -214,8 +215,7 @@ async function projekte(): Promise<void> {
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
seite("Terminplan");
|
||||
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>`);
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||||
}
|
||||
|
||||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
|
||||
334
src/web/gantt.ts
Normal file
334
src/web/gantt.ts
Normal 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);
|
||||
}
|
||||
@@ -94,3 +94,56 @@ td.zahl { white-space: nowrap; }
|
||||
th, td { padding: 11px 10px; }
|
||||
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; }
|
||||
}
|
||||
|
||||
@@ -149,4 +149,43 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect(kurz(l)).toEqual(kurz(erwartet));
|
||||
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
72
test/terminplan.test.ts
Normal 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);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user