Terminplan: Dauer aus Stunden und Besetzung, Auslastung je Woche (0.12.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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-20 07:12:26 +00:00
parent dd57169e9a
commit d5f861318b
16 changed files with 402 additions and 30 deletions

View File

@@ -148,7 +148,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
});
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung"]);
// T15: auch Besetzung, Abwesenheiten und Arbeitszeitmodelle ändern die Dauer berechneter Vorgänge
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "besetzung", "abwesenheit", "arbeitszeitmodell"]);
// P12: Projektänderungen legen den Zahlungsplan an oder führen ihn nach; eine Rate von Hand ändern stellt ihn fest
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = [], zahlungVon?: string): Promise<T> {
const e = await ladeEinstellungen();
@@ -159,7 +160,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
}
if (!PLAN.has(tabelle)) return fn();
const aenderung = zahlungVon ? async () => { const r = await fn(); await zahlungsplanFest(c, zahlungVon); return r; } : fn;
return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt)).ergebnis;
return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag)).ergebnis;
}
const projektDerZahlung = async (c: Client, tabelle: string, id: string) =>
tabelle === "zahlung" ? (await c.query("select projekt_id from zahlung where id = $1", [id])).rows[0]?.projekt_id as string | undefined : undefined;
@@ -209,6 +210,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const { id } = IdParam.parse(req.params);
const daten = teil.parse(req.body) as Record<string, unknown>;
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
// T15: wer die Dauer von Hand ändert, legt sie fest (wie beim Zahlungsplan)
if (t.name === "vorgang" && daten.dauer !== undefined && daten.dauer_fest === undefined) daten.dauer_fest = true;
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) => {
@@ -287,7 +290,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const e = await ladeEinstellungen();
const woche = { tage: e.arbeitstage };
const [tp, aufgaben, liqui] = await Promise.all([
terminplan(pool, woche),
terminplan(pool, woche, e.stundenProTag),
pool.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, k.name as kontakt_name, g.name as kategorie
from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id
left join aufgabe_kategorie g on g.id = a.kategorie_id
@@ -327,7 +330,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
app.get("/api/terminplan", async () => {
const e = await ladeEinstellungen();
return terminplan(pool, { tage: e.arbeitstage });
return terminplan(pool, { tage: e.arbeitstage }, e.stundenProTag);
});
// Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm

View File

@@ -0,0 +1,5 @@
-- T15: Dauer aus Stunden und Besetzung. Neue Vorgänge rechnen ihre Dauer aus den Stunden und der verfügbaren Zeit
-- der Eingeteilten, sobald beides da ist. Bestehende Vorgänge behalten ihre Dauer („Dauer fest“), damit sich
-- Hennings Plan beim Umstieg nicht von selbst verschiebt; das Gantt zeigt dort nur die Abweichung.
alter table vorgang add column dauer_fest boolean not null default false;
update vorgang set dauer_fest = true;

View File

@@ -33,7 +33,9 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
// so passt eine ältere Sicherung auch nach einer Migration
const vorhanden = new Set((await c.query<{ column_name: string }>(
"select column_name from information_schema.columns where table_schema = current_schema() and table_name = $1", [t.name])).rows.map((r) => r.column_name));
for (const z of zeilen) {
for (const zeile of zeilen) {
// T15: Vorgänge aus einer Sicherung von vor 0.12 behalten ihre Dauer
const z = t.name === "vorgang" && !("dauer_fest" in zeile) ? { ...zeile, dauer_fest: true } : zeile;
const spalten = Object.keys(z).filter((k) => vorhanden.has(k)).join(", ");
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_record(null::${t.name}, $1::json)`, [JSON.stringify(z)]);
}

View File

@@ -86,6 +86,7 @@ export const TABELLEN: Tabelle[] = [
reihenfolge: z.number().int().optional(),
fortschritt: z.number().int().min(0).max(100).optional(),
personen: z.number().positive().nullable().optional(),
dauer_fest: z.boolean().optional(),
}),
},
{

View File

@@ -5,26 +5,40 @@ import type { Client, Pool } from "./db.js";
import type { Arbeitswoche } from "../domain/kalender.js";
import { kuerzel, ueberschneidungen } from "../domain/einsatz.js";
import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVorgaenge, planeNeu } from "../domain/terminplan.js";
import { type KapBesetzung, type Personaldaten, auslastung, dauerNachBesetzung, reduzierteTage } from "../domain/kapazitaet.js";
import { ladePersonal } from "./personal.js";
import { plusTage } from "../domain/datum.js";
export class PlanFehler extends Error {
statusCode = 409;
}
async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: PlanVorgang[]; links: Verknuepfung[] }> {
type StandVorgang = PlanVorgang & { stunden: number | null; dauer_fest: boolean };
async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: StandVorgang[]; links: Verknuepfung[] }> {
const [v, k] = await Promise.all([
c.query<PlanVorgang>("select id, start, dauer from vorgang"),
c.query<StandVorgang>("select id, start, dauer, stunden, dauer_fest from vorgang"),
c.query<Verknuepfung>("select vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
]);
return { vorgaenge: v.rows, links: k.rows };
}
/** Besetzungen und Personaldaten für T15/T16 */
async function ladeKapazitaet(c: Client | Pool, stundenProTag: number): Promise<{ besetzungen: KapBesetzung[]; personal: Personaldaten }> {
const [b, st] = await Promise.all([
c.query<KapBesetzung>("select vorgang_id, kontakt_id, platzhalter, personen from besetzung"),
ladePersonal(c),
]);
return { besetzungen: b.rows.map((x) => ({ ...x, personen: Number(x.personen) })), personal: { modelle: st.modelle, abwesenheiten: st.abwesenheiten, stundenProTag } };
}
/**
* 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[] = [],
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [], stundenProTag = 8,
): Promise<{ ergebnis: T; verschoben: string[] }> {
const vorher = await ladeStand(c);
const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche);
@@ -32,16 +46,21 @@ export async function mitNeuplanung<T>(
for (const id of bewegt) eng.delete(id);
const ergebnis = await aenderung();
const nachher = await ladeStand(c);
let starts;
// T15: wer keine feste Dauer hat, bekommt sie aus Stunden und Besetzung, passend zum (neuen) Start
const auto = new Map(nachher.vorgaenge.filter((v) => !v.dauer_fest && Number(v.stunden) > 0 && Number(v.dauer) > 0).map((v) => [v.id, v]));
const kap = auto.size ? await ladeKapazitaet(c, stundenProTag) : null;
const dauerFuer = kap ? (v: PlanVorgang) => (auto.has(v.id) ? dauerNachBesetzung({ ...auto.get(v.id)!, start: v.start }, kap.besetzungen, kap.personal, woche) : undefined) : undefined;
let starts, dauern;
try {
({ starts } = planeNeu(nachher.vorgaenge, nachher.links, woche, eng));
({ starts, dauern } = planeNeu(nachher.vorgaenge, nachher.links, woche, eng, dauerFuer));
} 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]);
for (const [id, dauer] of dauern) await c.query("update vorgang set dauer = $2 where id = $1", [id, dauer]);
await zahlungenNachziehen(c, woche);
await zahlungsplaeneAutomatisch(c, woche);
return { ergebnis, verschoben: [...starts.keys()] };
return { ergebnis, verschoben: [...new Set([...starts.keys(), ...dauern.keys()])] };
}
/** Geplante Raten, die an einem Vorgang hängen, werden mit dessen Ende fällig und wandern mit ihm. */
@@ -64,19 +83,39 @@ export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; v
}
/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */
export async function terminplan(pool: Pool, woche: Arbeitswoche) {
export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag = 8) {
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen] = await Promise.all([
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, p.umsatz_netto, p.zahlungsplan, 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, abschnitt_id, nummer, name, start, dauer, dauer_fest, 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"),
pool.query(`select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.personen, b.freigegeben, k.name, k.firma, k.rolle
from besetzung b left join kontakt k on k.id = b.kontakt_id order by b.angelegt_am`),
pool.query("select id, name, firma, rolle from kontakt where rolle in ('mitarbeiter', 'subunternehmer') order by rolle, name"),
pool.query("select id, projekt_id, vorgang_id, art, bezeichnung, netto, termin, status from zahlung order by termin, reihenfolge"),
]);
const vs = vorgaenge.rows.map((v) => ({ ...v, anfang: anfang(v, woche), ende: ende(v, woche) }));
const kap = await ladeKapazitaet(pool, stundenProTag);
const vs = vorgaenge.rows.map((v) => {
const a = anfang(v, woche), e = ende(v, woche);
return {
...v, anfang: a, ende: e,
// T15: Dauer nach Stunden und Besetzung; bei fester Dauer zeigt das Gantt die Abweichung
dauer_besetzung: Number(v.dauer) > 0 ? dauerNachBesetzung(v, kap.besetzungen, kap.personal, woche) ?? null : null,
// T16: Tage, an denen die Eingeteilten nicht voll da sind (Balken heller)
reduziert: Number(v.dauer) > 0 ? reduzierteTage({ id: v.id, anfang: a, ende: e }, kap.besetzungen, kap.personal, woche) : [],
};
});
// T16: Auslastung des eigenen Teams je Woche, ab vier Wochen zurück bis zum letzten Vorgang (höchstens ein Jahr)
const heute = new Date().toISOString().slice(0, 10);
const stamm = new Set(kap.personal.modelle.map((m) => m.kontakt_id));
const mitStamm = (await pool.query("select kontakt_id from mitarbeiter")).rows.map((r) => r.kontakt_id as string);
for (const k of mitStamm) stamm.add(k);
const team = leute.rows.filter((k) => k.rolle === "mitarbeiter" && (stamm.has(k.id) || kap.besetzungen.some((b) => b.kontakt_id === k.id))).map((k) => k.id as string);
const ab = plusTage(heute, -28);
const bisSpaetestens = plusTage(heute, 365);
const letztes = vs.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 28));
const team_auslastung = team.length ? auslastung(ab, letztes < bisSpaetestens ? letztes : bisSpaetestens, team, vs, kap.besetzungen, kap.personal, woche) : [];
const bs = besetzungen.rows.map((b) => ({
...b,
kurz: b.kontakt_id ? kuerzel(b.rolle === "subunternehmer" && b.firma ? b.firma : b.name, b.rolle) : b.platzhalter,
@@ -93,5 +132,7 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche) {
zahlungen: zahlungen.rows,
ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
arbeitstage: woche.tage,
team,
auslastung: team_auslastung,
};
}

View File

@@ -8,6 +8,7 @@ import { type Abwesenheit, urlaubstage } from "../domain/personal.js";
import { formatDatum, jahrVon } from "../domain/datum.js";
import { anfang, ende } from "../domain/terminplan.js";
import { kontoFuer, ladePersonal } from "./personal.js";
import { mitNeuplanung } from "./terminplan.js";
type Abfrage = Pick<Pool, "query">;
const Tag = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
@@ -127,11 +128,14 @@ export function registriereUrlaub(app: FastifyInstance, pool: Pool, einstellunge
app.post("/api/urlaub/:id/entscheidung", async (req) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const d = z.object({ status: z.enum(["genehmigt", "abgelehnt"]), antwort: z.string().trim().max(500).nullable().optional() }).parse(req.body);
const e = await einstellungen();
return transaktion(pool, req.wer!.anmeldename, async (c) => {
const a = (await c.query("select status from abwesenheit where id = $1 and art = 'urlaub'", [id])).rows[0];
if (!a) throw new Fehler(404, "Nicht gefunden");
if (a.status !== "beantragt") throw new Fehler(409, `Der Antrag ist schon ${a.status}.`);
return (await c.query("update abwesenheit set status = $2, antwort = $3 where id = $1 returning *", [id, d.status, d.antwort || null])).rows[0];
// genehmigter Urlaub verlängert berechnete Vorgänge (T15)
return (await mitNeuplanung(c, { tage: e.arbeitstage },
async () => (await c.query("update abwesenheit set status = $2, antwort = $3 where id = $1 returning *", [id, d.status, d.antwort || null])).rows[0], [], e.stundenProTag)).ergebnis;
});
});
}

View File

@@ -40,7 +40,7 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
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, nummer: v.reihenfolge > 0 ? v.reihenfolge : undefined, abschnitt_id: ref(abschnitt) }));
id.set(schluessel, await einfuegen(c, "vorgang", { ...v, nummer: v.reihenfolge > 0 ? v.reihenfolge : undefined, abschnitt_id: ref(abschnitt), dauer_fest: true }));
}
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 });