Terminplan: Dauer aus Stunden und Besetzung, Auslastung je Woche (0.12.0)
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:
123
src/domain/kapazitaet.ts
Normal file
123
src/domain/kapazitaet.ts
Normal 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()];
|
||||
}
|
||||
@@ -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 };
|
||||
}
|
||||
|
||||
@@ -148,7 +148,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
});
|
||||
|
||||
// Ä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<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = [], zahlungVon?: string): Promise<T> {
|
||||
const e = await ladeEinstellungen();
|
||||
@@ -159,7 +160,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
}
|
||||
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<FastifyInstance> {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const daten = teil.parse(req.body) as Record<string, unknown>;
|
||||
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<FastifyInstance> {
|
||||
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<FastifyInstance> {
|
||||
|
||||
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
|
||||
|
||||
5
src/server/migrations/010_dauer_aus_besetzung.sql
Normal file
5
src/server/migrations/010_dauer_aus_besetzung.sql
Normal file
@@ -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;
|
||||
@@ -33,7 +33,9 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
|
||||
// so passt eine ältere Sicherung auch nach einer Migration
|
||||
const vorhanden = new Set((await c.query<{ column_name: string }>(
|
||||
"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)]);
|
||||
}
|
||||
|
||||
@@ -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(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
|
||||
@@ -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<PlanVorgang>("select id, start, dauer from vorgang"),
|
||||
c.query<StandVorgang>("select id, start, dauer, stunden, dauer_fest 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([
|
||||
c.query<KapBesetzung>("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<T>(
|
||||
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [],
|
||||
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, 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<T>(
|
||||
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,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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<Pool, "query">;
|
||||
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;
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -40,7 +40,7 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
|
||||
const hoechste = Math.max(1000, ...u.vorgaenge.map((v) => 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 });
|
||||
|
||||
@@ -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<string, number> = { tag: 24, woche: 10, monat: 4 };
|
||||
@@ -161,6 +163,20 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
`<span class="person${b.freigegeben ? "" : " vorgemerkt"}" title="${esc(b.anzeige)}${Number(b.personen) !== 1 ? `, ${String(b.personen).replace(".", ",")} Personen` : ""}${b.freigegeben ? "" : " (vorgemerkt, noch nicht freigegeben)"}">${esc(b.kurz)}${Number(b.personen) !== 1 ? ` ×${String(b.personen).replace(".", ",")}` : ""}</span>`).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 ' <small class="d-auto" aria-label="berechnet">⚙</small>';
|
||||
return Math.ceil(o.dauer_besetzung) !== Math.ceil(o.dauer) ? ` <small class="d-abw">(${zahlText(o.dauer_besetzung)})</small>` : "";
|
||||
};
|
||||
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) =>
|
||||
`<i class="reduziert" style="left:${x(d) - links0}px;width:${W}px" title="${formatDatum(d)}: nicht alle Eingeteilten verfügbar"></i>`).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<void
|
||||
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" title="${titel}">${inhaltHtml}</span>`;
|
||||
links = `${nr}<span class="name ebene2">${zelle("name", "text", esc(o.name), "Bezeichnung")}
|
||||
<span class="aktionen"><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
|
||||
${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")}
|
||||
<span class="leute" data-besetzung="${o.id}" title="Besetzung bearbeiten">${leuteHtml(o.id) || '<span class="leer">+ Personal</span>'}</span>`;
|
||||
@@ -271,13 +287,31 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
balken = ms
|
||||
? `<div class="balken meilenstein" data-bar="${o.id}" style="left:${links0 + W / 2 - 6}px" title="${esc(o.name)} · ${formatDatum(o.anfang)}"></div>`
|
||||
+ beschriftung(links0 + W / 2, links0 + W / 2 + 6, esc(o.name), undefined, o.anfang, leute)
|
||||
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}" data-bar="${o.id}" style="left:${links0}px;width:${breite}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${dauerText(Math.ceil(o.dauer))}"><i class="griff-rechts" data-dauer="${o.id}"></i></div>`
|
||||
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}" data-bar="${o.id}" style="left:${links0}px;width:${breite}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${dauerText(Math.ceil(o.dauer))}">${reduziertHtml(o, links0)}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`
|
||||
+ beschriftung(links0, links0 + breite, esc(o.name), o.anfang, o.ende, leute);
|
||||
}
|
||||
return `<div class="g-zeile ${r.art}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
|
||||
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
|
||||
}).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 `<div class="last ${klasse}" style="left:${x(w.ab)}px;width:${breite}px" title="${esc(titel)}">${breite >= 58 ? `${std(z.geplant)}/${std(z.verfuegbar)}` : ""}</div>`;
|
||||
}).join("");
|
||||
return `<div class="g-zeile auslastung" style="top:${reihen.length * ZEILE}px"><div class="g-links"><span class="nr"></span><span class="name ebene0" title="Stunden je Woche: eingeplant / verfügbar. Rot = überplant, grau = Leerlauf">Auslastung ${nurPerson ? esc(nameVon.get(nurPerson)) : "Team"} <small>Std./Woche</small></span></div></div>
|
||||
<div class="g-balken" style="top:${reihen.length * ZEILE}px">${bloecke}</div>`;
|
||||
})() : "";
|
||||
|
||||
// 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<void
|
||||
// Spaltenbreiten und Breite der Tabelle links (Trennleiste), beides gemerkt
|
||||
const breiten: Record<Spalte, number> = { ...(window.innerWidth < 1400 ? BREITE_KLEIN : BREITE_GROSS), ...merke<Partial<Record<Spalte, number>>>("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<void
|
||||
<div class="g-koerper" style="height:${hoehe}px">
|
||||
<div class="g-schatten" style="width:${tage * W}px">${schatten}</div>
|
||||
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
|
||||
${zeilenHtml}
|
||||
${zeilenHtml}${auslastungHtml}
|
||||
</div></div>
|
||||
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}</div>
|
||||
<div class="g-trenner" role="separator" aria-orientation="vertical" aria-label="Trennleiste zwischen Tabelle und Zeitplan" title="Ziehen: Spalten ein- oder ausblenden; Doppelklick: alle Spalten zeigen"></div>`;
|
||||
@@ -582,8 +616,17 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
const zeichne = () => {
|
||||
const liste = besetzungVon(v.id);
|
||||
huelle.innerHTML = `<div class="dialog besetzung"><h2>Besetzung: ${esc(v.name)}</h2>
|
||||
<p class="hinweis">${formatDatum(v.anfang)} – ${formatDatum(v.ende)}</p>
|
||||
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 = `<div class="dialog besetzung"><h2>Besetzung: ${esc(vv.name)}</h2>
|
||||
<p class="hinweis">${formatDatum(vv.anfang)} – ${formatDatum(vv.ende)}</p>
|
||||
<div class="b-dauer"><label for="b-stunden">Arbeitsstunden für diesen Vorgang</label><input id="b-stunden" inputmode="decimal" value="${vv.stunden != null ? zahl(Number(vv.stunden)) : ""}" placeholder="z. B. 32">
|
||||
<label class="schalter"><input type="checkbox" id="b-auto"${vv.dauer_fest ? "" : " checked"}> Dauer aus Stunden und Besetzung berechnen</label>
|
||||
<p class="hinweis">${ergebnis} Urlaub, Teilzeit und Feiertage zählen mit, der Freitag nicht.</p></div>
|
||||
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}</td>
|
||||
<td class="zahl">${String(b.personen).replace(".", ",")} P.</td>
|
||||
<td>${b.rolle === "mitarbeiter" ? "" : `<label class="schalter"><input type="checkbox" data-frei="${b.id}"${b.freigegeben ? " checked" : ""}> freigegeben</label>`}</td>
|
||||
@@ -624,7 +667,19 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
};
|
||||
huelle.onchange = async (ev) => {
|
||||
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;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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); }
|
||||
|
||||
Reference in New Issue
Block a user