168 lines
8.9 KiB
TypeScript
168 lines
8.9 KiB
TypeScript
import dayjs from 'dayjs';
|
|
import utc from 'dayjs/plugin/utc';
|
|
import timezone from 'dayjs/plugin/timezone';
|
|
dayjs.extend(utc);
|
|
dayjs.extend(timezone);
|
|
export const TYPES = ['work', 'vacation', 'sick', 'overtime_compensation', 'holiday', 'other'] as const;
|
|
export type TimeType = typeof TYPES[number];
|
|
export type Period = {
|
|
started_at: string;
|
|
ended_at: string | null;
|
|
};
|
|
export type Span = Period & {
|
|
id?: string;
|
|
user_id?: string;
|
|
type: TimeType;
|
|
description: string;
|
|
status: string;
|
|
version?: number;
|
|
date_from?: string | null;
|
|
date_to?: string | null;
|
|
timezone: string;
|
|
breaks: Period[];
|
|
projects: (Period & {
|
|
project_id: number;
|
|
notes: string;
|
|
})[];
|
|
};
|
|
export class TimeError extends Error {
|
|
constructor(public statusCode: number, message: string) { super(message); }
|
|
}
|
|
export const fail = (message: string, status = 400): never => { throw new TimeError(status, message); };
|
|
export function instant(value: unknown): string {
|
|
if (typeof value !== 'string' || !/T.*(?:Z|[+-]\d\d:\d\d)$/.test(value) || !Number.isFinite(Date.parse(value)))
|
|
fail('Zeitpunkt mit Zeitzone erforderlich.');
|
|
dateOnly((value as string).slice(0, 10));
|
|
return new Date(value as string).toISOString();
|
|
}
|
|
export function dateOnly(value: unknown): string {
|
|
if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value)
|
|
fail('Ungültiges Datum.');
|
|
return value as string;
|
|
}
|
|
export function midnight(date: string, zone = 'Europe/Berlin') { return dayjs.tz(dateOnly(date), zone).toISOString(); }
|
|
export function nextDay(date: string) { return dayjs.utc(dateOnly(date)).add(1, 'day').format('YYYY-MM-DD'); }
|
|
export function range(from: string, to: string, zone = 'Europe/Berlin') {
|
|
dateOnly(from);
|
|
dateOnly(to);
|
|
if (from > to || dayjs.utc(to).diff(dayjs.utc(from), 'day') > 3660)
|
|
fail('Zeitraum muss zwischen 1 und 3661 Tagen liegen.');
|
|
return { started_at: midnight(from, zone), ended_at: midnight(nextDay(to), zone) };
|
|
}
|
|
const end = (p: Period) => p.ended_at ? Date.parse(p.ended_at) : Infinity;
|
|
export const overlaps = (a: Period, b: Period) => Date.parse(a.started_at) < end(b) && Date.parse(b.started_at) < end(a);
|
|
export const minutes = (p: Period, window: Period) => Math.max(0, Math.min(end(p), end(window)) - Math.max(Date.parse(p.started_at), Date.parse(window.started_at))) / 60000;
|
|
export function normalizeSpan(input: any): Span {
|
|
if (!input || !TYPES.includes(input.type))
|
|
fail('Ungültige Zeitart.');
|
|
const zone = input.timezone || 'Europe/Berlin';
|
|
try {
|
|
new Intl.DateTimeFormat('de', { timeZone: zone });
|
|
}
|
|
catch {
|
|
fail('Ungültige Zeitzone.');
|
|
}
|
|
const allDay = input.date_from != null || input.date_to != null;
|
|
const span: Span = {
|
|
type: input.type, description: String(input.description || '').slice(0, 10000), timezone: zone,
|
|
started_at: allDay ? midnight(input.date_from, zone) : instant(input.started_at),
|
|
ended_at: allDay ? midnight(input.date_to, zone) : input.ended_at == null ? null : instant(input.ended_at),
|
|
date_from: allDay ? dateOnly(input.date_from) : null, date_to: allDay ? dateOnly(input.date_to) : null,
|
|
status: 'factual', breaks: [], projects: [],
|
|
};
|
|
if (allDay && (span.type === 'work' || span.date_to! <= span.date_from!))
|
|
fail('Ungültiger ganztägiger Zeitraum; Ende ist exklusiv.');
|
|
if (span.ended_at && end(span) <= Date.parse(span.started_at))
|
|
fail('Ende muss nach Beginn liegen.');
|
|
if (!Array.isArray(input.breaks || []) || !Array.isArray(input.projects || []))
|
|
fail('Ungültige Teilzeiträume.');
|
|
span.breaks = (input.breaks || []).map((p: any) => ({ started_at: instant(p.started_at), ended_at: p.ended_at == null ? null : instant(p.ended_at) }));
|
|
span.projects = (input.projects || []).map((p: any) => {
|
|
if (!Number.isSafeInteger(Number(p.project_id)) || Number(p.project_id) <= 0)
|
|
fail('Projekt erforderlich.');
|
|
return { started_at: instant(p.started_at), ended_at: instant(p.ended_at), project_id: Number(p.project_id), notes: String(p.notes || '').slice(0, 10000) };
|
|
});
|
|
if (span.type !== 'work' && (span.breaks.length || span.projects.length))
|
|
fail('Pausen und Projekte benötigen eine Anwesenheit.');
|
|
for (const parts of [span.breaks, span.projects]) {
|
|
if (parts.length > 200)
|
|
fail('Zu viele Teilzeiträume.');
|
|
parts.sort((a, b) => Date.parse(a.started_at) - Date.parse(b.started_at));
|
|
for (let i = 0; i < parts.length; i++) {
|
|
const p = parts[i];
|
|
if (end(p) <= Date.parse(p.started_at) || Date.parse(p.started_at) < Date.parse(span.started_at) || end(p) > end(span))
|
|
fail('Teilzeitraum muss innerhalb der Anwesenheit liegen.');
|
|
if (i && overlaps(parts[i - 1], p))
|
|
fail('Teilzeiträume dürfen sich nicht überschneiden.');
|
|
}
|
|
}
|
|
for (const project of span.projects)
|
|
if (span.breaks.some(p => overlaps(p, project)))
|
|
fail('Projektzeit darf keine Pause enthalten.');
|
|
return span;
|
|
}
|
|
export function transition(span: Span, action: string, reason = '') {
|
|
if (!span.ended_at)
|
|
fail('Laufende Einträge zuerst beenden.', 409);
|
|
if (action === 'submit' && ['factual', 'rejected'].includes(span.status))
|
|
return 'submitted';
|
|
if (action === 'approve' && span.status === 'submitted')
|
|
return 'approved';
|
|
if (action === 'reject' && span.status === 'submitted' && reason.trim())
|
|
return 'rejected';
|
|
fail('Ungültiger Statuswechsel oder fehlender Ablehnungsgrund.', 409);
|
|
}
|
|
export function evaluate(spans: Span[], profile: any, holidayDates: string[], from: string, to: string, zone = 'Europe/Berlin') {
|
|
const window = range(from, to, zone);
|
|
const sum = { timeSpanWorkingMinutes: 0, sumWorkingMinutesSubmitted: 0, sumWorkingMinutesApproved: 0,
|
|
sumWorkingMinutesRecreationDays: 0, sumRecreationDays: 0, sumWorkingMinutesVacationDays: 0, sumVacationDays: 0,
|
|
sumWorkingMinutesSickDays: 0, sumSickDays: 0, sumOvertimeCompensationMinutes: 0, sumOtherMinutes: 0,
|
|
presenceMinutes: 0, breakMinutes: 0, saldoApproved: 0, saldoSubmitted: 0 };
|
|
for (const s of spans.filter(s => s.type === 'work' && s.ended_at)) {
|
|
const gross = minutes(s, window), breaks = s.breaks.reduce((n, p) => n + minutes(p, window), 0), net = gross - breaks;
|
|
sum.presenceMinutes += gross;
|
|
sum.breakMinutes += breaks;
|
|
if (['submitted', 'approved'].includes(s.status))
|
|
sum.sumWorkingMinutesSubmitted += net;
|
|
if (s.status === 'approved')
|
|
sum.sumWorkingMinutesApproved += net;
|
|
}
|
|
const holidays = new Set(holidayDates);
|
|
for (let date = from; date <= to; date = nextDay(date)) {
|
|
const day = range(date, date, zone), weekday = dayjs.utc(date).day();
|
|
const target = Math.max(0, Number(profile.weekly_regular_working_hours?.[weekday] || 0)) * 60;
|
|
sum.timeSpanWorkingMinutes += target;
|
|
// Credits are capped per day; holidays take precedence over overlapping absence credits.
|
|
let remaining = target;
|
|
const approved = spans.filter(s => s.type !== 'work' && s.status === 'approved' && s.ended_at && overlaps(s, day));
|
|
if ((profile.recreation_days_compensation && holidays.has(date)) || approved.some(s => s.type === 'holiday')) {
|
|
sum.sumWorkingMinutesRecreationDays += target;
|
|
sum.sumRecreationDays += target > 0 ? 1 : 0;
|
|
remaining = 0;
|
|
}
|
|
for (const type of ['vacation', 'sick', 'overtime_compensation', 'other']) {
|
|
for (const s of approved.filter(s => s.type === type)) {
|
|
const credit = Math.min(remaining, s.date_from ? target : minutes(s, day));
|
|
if (type === 'vacation') {
|
|
sum.sumWorkingMinutesVacationDays += credit;
|
|
sum.sumVacationDays += target ? credit / target : 0;
|
|
}
|
|
if (type === 'sick') {
|
|
sum.sumWorkingMinutesSickDays += credit;
|
|
sum.sumSickDays += target ? credit / target : 0;
|
|
}
|
|
// Freizeitausgleich consumes the balance through the regular daily target, without a credit.
|
|
if (type === 'overtime_compensation')
|
|
sum.sumOvertimeCompensationMinutes += credit;
|
|
if (type === 'other')
|
|
sum.sumOtherMinutes += credit;
|
|
remaining -= credit;
|
|
}
|
|
}
|
|
}
|
|
const credit = sum.sumWorkingMinutesRecreationDays + sum.sumWorkingMinutesVacationDays + sum.sumWorkingMinutesSickDays;
|
|
sum.saldoApproved = sum.sumWorkingMinutesApproved + credit - sum.timeSpanWorkingMinutes;
|
|
sum.saldoSubmitted = sum.sumWorkingMinutesSubmitted + credit - sum.timeSpanWorkingMinutes;
|
|
return sum;
|
|
}
|