Files
Betriebsf-hrungssoftware/src/server/urlaub.ts
Claude f3dd3678f6
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.36.0: Status Intern mit I-Nummern und Ordner 05 Intern, Eckdaten unten und einklappbar
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-24 05:49:21 +00:00

142 lines
8.6 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// M10: Urlaubsantrag. Mitarbeiter beantragen am Handy, Henning (oder das Büro) genehmigt oder lehnt mit einer Antwort ab.
// Beantragter Urlaub sperrt noch nichts; erst genehmigt zählt er in Verfügbarkeit, Soll und Stundenliste.
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
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}$/);
const heute = () => new Date().toISOString().slice(0, 10);
class Fehler extends Error {
constructor(public statusCode: number, nachricht: string) { super(nachricht); }
}
/** „12.–14.11.2026“ oder „12.11.2026“ */
export function zeitraumText(von: string, bis: string): string {
if (von === bis) return formatDatum(von);
const v = formatDatum(von), b = formatDatum(bis);
return v.slice(6) === b.slice(6) ? (v.slice(3, 5) === b.slice(3, 5) ? `${v.slice(0, 3)}–${b}` : `${v.slice(0, 6)}–${b}`) : `${v}–${b}`;
}
/** Vorgänge, für die jemand im Zeitraum eingeteilt ist; Mitarbeiter sehen nur freigegebene (E27) */
async function einsaetzeIm(c: Abfrage, kontaktId: string, von: string, bis: string, woche: { tage: number[] }, nurFreigegeben: boolean) {
const r = await c.query(`select v.id, v.name, v.start, v.start_teil, v.dauer, v.freitage, p.nummer, p.bezeichnung from besetzung_person b join vorgang v on v.id = b.vorgang_id
join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
where b.kontakt_id = $1 and ($2 or b.freigegeben) and p.status in ('auftrag', 'ausfuehrung', 'intern') and v.dauer > 0`, [kontaktId, !nurFreigegeben]);
return r.rows
.map((v) => ({ name: v.name, projekt: `${v.nummer} ${v.bezeichnung}`, anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }))
.filter((v) => v.anfang <= bis && v.ende >= von)
.sort((a, b) => (a.anfang < b.anfang ? -1 : 1));
}
/** Was ein Antrag bedeutet: Urlaubstage, Rest danach, Einsätze in der Zeit */
async function pruefe(pool: Pool, e: Einstellungen, kontaktId: string, a: { von: string; bis: string; halbtag: boolean; id?: string }, nurFreigegeben: boolean) {
const st = await ladePersonal(pool, kontaktId);
const jahr = jahrVon(a.von);
const antrag: Abwesenheit = { kontakt_id: kontaktId, art: "urlaub", von: a.von, bis: a.bis, halbtag: a.halbtag, status: "beantragt" };
let tage = 0;
for (let j = jahr; j <= jahrVon(a.bis); j++) tage += urlaubstage(antrag, st.modelle, j, e.stundenProTag);
// Rest im Jahr des Beginns, ohne diesen Antrag selbst (falls er schon gespeichert ist)
const ohne = { ...st, abwesenheiten: st.abwesenheiten.filter((x) => x.id !== a.id) };
const konto = kontoFuer(ohne, kontaktId, jahr, heute(), e.stundenProTag);
const restVorher = konto.rest - konto.beantragt;
return { tage, jahr, rest_vorher: restVorher, rest_danach: restVorher - tage, einsaetze: await einsaetzeIm(pool, kontaktId, a.von, a.bis, { tage: e.arbeitstage }, nurFreigegeben) };
}
const Antrag = z.object({
von: Tag,
bis: Tag.optional(),
halbtag: z.boolean().default(false),
notiz: z.string().trim().max(500).nullable().optional(),
}).transform((a) => ({ ...a, bis: a.bis || a.von }));
export function registriereUrlaub(app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>): void {
const eigener = (req: FastifyRequest) => {
const k = req.wer!.kontakt_id;
if (!k) throw new Fehler(409, "Deinem Zugang ist kein Mitarbeiter zugeordnet.");
return k;
};
const pruefeEingabe = (a: z.infer<typeof Antrag>) => {
if (a.bis < a.von) throw new Fehler(400, "Das Ende liegt vor dem Beginn.");
if (a.halbtag && a.bis !== a.von) throw new Fehler(400, "Einen halben Tag gibt es nur für einen einzelnen Tag.");
if (a.von < heute()) throw new Fehler(400, "Urlaub lässt sich nur ab heute beantragen.");
};
// Eigenes Urlaubskonto und eigene Anträge
app.get("/api/ich/urlaub", async (req) => {
const k = eigener(req);
const e = await einstellungen();
const st = await ladePersonal(pool, k);
const h = heute(), jahr = jahrVon(h);
const antraege = st.abwesenheiten.filter((a) => a.art === "urlaub" && a.bis >= `${jahr - 1}-01-01`)
.sort((a, b) => (a.von < b.von ? 1 : -1))
.map((a) => ({ id: a.id, von: a.von, bis: a.bis, halbtag: a.halbtag, status: a.status, notiz: a.notiz, antwort: a.antwort,
tage: urlaubstage(a, st.modelle, jahrVon(a.von), e.stundenProTag) + (jahrVon(a.bis) > jahrVon(a.von) ? urlaubstage(a, st.modelle, jahrVon(a.bis), e.stundenProTag) : 0) }));
return { konto: kontoFuer(st, k, jahr, h, e.stundenProTag), naechstes: kontoFuer(st, k, jahr + 1, h, e.stundenProTag), antraege };
});
app.get("/api/ich/urlaub/pruefen", async (req) => {
const a = Antrag.parse({ ...(req.query as object), halbtag: (req.query as { halbtag?: string }).halbtag === "true" });
if (a.bis < a.von) throw new Fehler(400, "Das Ende liegt vor dem Beginn.");
return pruefe(pool, await einstellungen(), eigener(req), { ...a, halbtag: a.halbtag && a.von === a.bis }, true);
});
app.post("/api/ich/urlaub", async (req, reply) => {
const k = eigener(req);
const a = Antrag.parse(req.body);
pruefeEingabe(a);
const e = await einstellungen();
const p = await pruefe(pool, e, k, a, true);
if (!p.tage) throw new Fehler(400, "In diesem Zeitraum sind keine Arbeitstage.");
const neu = await transaktion(pool, req.wer!.anmeldename, async (c) => {
const doppelt = await c.query(`select 1 from abwesenheit where kontakt_id = $1 and art = 'urlaub' and status <> 'abgelehnt' and von <= $3 and bis >= $2`, [k, a.von, a.bis]);
if (doppelt.rowCount) throw new Fehler(409, "Für diese Tage ist schon Urlaub eingetragen oder beantragt.");
return (await c.query(`insert into abwesenheit (kontakt_id, art, von, bis, halbtag, status, notiz) values ($1, 'urlaub', $2, $3, $4, 'beantragt', $5) returning *`,
[k, a.von, a.bis, a.halbtag, a.notiz ?? null])).rows[0];
});
return reply.status(201).send({ ...neu, ...p });
});
// Zurückziehen, solange noch nicht entschieden ist
app.delete("/api/ich/urlaub/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const k = eigener(req);
const n = await transaktion(pool, req.wer!.anmeldename, async (c) => {
const a = (await c.query("select status from abwesenheit where id = $1 and kontakt_id = $2 and art = 'urlaub'", [id, k])).rows[0];
if (!a) throw new Fehler(404, "Nicht gefunden");
if (a.status !== "beantragt") throw new Fehler(409, "Über diesen Antrag ist schon entschieden. Bitte sprich Henning an.");
return (await c.query("delete from abwesenheit where id = $1", [id])).rowCount;
});
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
// Inhaber und Büro: offene Anträge mit allem, was man zum Entscheiden braucht
app.get("/api/urlaub/antraege", async () => {
const e = await einstellungen();
const r = await pool.query(`select a.*, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id
where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`);
return Promise.all(r.rows.map(async (a) => ({ ...a, zeitraum: zeitraumText(a.von, a.bis), ...(await pruefe(pool, e, a.kontakt_id, a, false)) })));
});
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}.`);
// 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;
});
});
}