// 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 { restNachziehen, zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; 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"; import { type BezugArt, bezugsTermin } from "../domain/bezug.js"; import type { VorlageEintrag } from "./einstellungen.js"; import { vorlageAnwenden } from "./vorlage.js"; export class PlanFehler extends Error { statusCode = 409; } 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("select id, start, dauer, stunden, dauer_fest from vorgang"), c.query("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("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( c: Client, woche: Arbeitswoche, aenderung: () => Promise, bewegt: string[] = [], stundenProTag = 8, vorlage?: VorlageEintrag[], ): 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); // 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, 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 bezuegeNachziehen(c, woche); await zahlungsplaeneAutomatisch(c, woche); await restNachziehen(c); if (vorlage) await vorlageAnwenden(c, vorlage, woche); return { ergebnis, verschoben: [...new Set([...starts.keys(), ...dauern.keys()])] }; } /** * Was an einem Vorgang hängt, wandert mit ihm: geplante Raten, nicht bezahlte Kosten und offene Aufgaben. * Bezug am Anfang (AA) oder Ende (EE) mit Versatz in Arbeitstagen. */ export async function bezuegeNachziehen(c: Client, woche: Arbeitswoche): Promise { const teile: [string, string, string][] = [ ["zahlung", "termin", "coalesce(x.status, 'geplant') = 'geplant'"], ["kosten", "termin", "x.status <> 'bezahlt'"], ["aufgabe", "faellig_am", "x.erledigt_am is null"], ]; for (const [tabelle, feld, offen] of teile) { const r = await c.query<{ id: string; datum: string | null; bezug_art: BezugArt; bezug_tage: number; vid: string; start: string; dauer: number }>( `select x.id, x.${feld} as datum, x.bezug_art, x.bezug_tage, v.id as vid, v.start, v.dauer from ${tabelle} x join vorgang v on v.id = x.vorgang_id where ${offen}`); for (const z of r.rows) { const soll = bezugsTermin({ id: z.vid, start: z.start, dauer: Number(z.dauer) }, z.bezug_art, Number(z.bezug_tage), woche); if (soll !== z.datum) await c.query(`update ${tabelle} set ${feld} = $2 where id = $1`, [z.id, soll]); } } } /** 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 { const r = await c.query("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, stundenProTag = 8) { const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben] = 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, 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, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status, rest, reihenfolge from zahlung order by reihenfolge, termin"), pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status from kosten order by termin, bezeichnung"), // Aufgaben eines Projekts stehen im Terminplan in dessen Abschnitt „Aufgaben“ pool.query(`select a.id, a.projekt_id, a.vorgang_id, a.bezug_art, a.bezug_tage, a.text, a.faellig_am, a.erledigt_am, a.kategorie_id, g.name as kategorie from aufgabe a left join aufgabe_kategorie g on g.id = a.kategorie_id where a.projekt_id is not null order by a.faellig_am nulls last, a.angelegt_am`), ]); 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, anzeige: b.kontakt_id ? (b.firma && b.rolle === "subunternehmer" ? b.firma : b.name) : b.platzhalter, })); const anzeige = new Map(bs.map((b) => [b.kontakt_id ?? `platzhalter:${String(b.platzhalter).trim().toLowerCase()}`, b.anzeige])); return { projekte: projekte.rows, abschnitte: abschnitte.rows, vorgaenge: vs, verknuepfungen: links.rows, besetzungen: bs, leute: leute.rows, zahlungen: zahlungen.rows, kosten: kosten.rows, aufgaben: aufgaben.rows, ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })), arbeitstage: woche.tage, team, auslastung: team_auslastung, }; }