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

123
src/domain/kapazitaet.ts Normal file
View File

@@ -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<KapBesetzung, "kontakt_id" | "personen">, 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<Datum, Woche>();
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()];
}

View File

@@ -125,25 +125,36 @@ function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorga
export interface Ergebnis {
/** neuer Start je verschobenem Vorgang */
starts: Map<string, Datum>;
/** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */
dauern: Map<string, number>;
}
/**
* 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<string> = new Set()): Ergebnis {
export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set<string> = new Set(),
dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis {
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
const starts = new Map<string, Datum>();
const dauern = new Map<string, number>();
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 };
}