Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
142 lines
8.6 KiB
TypeScript
142 lines
8.6 KiB
TypeScript
// 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;
|
||
});
|
||
});
|
||
}
|