diff --git a/CHANGELOG.md b/CHANGELOG.md index 9808933..af0b1b2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.12.0 + +- Dauer aus Stunden und Besetzung (T15): Im Besetzungsfenster eines Vorgangs trägst du die Arbeitsstunden ein. Mit „Dauer aus Stunden und Besetzung berechnen“ rechnet das Programm die Dauer aus der Zeit, die die Eingeteilten wirklich haben: Arbeitszeitmodell, genehmigter Urlaub, Krankheit und Feiertage zählen mit, der Freitag bleibt Reserve. Mehr Leute machen den Vorgang kürzer, Teilzeit oder Urlaub länger; Nachfolger rücken mit. Berechnete Dauern tragen ein ⚙ in der Spalte Dauer. +- Wer die Dauer von Hand ändert (Zahl eintragen oder Balken ziehen), legt sie fest. Weicht die Rechnung ab, steht sie in Klammern daneben, z. B. „6 Tage (4)“. +- Deine bestehenden Vorgänge behalten ihre Dauer (alle „fest“), damit sich dein Plan nicht von selbst verschiebt. Neue Vorgänge rechnen, sobald Stunden und Besetzung da sind. +- Auslastung (T16): ganz unten im Terminplan je Woche die eingeplanten gegen die verfügbaren Stunden des Teams, rot bei Überplanung, grau schraffiert bei Leerlauf; mit dem Personenfilter für diese Person. Die Einzelheiten je Person stehen im Tooltip. Tage, an denen nicht alle Eingeteilten da sind, sind im Balken heller. + ## 0.11.0 - Urlaubsantrag (M10): Mitarbeiter haben am Handy den neuen Reiter „Urlaub“ mit Resturlaub und ihren Anträgen. Beim Beantragen sehen sie sofort, wie viele Urlaubstage das sind, was danach übrig bleibt und ob sie in der Zeit auf einer Baustelle eingeteilt sind. Ein Antrag lässt sich zurückziehen, solange nicht entschieden ist. diff --git a/demo/kern.ts b/demo/kern.ts index 9982d7b..95142c4 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -11,12 +11,14 @@ import m006 from "../src/server/migrations/006_zahlungsplan_automatisch.sql"; import m007 from "../src/server/migrations/007_anmeldung.sql"; import m008 from "../src/server/migrations/008_personal.sql"; import m009 from "../src/server/migrations/009_zeiterfassung.sql"; +import m010 from "../src/server/migrations/010_dauer_aus_besetzung.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], ["005_projektseite_kategorien.sql", m005], ["006_zahlungsplan_automatisch.sql", m006], ["007_anmeldung.sql", m007], ["008_personal.sql", m008], ["009_zeiterfassung.sql", m009], + ["010_dauer_aus_besetzung.sql", m010], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/package.json b/package.json index 9e11f12..b8ef0a6 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.11.0", + "version": "0.12.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/kapazitaet.ts b/src/domain/kapazitaet.ts new file mode 100644 index 0000000..466cab0 --- /dev/null +++ b/src/domain/kapazitaet.ts @@ -0,0 +1,123 @@ +// T15: Dauer eines Vorgangs aus seinen Stunden und der tatsächlich verfügbaren Zeit der eingeteilten Personen +// (Arbeitszeitmodell M8, Abwesenheiten M4, Feiertage). T16: Auslastung je Woche, geplant gegen verfügbar. +// Geplant wird im Firmenkalender (Mo–Do); der Freitag bleibt Reserve und zählt nicht mit. + +import { type Datum, montagDerWoche, plusTage } from "./datum.js"; +import { type Arbeitswoche, feiertag, istArbeitstag, naechsterArbeitstag } from "./kalender.js"; +import { type Abwesenheit, type Modell, abwesendStunden, sollStunden, wirksam } from "./personal.js"; + +export interface KapBesetzung { + vorgang_id: string; + kontakt_id?: string | null; + platzhalter?: string | null; + personen: number; +} + +export interface Personaldaten { + modelle: Modell[]; + abwesenheiten: Abwesenheit[]; + stundenProTag: number; +} + +const EPS = 1e-9; + +/** Freie Stunden einer Person an einem Tag: Soll laut Modell (Feiertag 0) minus genehmigte Abwesenheiten */ +export function freiAm(p: Personaldaten, kontaktId: string, d: Datum): number { + const soll = sollStunden(p.modelle, kontaktId, d, p.stundenProTag); + if (soll <= 0) return 0; + let weg = 0; + for (const a of p.abwesenheiten) if (a.kontakt_id === kontaktId && wirksam(a) && a.von <= d && a.bis >= d) weg += abwesendStunden(a, soll); + return Math.max(0, soll - weg); +} + +/** Stunden, die eine Besetzung an einem Tag leistet: voll ohne Abwesenheiten, frei mit. Platzhalter rechnen mit Stunden pro Tag. */ +export function leistung(p: Personaldaten, b: Pick, d: Datum): { voll: number; frei: number } { + const n = Number(b.personen) > 0 ? Number(b.personen) : 1; + if (!b.kontakt_id) { + const h = feiertag(d) ? 0 : p.stundenProTag * n; + return { voll: h, frei: h }; + } + return { voll: sollStunden(p.modelle, b.kontakt_id, d, p.stundenProTag) * n, frei: freiAm(p, b.kontakt_id, d) * n }; +} + +/** Höchstens so viele Arbeitstage wird gesucht; wer länger nicht verfügbar ist, bekommt keine berechnete Dauer */ +const MAX_TAGE = 260; + +/** + * Arbeitstage, bis die Stunden geleistet sind. Tage ohne Kapazität (Urlaub aller Eingeteilten) liegen im Balken + * und zählen mit. Der letzte Tag zählt halb, wenn höchstens die Hälfte gebraucht wird. undefined ohne Kapazität. + */ +export function dauerAusKapazitaet(start: Datum, stunden: number, kapazitaet: (d: Datum) => number, woche: Arbeitswoche): number | undefined { + if (!(stunden > 0)) return undefined; + let rest = stunden; + let d = naechsterArbeitstag(start, woche); + for (let n = 0; n < MAX_TAGE; n++) { + const k = kapazitaet(d); + if (k > EPS) { + if (rest <= k + EPS) return n + (rest / k <= 0.5 + EPS ? 0.5 : 1); + rest -= k; + } + d = naechsterArbeitstag(plusTage(d, 1), woche); + } + return undefined; +} + +/** Dauer eines Vorgangs nach seiner Besetzung; undefined ohne Stunden oder ohne Besetzung */ +export function dauerNachBesetzung(v: { id: string; start: Datum; stunden?: number | null }, besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): number | undefined { + const bs = besetzungen.filter((b) => b.vorgang_id === v.id); + if (!bs.length || !(Number(v.stunden) > 0)) return undefined; + return dauerAusKapazitaet(v.start, Number(v.stunden), (d) => bs.reduce((s, b) => s + leistung(p, b, d).frei, 0), woche); +} + +/** Tage im Vorgang, an denen die Besetzung nicht voll da ist (Balken heller) */ +export function reduzierteTage(v: { id: string; anfang: Datum; ende: Datum }, besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): Datum[] { + const bs = besetzungen.filter((b) => b.vorgang_id === v.id && b.kontakt_id); + if (!bs.length) return []; + const aus: Datum[] = []; + for (let d = v.anfang; d <= v.ende; d = plusTage(d, 1)) { + if (!istArbeitstag(d, woche)) continue; + let voll = 0, frei = 0; + for (const b of bs) { const l = leistung(p, b, d); voll += l.voll; frei += l.frei; } + if (frei < voll - EPS) aus.push(d); + } + return aus; +} + +export interface Woche { + /** Montag */ + ab: Datum; + geplant: number; + verfuegbar: number; + personen: { kontakt_id: string; geplant: number; verfuegbar: number }[]; +} + +/** + * T16: je Woche die Stunden, für die das Team eingeplant ist (je Vorgang und Tag das Soll der Person, Urlaub nicht + * abgezogen, damit Einplanung im Urlaub als Überplanung auffällt), gegen die verfügbaren Stunden (Urlaub abgezogen). + */ +export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: { id: string; anfang: Datum; ende: Datum; dauer: number }[], + besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): Woche[] { + const imTeam = new Set(team); + const eigene = besetzungen.filter((b) => b.kontakt_id && imTeam.has(b.kontakt_id)); + const vById = new Map(vorgaenge.filter((v) => Number(v.dauer) > 0).map((v) => [v.id, v])); + const wochen = new Map(); + for (let d = von; d <= bis; d = plusTage(d, 1)) { + if (!istArbeitstag(d, woche)) continue; + const ab = montagDerWoche(d); + let w = wochen.get(ab); + if (!w) wochen.set(ab, (w = { ab, geplant: 0, verfuegbar: 0, personen: team.map((kontakt_id) => ({ kontakt_id, geplant: 0, verfuegbar: 0 })) })); + for (const pers of w.personen) { + const f = freiAm(p, pers.kontakt_id, d); + pers.verfuegbar += f; + w.verfuegbar += f; + } + for (const b of eigene) { + const v = vById.get(b.vorgang_id); + if (!v || v.anfang > d || v.ende < d) continue; + const h = sollStunden(p.modelle, b.kontakt_id!, d, p.stundenProTag) * (Number(b.personen) > 0 ? Number(b.personen) : 1); + w.personen.find((x) => x.kontakt_id === b.kontakt_id)!.geplant += h; + w.geplant += h; + } + } + return [...wochen.values()]; +} diff --git a/src/domain/terminplan.ts b/src/domain/terminplan.ts index c03dcb4..4095c5f 100644 --- a/src/domain/terminplan.ts +++ b/src/domain/terminplan.ts @@ -125,25 +125,36 @@ function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorga export interface Ergebnis { /** neuer Start je verschobenem Vorgang */ starts: Map; + /** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */ + dauern: Map; } /** * 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). + * `dauerFuer` liefert für Vorgänge ohne feste Dauer die Dauer am jeweiligen Start (T15); Start und Dauer + * hängen bei EE und AE voneinander ab, deshalb wird bis zu dreimal abgeglichen. */ -export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set = new Set()): Ergebnis { +export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set = new Set(), + dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis { const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }])); const starts = new Map(); + const dauern = new Map(); 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))) { + for (let runde = 0; runde < 3; runde++) { + const d = dauerFuer?.(x); + if (d !== undefined && d !== Number(x.dauer)) { + x.dauer = d; + dauern.set(v.id, d); + } + const f = fruehesterStart(x, stand, links, woche); + const a = anfang(x, woche); + if (!f || !(f > a || (f < a && eng.has(v.id)))) break; x.start = f; starts.set(v.id, f); } } - return { starts }; + return { starts, dauern }; } diff --git a/src/server/app.ts b/src/server/app.ts index 46e12bd..1379a18 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -148,7 +148,8 @@ export async function baueApp(o: Optionen): Promise { }); // Ä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(c: Client, tabelle: string, fn: () => Promise, bewegt: string[] = [], zahlungVon?: string): Promise { const e = await ladeEinstellungen(); @@ -159,7 +160,7 @@ export async function baueApp(o: Optionen): Promise { } 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 { const { id } = IdParam.parse(req.params); const daten = teil.parse(req.body) as Record; 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 { 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 { 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 diff --git a/src/server/migrations/010_dauer_aus_besetzung.sql b/src/server/migrations/010_dauer_aus_besetzung.sql new file mode 100644 index 0000000..4f12904 --- /dev/null +++ b/src/server/migrations/010_dauer_aus_besetzung.sql @@ -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; diff --git a/src/server/stand.ts b/src/server/stand.ts index db6cdcc..158d897 100644 --- a/src/server/stand.ts +++ b/src/server/stand.ts @@ -33,7 +33,9 @@ export async function speichereStand(c: Client, s: Stand): Promise( "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)]); } diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 3fac3e2..1d8dc44 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -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(), }), }, { diff --git a/src/server/terminplan.ts b/src/server/terminplan.ts index eb1b27b..8b475de 100644 --- a/src/server/terminplan.ts +++ b/src/server/terminplan.ts @@ -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("select id, start, dauer from vorgang"), + 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[] = [], + c: Client, woche: Arbeitswoche, aenderung: () => Promise, 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( 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, }; } diff --git a/src/server/urlaub.ts b/src/server/urlaub.ts index f68acbb..28f69ec 100644 --- a/src/server/urlaub.ts +++ b/src/server/urlaub.ts @@ -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; 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; }); }); } diff --git a/src/server/v70import.ts b/src/server/v70import.ts index 5e5f7c3..3d31035 100644 --- a/src/server/v70import.ts +++ b/src/server/v70import.ts @@ -40,7 +40,7 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise 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 }); diff --git a/src/web/gantt.ts b/src/web/gantt.ts index d4a3c5f..cc3ef0d 100644 --- a/src/web/gantt.ts +++ b/src/web/gantt.ts @@ -30,6 +30,8 @@ interface Plan { ueberschneidungen: Zeile[]; zahlungen: Zeile[]; arbeitstage: number[]; + team?: string[]; + auslastung?: { ab: Datum; geplant: number; verfuegbar: number; personen: { kontakt_id: string; geplant: number; verfuegbar: number }[] }[]; } const ZOOM: Record = { tag: 24, woche: 10, monat: 4 }; @@ -161,6 +163,20 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise${esc(b.kurz)}${Number(b.personen) !== 1 ? ` ×${String(b.personen).replace(".", ",")}` : ""}`).join(""); const imKonflikt = new Set(plan.ueberschneidungen.flatMap((u) => [u.vorgang_a, u.vorgang_b])); + // T15: berechnete Dauer markieren; bei fester Dauer die Abweichung zur Besetzung zeigen + const zahlText = (n: number) => String(n).replace(".", ","); + const dauerHinweis = (o: Zeile) => { + if (o.dauer_besetzung == null || Number(o.dauer) === 0) return ""; + if (!o.dauer_fest) return ' ⚙'; + return Math.ceil(o.dauer_besetzung) !== Math.ceil(o.dauer) ? ` (${zahlText(o.dauer_besetzung)})` : ""; + }; + const dauerTitel = (o: Zeile) => o.dauer_besetzung == null ? "Dauer in Arbeitstagen, 0 = Meilenstein" + : !o.dauer_fest ? `Aus ${zahlText(Number(o.stunden))} Std. und der Besetzung berechnet: ${zahlText(o.dauer_besetzung)} Arbeitstage. Eine eigene Zahl legt die Dauer fest.` + : `Dauer fest. Nach ${zahlText(Number(o.stunden))} Std. und der Besetzung wären es ${zahlText(o.dauer_besetzung)} Arbeitstage.`; + // T16: Tage mit weniger Leuten als eingeteilt heller + const reduziertHtml = (o: Zeile, links0: number) => (o.reduziert ?? []).map((d: Datum) => + ``).join(""); + // Zeilen aufbauen type Reihe = { art: "p" | "a" | "v"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum }; const reihen: Reihe[] = []; @@ -262,7 +278,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise${inhaltHtml}`; links = `${nr}${zelle("name", "text", esc(o.name), "Bezeichnung")} - ${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)), "Dauer in Arbeitstagen, 0 = Meilenstein")} + ${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)) + dauerHinweis(o), dauerTitel(o))} ${zelle("vg", "vg", esc(vorgaengerText(linksVon(o.id), zeilenNr)), "Vorgänger: Zeilennummer, z. B. 5 oder 5AA+2")} ${zelle("start", "zahl", tabellenDatum(o.anfang), "Anfang")}${zelle("ende", "zahl", tabellenDatum(o.ende), "Ende")} ${leuteHtml(o.id) || '+ Personal'}`; @@ -271,13 +287,31 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise` + beschriftung(links0 + W / 2, links0 + W / 2 + 6, esc(o.name), undefined, o.anfang, leute) - : `
` + : `
${reduziertHtml(o, links0)}
` + beschriftung(links0, links0 + breite, esc(o.name), o.anfang, o.ende, leute); } return `
${balken}
`; }).join(""); + // T16: Auslastung des eigenen Teams je Woche unter dem Plan; mit Personenfilter nur diese Person + const team = plan.team ?? []; + const nameVon = new Map(plan.leute.map((k) => [k.id, k.name])); + const nurPerson = filter && team.includes(filter) ? filter : ""; + const auslastungHtml = team.length && reihen.length ? (() => { + const std = (n: number) => zahlText(Math.round(n * 10) / 10); + const bloecke = (plan.auslastung ?? []).filter((w) => w.ab >= von && w.ab <= bis).map((w) => { + const z = nurPerson ? w.personen.find((p) => p.kontakt_id === nurPerson)! : w; + const klasse = z.geplant > z.verfuegbar + 0.01 ? "ueber" : z.verfuegbar - z.geplant >= 8 ? "leer" : "voll"; + const breite = woche.tage.length * W; + const titel = `KW ${kalenderwoche(w.ab)}: ${std(z.geplant)} von ${std(z.verfuegbar)} Std. eingeplant` + + (nurPerson ? "" : w.personen.map((p) => `\n${nameVon.get(p.kontakt_id) ?? ""}: ${std(p.geplant)} von ${std(p.verfuegbar)}${p.geplant > p.verfuegbar + 0.01 ? " (überplant)" : ""}`).join("")); + return `
${breite >= 58 ? `${std(z.geplant)}/${std(z.verfuegbar)}` : ""}
`; + }).join(""); + return `
+
${bloecke}
`; + })() : ""; + // Pfeile für die Verknüpfungen const pfeile = plan.verknuepfungen.map((k) => { const a = plan.vorgaenge.find((v) => v.id === k.vorgaenger_id); @@ -295,7 +329,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise = { ...(window.innerWidth < 1400 ? BREITE_KLEIN : BREITE_GROSS), ...merke>>("gantt-spalten") }; const summeBreiten = () => SPALTEN.reduce((s, k) => s + breiten[k], 0); - const hoehe = reihen.length * ZEILE; + const hoehe = (reihen.length + (auslastungHtml ? 1 : 0)) * ZEILE; const rahmen = document.createElement("div"); rahmen.className = "g-rahmen"; for (const k of SPALTEN) rahmen.style.setProperty(`--sp-${k}`, `${breiten[k]}px`); @@ -306,7 +340,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise
${schatten}
${pfeile} - ${zeilenHtml} + ${zeilenHtml}${auslastungHtml} ${reihen.length ? "" : '

Noch keine Projekte im Terminplan.

'} `; @@ -582,8 +616,17 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise { const liste = besetzungVon(v.id); - huelle.innerHTML = `

Besetzung: ${esc(v.name)}

-

${formatDatum(v.anfang)} – ${formatDatum(v.ende)}

+ const vv = plan.vorgaenge.find((x) => x.id === v.id) ?? v; + const zahl = (n: number) => String(n).replace(".", ","); + // T15: Stunden und Besetzung ergeben die Dauer + const ergebnis = vv.dauer_besetzung != null + ? `Nach Stunden und Besetzung ${dauerText(vv.dauer_besetzung).replace(".", ",")}${vv.dauer_fest ? `, eingetragen ${dauerText(Number(vv.dauer)).replace(".", ",")}` : ""}.` + : Number(vv.stunden) > 0 ? "Sobald jemand eingeteilt ist, ergibt sich daraus die Dauer." : "Ohne Stunden bleibt die Dauer so, wie du sie einträgst."; + huelle.innerHTML = `

Besetzung: ${esc(vv.name)}

+

${formatDatum(vv.anfang)} – ${formatDatum(vv.ende)}

+
+ +

${ergebnis} Urlaub, Teilzeit und Feiertage zählen mit, der Freitag nicht.

${liste.length ? `${liste.map((b) => ` @@ -624,7 +667,19 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise { const t = ev.target as HTMLInputElement; - if (t.dataset.frei) { await api(`besetzungen/${t.dataset.frei}`, "PATCH", { freigegeben: t.checked }); neu(); } + try { + if (t.dataset.frei) { await api(`besetzungen/${t.dataset.frei}`, "PATCH", { freigegeben: t.checked }); await neu(); } + if (t.id === "b-auto") { await api(`vorgaenge/${v.id}`, "PATCH", { dauer_fest: !t.checked }); await neu(); } + if (t.id === "b-stunden") { + const roh = t.value.trim().replace(",", "."); + const stunden = roh ? Number(roh) : null; + if (stunden !== null && !(stunden >= 0)) throw new Error("Die Stunden sind eine Zahl, z. B. 32."); + await api(`vorgaenge/${v.id}`, "PATCH", { stunden }); + await neu(); + } + } catch (e) { + huelle.querySelector("#b-fehler")!.textContent = (e as Error).message; + } }; } diff --git a/src/web/styles.css b/src/web/styles.css index 520ac4a..ca63b49 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -549,3 +549,16 @@ button.haupt.gross { padding: 14px 22px; font-size: 17px; flex: 1; } #seitenleiste { gap: 2px; padding: 8px 6px; } #reiter button { padding: 8px 6px; gap: 5px; } } +/* T15/T16: berechnete Dauer, Tage mit weniger Leuten, Auslastung je Woche */ +.g-zeile .d-auto { color: var(--akzent); font-size: 11px; } +.g-zeile .d-abw { color: var(--warn); font-size: 11.5px; } +.balken .reduziert { position: absolute; top: 0; bottom: 0; background: var(--fl); opacity: 0.55; pointer-events: none; } +.g-zeile.auslastung .g-links { background: var(--bg); } +.g-zeile.auslastung .name { font-weight: 600; } +.g-zeile.auslastung .name small { font-weight: 400; color: var(--leise); margin-left: 4px; } +.last { position: absolute; top: 9px; height: 24px; border-radius: 4px; font-size: 11px; line-height: 24px; text-align: center; white-space: nowrap; overflow: hidden; pointer-events: auto; cursor: default; } +.last.voll { background: var(--gut-bg); color: var(--gut-text); } +.last.ueber { background: var(--warnung-bg); color: var(--warnung-text); border: 1px solid var(--warn); } +.last.leer { background: repeating-linear-gradient(135deg, rgb(120 130 150 / 0.18) 0 4px, transparent 4px 8px); color: var(--leise); border: 1px solid var(--linie); } +.dialog .b-dauer { border-bottom: 1px solid var(--linie); padding-bottom: 10px; margin-bottom: 10px; } +.dialog .b-dauer .schalter { margin-top: 8px; color: var(--text); } diff --git a/test/api.test.ts b/test/api.test.ts index f0d1143..97c58a9 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -401,6 +401,15 @@ describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => expect(v.statusCode, v.body).toBe(201); expect(v.json().nummer).toBeGreaterThan(Math.max(...vorher.daten.vorgaenge.map((x: { nummer: number }) => x.nummer))); }); + + it("Sicherung von vor 0.12: Vorgänge behalten ihre Dauer (T15)", async () => { + const vorher = (await app.inject("/api/export")).json(); + vorher.daten.vorgaenge = vorher.daten.vorgaenge.map(({ dauer_fest, ...v }: { dauer_fest: boolean }) => v); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(201); + expect((await pool.query("select bool_and(dauer_fest) as alle from vorgang")).rows[0].alle).toBe(true); + }); }); describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { @@ -696,6 +705,41 @@ describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { expect((await als(jj, "DELETE", `/api/ich/urlaub/${z.json().id}`)).statusCode).toBe(204); }); + it("Dauer aus Stunden und Besetzung, Auslastung im Terminplan (T15, T16)", async () => { + const tp = (await als(inhaber, "GET", "/api/terminplan")).json(); + const abschnitt = tp.vorgaenge.find((v: { name: string }) => v.name === "Abbund").abschnitt_id; + // ein Montag gut vier Monate voraus, die Woche ohne Feiertag + const plus = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10); + let start = plus(new Date().toISOString().slice(0, 10), 120); + while (new Date(`${start}T00:00:00Z`).getUTCDay() !== 1 || [0, 1, 2, 3, 7].some((i) => feiertag(plus(start, i)))) start = plus(start, 1); + const v = (await als(inhaber, "POST", "/api/vorgaenge", { abschnitt_id: abschnitt, name: "Dach decken", start, dauer: 1, stunden: 32 })).json(); + expect(v.dauer_fest).toBe(false); + const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; + expect((await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, kontakt_id: jan })).statusCode).toBe(201); + const lies = async () => (await als(inhaber, "GET", "/api/terminplan")).json().vorgaenge.find((x: { id: string }) => x.id === v.id); + expect(await lies()).toMatchObject({ dauer: 4, dauer_besetzung: 4, ende: plus(start, 3) }); // Jan Mo–Do je 8 Std. + // zweite Person: halb so lang + const kolonne = (await als(inhaber, "POST", "/api/besetzungen", { vorgang_id: v.id, platzhalter: "Helfer", personen: 1 })).json(); + expect((await lies()).dauer).toBe(2); + await als(inhaber, "DELETE", `/api/besetzungen/${kolonne.id}`); + // genehmigter Urlaub am Dienstag: einen Tag länger, Balken an dem Tag heller + const u = (await als(inhaber, "POST", "/api/abwesenheiten", { kontakt_id: jan, art: "frei", von: plus(start, 1), bis: plus(start, 1), status: "genehmigt" })).json(); + expect(await lies()).toMatchObject({ dauer: 5, reduziert: [plus(start, 1)] }); + await als(inhaber, "DELETE", `/api/abwesenheiten/${u.id}`); + expect((await lies()).dauer).toBe(4); + // von Hand geändert: Dauer fest, die Berechnung bleibt als Abweichung sichtbar + const fest = await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer: 6 }); + expect(fest.json()).toMatchObject({ dauer: 6, dauer_fest: true }); + expect(await lies()).toMatchObject({ dauer: 6, dauer_besetzung: 4, dauer_fest: true }); + expect((await als(inhaber, "PATCH", `/api/vorgaenge/${v.id}`, { dauer_fest: false })).statusCode).toBe(200); + expect((await lies()).dauer).toBe(4); + // Auslastung: Jan steht im Team, die Woche des Vorgangs zählt seine 32 Stunden als geplant + const plan = (await als(inhaber, "GET", "/api/terminplan")).json(); + expect(plan.team).toContain(jan); + const w = plan.auslastung.find((x: { ab: string }) => x.ab === start); + expect(w.personen.find((x: { kontakt_id: string }) => x.kontakt_id === jan).geplant).toBe(32); + }); + it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => { const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; diff --git a/test/kapazitaet.test.ts b/test/kapazitaet.test.ts new file mode 100644 index 0000000..b43a521 --- /dev/null +++ b/test/kapazitaet.test.ts @@ -0,0 +1,61 @@ +import { describe, expect, it } from "vitest"; +import { auslastung, dauerAusKapazitaet, dauerNachBesetzung, freiAm, reduzierteTage } from "../src/domain/kapazitaet.js"; +import { planeNeu } from "../src/domain/terminplan.js"; +import type { Abwesenheit, Modell } from "../src/domain/personal.js"; + +const W = { tage: [1, 2, 3, 4] }; +const modelle: Modell[] = [ + { kontakt_id: "jan", gueltig_ab: "2026-01-01", stunden: [8, 8, 8, 8, 6.5, 0, 0] }, + { kontakt_id: "tim", gueltig_ab: "2026-01-01", stunden: [4, 4, 4, 4, 0, 0, 0] }, +]; +const urlaub: Abwesenheit[] = [ + { kontakt_id: "jan", art: "urlaub", von: "2026-11-11", bis: "2026-11-11", status: "genehmigt" }, + { kontakt_id: "jan", art: "urlaub", von: "2026-11-12", bis: "2026-11-12", status: "beantragt" }, +]; +const p = { modelle, abwesenheiten: urlaub, stundenProTag: 8 }; + +describe("Dauer aus Stunden und Besetzung (T15)", () => { + it("Kapazität je Tag: Feiertag, Urlaub, beantragter Urlaub zählt nicht", () => { + expect(freiAm(p, "jan", "2026-11-10")).toBe(8); + expect(freiAm(p, "jan", "2026-11-11")).toBe(0); + expect(freiAm(p, "jan", "2026-11-12")).toBe(8); + expect(freiAm(p, "jan", "2026-12-25")).toBe(0); + expect(freiAm(p, "tim", "2026-11-10")).toBe(4); + }); + + it("zählt Arbeitstage Mo–Do, letzter Tag halb oder ganz", () => { + expect(dauerAusKapazitaet("2026-11-02", 40, () => 8, W)).toBe(5); + expect(dauerAusKapazitaet("2026-11-02", 36, () => 8, W)).toBe(4.5); + expect(dauerAusKapazitaet("2026-11-02", 37, () => 8, W)).toBe(5); + expect(dauerAusKapazitaet("2026-11-02", 0, () => 8, W)).toBeUndefined(); + expect(dauerAusKapazitaet("2026-11-02", 8, () => 0, W)).toBeUndefined(); + }); + + it("mehr Personen machen kürzer, Teilzeit und Urlaub länger", () => { + const v = { id: "v", start: "2026-11-09", stunden: 40 }; + expect(dauerNachBesetzung(v, [{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }], p, W)).toBe(6); // Mi 11.11. Urlaub + expect(dauerNachBesetzung(v, [{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }, { vorgang_id: "v", kontakt_id: "tim", personen: 1 }], p, W)).toBe(4); + expect(dauerNachBesetzung(v, [{ vorgang_id: "v", platzhalter: "Kolonne", personen: 2 }], p, W)).toBe(2.5); + expect(dauerNachBesetzung(v, [], p, W)).toBeUndefined(); + expect(reduzierteTage({ id: "v", anfang: "2026-11-09", ende: "2026-11-17" }, [{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }], p, W)).toEqual(["2026-11-11"]); + }); + + it("Neuplanung: berechnete Dauer schiebt den Nachfolger", () => { + const vorgaenge = [{ id: "a", start: "2026-11-09", dauer: 2 }, { id: "b", start: "2026-11-11", dauer: 1 }]; + const links = [{ vorgang_id: "b", vorgaenger_id: "a", art: "EA" as const, verzoegerung: 0 }]; + const r = planeNeu(vorgaenge, links, W, new Set(), (v) => (v.id === "a" ? dauerNachBesetzung({ id: "a", start: v.start, stunden: 40 }, [{ vorgang_id: "a", kontakt_id: "jan", personen: 1 }], p, W) : undefined)); + expect(r.dauern.get("a")).toBe(6); + expect(r.starts.get("b")).toBe("2026-11-18"); + }); +}); + +describe("Auslastung je Woche (T16)", () => { + it("geplant gegen verfügbar; Einplanung im Urlaub ist Überplanung", () => { + const w = auslastung("2026-11-09", "2026-11-15", ["jan", "tim"], + [{ id: "v", anfang: "2026-11-09", ende: "2026-11-12", dauer: 4 }, { id: "x", anfang: "2026-11-12", ende: "2026-11-12", dauer: 1 }], + [{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }, { vorgang_id: "x", kontakt_id: "jan", personen: 1 }], p, W); + expect(w).toHaveLength(1); + expect(w[0]).toMatchObject({ ab: "2026-11-09", geplant: 40, verfuegbar: 24 + 16 }); + expect(w[0]!.personen).toEqual([{ kontakt_id: "jan", geplant: 40, verfuegbar: 24 }, { kontakt_id: "tim", geplant: 0, verfuegbar: 16 }]); + }); +});
${esc(b.anzeige)}${b.rolle ? ` ${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}` : ""} ${String(b.personen).replace(".", ",")} P. ${b.rolle === "mitarbeiter" ? "" : ``}