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

View File

@@ -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 });
});

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",
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
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) {
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 });