Urlaubsantrag am Handy, Entscheidung mit Antwort, Hinweis in der Übersicht (0.11.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 06:59:26 +00:00
parent 8634791c68
commit dd57169e9a
10 changed files with 360 additions and 8 deletions

137
src/server/urlaub.ts Normal file
View File

@@ -0,0 +1,137 @@
// 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";
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.dauer, p.nummer, p.bezeichnung from besetzung 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') 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);
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];
});
});
}