Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
140 lines
7.0 KiB
TypeScript
140 lines
7.0 KiB
TypeScript
// 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, tagesAnteile, wocheVon } 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. Angefangene Tage zählen in Vierteln (Henning, 22.10.2026), aufgerundet. `teil`: so viel vom
|
||
* ersten Tag ist schon belegt. undefined ohne Kapazität.
|
||
*/
|
||
export function dauerAusKapazitaet(start: Datum, stunden: number, kapazitaet: (d: Datum) => number, woche: Arbeitswoche, teil = 0): number | undefined {
|
||
if (!(stunden > 0)) return undefined;
|
||
let rest = stunden;
|
||
let d = naechsterArbeitstag(start, woche);
|
||
let frei = 1 - teil;
|
||
let n = 0;
|
||
for (let i = 0; i < MAX_TAGE; i++) {
|
||
const k = kapazitaet(d) * frei;
|
||
if (k > EPS && rest <= k + EPS) return n + Math.max(0.25, Math.ceil((rest / kapazitaet(d)) * 4 - EPS) / 4);
|
||
if (k > EPS) rest -= k;
|
||
n += frei;
|
||
frei = 1;
|
||
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; start_teil?: number | null; stunden?: number | null; freitage?: Datum[] | 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;
|
||
const w = wocheVon(v, woche);
|
||
const teil = naechsterArbeitstag(v.start, w) === v.start ? Number(v.start_teil ?? 0) : 0;
|
||
return dauerAusKapazitaet(v.start, Number(v.stunden), (d) => bs.reduce((s, b) => s + leistung(p, b, d).frei, 0), w, teil);
|
||
}
|
||
|
||
/** Tage im Vorgang, an denen die Besetzung nicht voll da ist (Balken heller) */
|
||
export function reduzierteTage(v: { id: string; anfang: Datum; ende: Datum; freitage?: Datum[] | null }, besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): Datum[] {
|
||
const w = wocheVon(v, woche);
|
||
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, w)) 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).
|
||
* Ein freigegebener Freitag zählt nur für die Leute, die an diesem Vorgang eingeteilt sind, geplant und verfügbar.
|
||
*/
|
||
export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: { id: string; start?: Datum; start_teil?: number | null; anfang: Datum; ende: Datum; dauer: number; freitage?: Datum[] | null }[],
|
||
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]));
|
||
// Vierteltage: an jedem Tag zählt nur der Teil, den der Vorgang belegt
|
||
const anteile = new Map([...vById.values()].map((v) => [v.id, tagesAnteile(v.anfang, Number(v.dauer), wocheVon(v, woche), v.start === v.anfang ? Number(v.start_teil ?? 0) : 0)]));
|
||
const wochen = new Map<Datum, Woche>();
|
||
const extra = new Set(vorgaenge.flatMap((v) => v.freitage ?? []));
|
||
for (let d = von; d <= bis; d = plusTage(d, 1)) {
|
||
const firmentag = istArbeitstag(d, woche);
|
||
if (!firmentag && !extra.has(d)) continue;
|
||
// am freigegebenen Freitag nur die Vorgänge, die ihn freigegeben haben, und deren Leute
|
||
const dabei = firmentag ? null : new Set(eigene.filter((b) => vById.get(b.vorgang_id)?.freitage?.includes(d)).map((b) => b.kontakt_id!));
|
||
if (dabei && !dabei.size) 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) {
|
||
if (dabei && !dabei.has(pers.kontakt_id)) continue;
|
||
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;
|
||
if (!firmentag && !v.freitage?.includes(d)) continue;
|
||
const h = sollStunden(p.modelle, b.kontakt_id!, d, p.stundenProTag) * (Number(b.personen) > 0 ? Number(b.personen) : 1) * (anteile.get(v.id)!.get(d) ?? 0);
|
||
w.personen.find((x) => x.kontakt_id === b.kontakt_id)!.geplant += h;
|
||
w.geplant += h;
|
||
}
|
||
}
|
||
return [...wochen.values()];
|
||
}
|