Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
179 lines
12 KiB
TypeScript
179 lines
12 KiB
TypeScript
// 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, wer } 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";
|
|
import { subKostenNachziehen } from "./subunternehmer.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<StandVorgang>("select id, start, start_teil, dauer, stunden, dauer_fest, freitage 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([
|
|
// eine Kolonne zählt mit jedem ihrer Mitglieder
|
|
c.query<KapBesetzung>("select vorgang_id, kontakt_id, platzhalter, personen from besetzung_person"),
|
|
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[] = [], 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, teile, dauern;
|
|
try {
|
|
({ starts, teile, 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, start_teil = $3 where id = $1", [id, start, teile.get(id) ?? 0]);
|
|
for (const [id, dauer] of dauern) await c.query("update vorgang set dauer = $2 where id = $1", [id, dauer]);
|
|
await subKostenNachziehen(c, woche, stundenProTag);
|
|
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<void> {
|
|
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; freitag: boolean; vid: string; start: string; start_teil: number; dauer: number; freitage: string[] }>(
|
|
`select x.id, x.${feld} as datum, x.bezug_art, x.bezug_tage, x.freitag, v.id as vid, v.start, v.start_teil, v.dauer, v.freitage
|
|
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, start_teil: z.start_teil, dauer: Number(z.dauer), freitage: z.freitage }, z.bezug_art, Number(z.bezug_tage), woche, z.freitag);
|
|
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<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, stundenProTag = 8) {
|
|
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben, kolonnen] = 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, start_teil, dauer, dauer_fest, freitage, 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.kolonne_id, b.personen, b.freigegeben, coalesce(k.name, ko.name) as name, k.firma, k.rolle
|
|
from besetzung b left join kontakt k on k.id = b.kontakt_id left join kolonne ko on ko.id = b.kolonne_id order by b.angelegt_am`),
|
|
pool.query(`select k.id, k.name, k.firma, k.rolle, s.kolonnengroesse from kontakt k left join subunternehmer s on s.kontakt_id = k.id
|
|
where k.rolle in ('mitarbeiter', 'subunternehmer') order by k.rolle, k.name`),
|
|
pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, freitag, art, bezeichnung, netto, termin, status, rest, reihenfolge from zahlung order by reihenfolge, termin"),
|
|
// Sicherheitseinbehalte werden erst nach der Gewährleistung fällig und gehören nicht in den Bauablauf
|
|
pool.query(`select id, projekt_id, vorgang_id, bezug_art, bezug_tage, freitag, art, bezeichnung, netto, termin, status, automatisch from kosten
|
|
where besetzung_teil is distinct from 'einbehalt' 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.freitag, 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`),
|
|
pool.query(`select o.id, o.name, o.aktiv, o.leitung_kontakt_id, coalesce(array_agg(m.kontakt_id order by m.angelegt_am) filter (where m.kontakt_id is not null), '{}') as mitglieder
|
|
from kolonne o left join kolonne_mitglied m on m.kolonne_id = o.id group by o.id order by o.name`),
|
|
]);
|
|
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 mitgliederVon = new Map(kolonnen.rows.map((o) => [o.id as string, o.mitglieder as string[]]));
|
|
const bs = besetzungen.rows.map((b) => ({
|
|
...b,
|
|
kurz: b.kontakt_id ? kuerzel(b.rolle === "subunternehmer" && b.firma ? b.firma : b.name, b.rolle) : b.kolonne_id ? b.name : b.platzhalter,
|
|
anzeige: b.kontakt_id ? (b.firma && b.rolle === "subunternehmer" ? b.firma : b.name) : b.kolonne_id ? b.name : b.platzhalter,
|
|
// eine Kolonne: wer dazugehört (Personenfilter, Überschneidungen)
|
|
...(b.kolonne_id ? { mitglieder: mitgliederVon.get(b.kolonne_id) ?? [] } : {}),
|
|
}));
|
|
const anzeige = new Map<string, string>(leute.rows.map((k) => [k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name]));
|
|
for (const b of bs) { const w = wer(b); if (w && !anzeige.has(w)) anzeige.set(w, b.anzeige); }
|
|
// Überschneidungen je Person: auch wer über eine Kolonne eingeteilt ist
|
|
const jePerson = [...bs, ...kap.besetzungen.filter((b) => b.kontakt_id).map((b) => ({ ...b, freigegeben: true }))];
|
|
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, jePerson, woche).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
|
|
kolonnen: kolonnen.rows,
|
|
arbeitstage: woche.tage,
|
|
team,
|
|
auslastung: team_auslastung,
|
|
// Abwesenheiten im Terminplan (Henning, 26.10.2026): Urlaub, krank, Schule usw. von Team und Subunternehmern, ohne abgelehnte
|
|
abwesenheiten: kap.personal.abwesenheiten.filter((a) => a.status !== "abgelehnt" && a.bis >= ab)
|
|
.map((a) => ({ id: a.id, kontakt_id: a.kontakt_id, art: a.art, von: a.von, bis: a.bis, status: a.status, halbtag: !!a.halbtag, stunden: a.stunden ?? null })),
|
|
};
|
|
}
|