Zeiterfassung mit Pausenabzug, offline am Handy, Ansicht für alle (0.9.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:43:52 +00:00
parent 859a076e83
commit e4754f329a
16 changed files with 832 additions and 18 deletions

View File

@@ -11,7 +11,7 @@ import { legeZahlungsplanAn, zahlungsplanFest, zahlungsplaeneAutomatisch } from
import { uebersicht } from "./uebersicht.js";
import { aufgabenKalender, baustellenKalender } from "./kalender.js";
import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js";
import { TABELLEN } from "./tabellen.js";
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
import { liquiditaet } from "../domain/liquiditaet.js";
import { liquiditaetsDaten } from "../domain/projektplan.js";
@@ -22,6 +22,7 @@ import { VERSION } from "./version.js";
import { type Anmeldeart, registriereAnmeldung, werName } from "./anmeldung.js";
import { istEingeteilt, registriereIch } from "./ich.js";
import { registrierePersonal } from "./personal.js";
import { registriereZeiten } from "./zeiten.js";
export interface Optionen {
pool: Pool;
@@ -64,6 +65,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
registriereIch(app, pool, ladeEinstellungen);
registrierePersonal(app, pool, ladeEinstellungen);
registriereZeiten(app, pool, ladeEinstellungen);
app.get("/api/status", async () => {
await pool.query("select 1");
@@ -350,7 +352,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
// D1: kompletter Stand als JSON-Datei
app.get("/api/export", async (_req, reply) => {
const daten: Record<string, unknown[]> = {};
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
daten.benutzer = await benutzerFuerSicherung(pool);
const stand = new Date().toISOString();
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);

View File

@@ -27,6 +27,8 @@ export const EinstellungenSchema = z.object({
startsaldo: z.number().int().default(0),
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
mindestreserve: z.number().int().default(0),
// M3: knapp über einer Grenze nur bis zur Grenze abziehen (6:10 → 6:00) oder immer voll
pausenabzug: z.enum(["bis_grenze", "voll"]).default("bis_grenze"),
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
kalenderToken: z.string().min(20).nullable().default(null),
});

View File

@@ -0,0 +1,42 @@
-- Z1, M3: Arbeitszeit am Handy. Ein Eintrag je Person und Tag (E21) mit Beginn, Ende und Pause,
-- aufgeteilt auf Vorgänge mit Tätigkeit. Im Bau Pflicht und 2 Jahre aufzubewahren: Einträge
-- verschwinden nicht mit dem Kontakt oder dem Vorgang.
create table zeiteintrag (
id uuid primary key default gen_random_uuid(),
kontakt_id uuid not null references kontakt (id) on delete restrict,
datum date not null,
beginn time not null,
ende time not null,
-- von Hand eingetragene Pause und automatischer Abzug nach M3, beides in Minuten
pause_min integer not null default 0 check (pause_min >= 0),
abzug_min integer not null default 0 check (abzug_min >= 0),
notiz text,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system',
unique (kontakt_id, datum),
check (ende > beginn)
);
create trigger zeiteintrag_protokoll before insert or update or delete on zeiteintrag
for each row execute function stempel_und_protokoll();
create table zeitanteil (
id uuid primary key default gen_random_uuid(),
zeiteintrag_id uuid not null references zeiteintrag (id) on delete cascade,
projekt_id uuid references projekt (id) on delete set null,
vorgang_id uuid references vorgang (id) on delete set null,
taetigkeit text,
stunden numeric(5, 2) not null check (stunden > 0),
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index zeitanteil_eintrag on zeitanteil (zeiteintrag_id);
create index zeitanteil_projekt on zeitanteil (projekt_id);
create trigger zeitanteil_protokoll before insert or update or delete on zeitanteil
for each row execute function stempel_und_protokoll();
-- Einen Kontakt mit Zugang nicht still löschen (Mitarbeiter brauchen ihren Kontakt): erst den Benutzer ändern
alter table benutzer drop constraint benutzer_kontakt_id_fkey,
add constraint benutzer_kontakt_id_fkey foreign key (kontakt_id) references kontakt (id) on delete restrict;

View File

@@ -2,7 +2,7 @@
// Damit ziehen die Daten aus der Testversion im Browser auf den Server um.
import type { Client } from "./db.js";
import { EinstellungenSchema } from "./einstellungen.js";
import { TABELLEN } from "./tabellen.js";
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
import { NichtLeer } from "./v70import.js";
export interface Stand {
@@ -21,13 +21,13 @@ export function pruefeStand(x: unknown): Stand {
export async function speichereStand(c: Client, s: Stand): Promise<Record<string, number>> {
const belegt = await c.query<{ n: number }>(
`select ${TABELLEN.map((t) => `(select count(*) from ${t.name})`).join(" + ")} as n`,
`select ${[...TABELLEN, ...NUR_SICHERUNG].map((t) => `(select count(*) from ${t.name})`).join(" + ")} as n`,
);
if (Number(belegt.rows[0]!.n) > 0) throw new NichtLeer("Eine Sicherung lässt sich nur in ein leeres Programm einspielen.");
const anzahl: Record<string, number> = {};
// TABELLEN steht in der Reihenfolge der Fremdschlüssel
for (const t of TABELLEN) {
// TABELLEN steht in der Reihenfolge der Fremdschlüssel, NUR_SICHERUNG hängt an ihnen
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) {
const zeilen = s.daten[t.pfad] ?? [];
// nur Spalten, die es gibt und die in der Sicherung stehen: neue Spalten behalten ihren Vorgabewert,
// so passt eine ältere Sicherung auch nach einer Migration

View File

@@ -236,3 +236,10 @@ export const TABELLEN: Tabelle[] = [
}),
},
];
/** Tabellen mit eigenen Routen (keine allgemeinen), die trotzdem in Sicherung und Umzug gehören.
* Reihenfolge nach Fremdschlüsseln, nach TABELLEN einzuspielen. */
export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] = [
{ name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" },
{ name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" },
];

200
src/server/zeiten.ts Normal file
View File

@@ -0,0 +1,200 @@
// Z1, M3: Arbeitszeit buchen. Ein Eintrag je Person und Tag (E21), aufgeteilt auf Vorgänge.
// Der Pausenabzug wird beim Speichern berechnet und mit gespeichert, damit Übergabe und Nachweis
// genau das zeigen, was der Mitarbeiter beim Buchen gesehen hat.
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Client, type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { type Abzugsart, minuten, rechneTag, uhrzeit } from "../domain/zeit.js";
import { plusTage } from "../domain/datum.js";
import { anfang, ende } from "../domain/terminplan.js";
import { verfuegbarkeit } from "../domain/personal.js";
import { ladePersonal } from "./personal.js";
type Abfrage = Pick<Pool, "query">;
const Tag = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
const Uhrzeit = z.string().regex(/^\d{1,2}:\d{2}$/, "Uhrzeit als hh:mm");
const Anteil = z.object({
projekt_id: z.uuid().nullable().optional(),
vorgang_id: z.uuid().nullable().optional(),
taetigkeit: z.string().trim().max(200).nullable().optional(),
stunden: z.number().positive().max(24).optional(),
});
export const TagEingabe = z.object({
beginn: Uhrzeit,
ende: Uhrzeit,
pause_min: z.number().int().min(0).max(720).default(0),
notiz: z.string().trim().max(500).nullable().optional(),
anteile: z.array(Anteil).max(20).default([]),
});
export type TagEingabe = z.infer<typeof TagEingabe>;
class Fehler extends Error {
constructor(public statusCode: number, nachricht: string) { super(nachricht); }
}
/** Pausenregel gilt für Angestellte; nicht für den Inhaber und nicht für Subunternehmer */
export async function istAngestellt(c: Abfrage, kontaktId: string): Promise<boolean> {
const r = (await c.query(`select k.rolle, m.angestellt, exists (select 1 from benutzer b where b.kontakt_id = k.id and b.rolle = 'inhaber') as inhaber
from kontakt k left join mitarbeiter m on m.kontakt_id = k.id where k.id = $1`, [kontaktId])).rows[0];
if (!r) throw new Fehler(404, "Person nicht gefunden");
if (r.angestellt != null) return r.angestellt;
return r.rolle === "mitarbeiter" && !r.inhaber;
}
/** Einträge mit Anteilen, Projekt- und Vorgangsnamen */
export async function ladeTage(c: Abfrage, von: string, bis: string, kontaktId?: string) {
const e = await c.query(`select z.*, k.name from zeiteintrag z join kontakt k on k.id = z.kontakt_id
where z.datum between $1 and $2 and ($3::uuid is null or z.kontakt_id = $3) order by z.datum, k.name`, [von, bis, kontaktId ?? null]);
if (!e.rows.length) return [];
const a = await c.query(`select t.*, p.nummer, p.bezeichnung, v.name as vorgang from zeitanteil t
left join projekt p on p.id = t.projekt_id left join vorgang v on v.id = t.vorgang_id
where t.zeiteintrag_id = any($1::uuid[]) order by t.reihenfolge`, [e.rows.map((r) => r.id)]);
return e.rows.map((r) => {
const beginn = uhrzeit(minuten(r.beginn)), endeZ = uhrzeit(minuten(r.ende));
const anwesend = minuten(r.ende) - minuten(r.beginn);
return {
...r, beginn, ende: endeZ, anwesend_min: anwesend, netto_min: anwesend - r.pause_min - r.abzug_min,
anteile: a.rows.filter((x) => x.zeiteintrag_id === r.id).map((x) => ({ ...x, stunden: Number(x.stunden) })),
};
});
}
export async function speichereTag(c: Client, kontaktId: string, datum: string, eingabe: TagEingabe, art: Abzugsart) {
const anwesend = minuten(eingabe.ende) - minuten(eingabe.beginn);
if (anwesend <= 0) throw new Fehler(400, "Das Ende muss nach dem Beginn liegen.");
if (eingabe.pause_min >= anwesend) throw new Fehler(400, "Die Pause ist länger als die Arbeitszeit.");
const r = rechneTag(anwesend, eingabe.pause_min, await istAngestellt(c, kontaktId), art);
const netto = r.netto / 60;
// Anteile: keiner = alles ohne Baustelle, einer = alles dorthin, mehrere = Summe muss stimmen
let anteile = eingabe.anteile.length ? eingabe.anteile : [{ taetigkeit: null }];
if (anteile.length === 1) anteile = [{ ...anteile[0]!, stunden: netto }];
const summe = anteile.reduce((s, x) => s + (x.stunden ?? 0), 0);
if (Math.abs(summe - netto) > 0.01) {
const f = (h: number) => String(Math.round(h * 100) / 100).replace(".", ",");
throw new Fehler(400, `Die Stunden der Baustellen ergeben ${f(summe)}, gearbeitet wurden ${f(netto)} Stunden.`);
}
// Projekt aus dem Vorgang, damit die Stunden beim Projekt bleiben, auch wenn der Vorgang später gelöscht wird
for (const x of anteile) {
if (!x.vorgang_id) continue;
const p = (await c.query("select a.projekt_id from vorgang v join abschnitt a on a.id = v.abschnitt_id where v.id = $1", [x.vorgang_id])).rows[0];
if (!p) throw new Fehler(400, "Vorgang nicht gefunden");
x.projekt_id = p.projekt_id;
}
const eintrag = (await c.query(`insert into zeiteintrag (kontakt_id, datum, beginn, ende, pause_min, abzug_min, notiz) values ($1, $2, $3, $4, $5, $6, $7)
on conflict (kontakt_id, datum) do update set beginn = excluded.beginn, ende = excluded.ende, pause_min = excluded.pause_min, abzug_min = excluded.abzug_min, notiz = excluded.notiz
returning id`, [kontaktId, datum, eingabe.beginn, eingabe.ende, r.handPause, r.abzug, eingabe.notiz ?? null])).rows[0];
await c.query("delete from zeitanteil where zeiteintrag_id = $1", [eintrag.id]);
for (const [i, x] of anteile.entries()) {
await c.query("insert into zeitanteil (zeiteintrag_id, projekt_id, vorgang_id, taetigkeit, stunden, reihenfolge) values ($1, $2, $3, $4, $5, $6)",
[eintrag.id, x.projekt_id ?? null, x.vorgang_id ?? null, x.taetigkeit || null, Math.round(x.stunden! * 100) / 100, i]);
}
return { ...(await ladeTage(c, datum, datum, kontaktId))[0]!, ueber_zehn: r.ueberZehn };
}
/** Wer selbst bucht, braucht einen Kontakt. Inhaber und Büro bekommen ihn beim ersten Mal. */
async function eigenerKontakt(pool: Pool, req: FastifyRequest): Promise<string> {
const w = req.wer!;
if (w.kontakt_id) return w.kontakt_id;
if (w.rolle === "mitarbeiter") throw new Fehler(409, "Deinem Zugang ist kein Mitarbeiter zugeordnet.");
return transaktion(pool, w.anmeldename, async (c) => {
const k = (await c.query("insert into kontakt (name, rolle) values ($1, 'mitarbeiter') returning id", [w.name])).rows[0].id;
await c.query("insert into mitarbeiter (kontakt_id, angestellt) values ($1, $2)", [k, w.rolle !== "inhaber"]);
// Testversion ohne angelegte Benutzer: Henning als Inhaber anlegen
if (w.id) await c.query("update benutzer set kontakt_id = $2 where id = $1", [w.id, k]);
else await c.query(`insert into benutzer (anmeldename, name, rolle, kontakt_id) values ($1, $2, $3, $4)
on conflict (anmeldename) do update set kontakt_id = excluded.kontakt_id`, [w.anmeldename, w.name, w.rolle, k]);
w.kontakt_id = k;
return k;
});
}
const heute = () => new Date().toISOString().slice(0, 10);
/** Mitarbeiter buchen und ändern ihre eigenen Tage bis 14 Tage zurück; Älteres ändert der Inhaber oder das Büro */
export const RUECKWIRKEND = 14;
export function registriereZeiten(app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>): void {
// Eigene Stunden mit allem, was das Handy zum Buchen braucht
app.get("/api/ich/zeiten", async (req) => {
const q = z.object({ von: Tag.optional(), bis: Tag.optional() }).parse(req.query);
const bis = q.bis ?? heute();
const von = q.von ?? plusTage(bis, -13);
const kontakt = await eigenerKontakt(pool, req);
const e = await einstellungen();
const woche = { tage: e.arbeitstage };
const [tage, angestellt, st, einsatz, projekte] = await Promise.all([
ladeTage(pool, von, bis, kontakt),
istAngestellt(pool, kontakt),
ladePersonal(pool, kontakt),
pool.query(`select v.id, v.name, v.start, v.dauer, a.projekt_id from besetzung b join vorgang v on v.id = b.vorgang_id
join abschnitt a on a.id = v.abschnitt_id where b.kontakt_id = $1 and b.freigegeben`, [kontakt]),
// Baustellen zur Auswahl: laufende Aufträge mit ihren Vorgängen, nur Namen (E27)
pool.query(`select p.id, p.nummer, p.bezeichnung, coalesce(json_agg(json_build_object('id', v.id, 'name', v.name) order by a.reihenfolge, v.reihenfolge, v.nummer)
filter (where v.id is not null), '[]') as vorgaenge
from projekt p left join abschnitt a on a.projekt_id = p.id left join vorgang v on v.abschnitt_id = a.id
where p.status in ('auftrag', 'ausfuehrung') group by p.id order by p.nummer`),
]);
const einsaetze = einsatz.rows.map((v) => ({ id: v.id, name: v.name, projekt_id: v.projekt_id,
anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }));
return {
von, bis, kontakt_id: kontakt, angestellt, pausenabzug: e.pausenabzug, rueckwirkend: req.wer!.rolle === "mitarbeiter" ? RUECKWIRKEND : null,
tage, soll: verfuegbarkeit(st.modelle, st.abwesenheiten, kontakt, von, plusTage(bis, 7), e.stundenProTag), einsaetze, projekte: projekte.rows,
};
});
const darfSelbst = (req: FastifyRequest, datum: string) => {
if (datum > heute()) throw new Fehler(400, "Stunden lassen sich nicht im Voraus buchen.");
if (req.wer!.rolle === "mitarbeiter" && datum < plusTage(heute(), -RUECKWIRKEND)) {
throw new Fehler(403, `Tage, die länger als ${RUECKWIRKEND} Tage zurückliegen, ändert Henning.`);
}
};
app.put("/api/ich/zeiten/:datum", async (req) => {
const { datum } = z.object({ datum: Tag }).parse(req.params);
darfSelbst(req, datum);
const eingabe = TagEingabe.parse(req.body);
const kontakt = await eigenerKontakt(pool, req);
const art = (await einstellungen()).pausenabzug;
return transaktion(pool, req.wer!.anmeldename, (c) => speichereTag(c, kontakt, datum, eingabe, art));
});
app.delete("/api/ich/zeiten/:datum", async (req, reply) => {
const { datum } = z.object({ datum: Tag }).parse(req.params);
darfSelbst(req, datum);
const kontakt = await eigenerKontakt(pool, req);
const n = await transaktion(pool, req.wer!.anmeldename, async (c) => (await c.query("delete from zeiteintrag where kontakt_id = $1 and datum = $2", [kontakt, datum])).rowCount);
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
// Inhaber und Büro: alle Stunden, auch nachtragen und korrigieren (auch Subunternehmer im Stundenlohn, Z2)
app.get("/api/zeiten", async (req) => {
const q = z.object({ von: Tag, bis: Tag, kontakt_id: z.uuid().optional() }).parse(req.query);
const [tage, leute] = await Promise.all([
ladeTage(pool, q.von, q.bis, q.kontakt_id),
pool.query(`select k.id, k.name, k.rolle, coalesce(m.angestellt, k.rolle = 'mitarbeiter' and not exists (select 1 from benutzer b where b.kontakt_id = k.id and b.rolle = 'inhaber')) as angestellt
from kontakt k left join mitarbeiter m on m.kontakt_id = k.id where k.rolle in ('mitarbeiter', 'subunternehmer') order by k.rolle, k.name`),
]);
return { tage, leute: leute.rows, pausenabzug: (await einstellungen()).pausenabzug };
});
app.put("/api/zeiten/:kontakt_id/:datum", async (req) => {
const { kontakt_id, datum } = z.object({ kontakt_id: z.uuid(), datum: Tag }).parse(req.params);
const eingabe = TagEingabe.parse(req.body);
const art = (await einstellungen()).pausenabzug;
return transaktion(pool, req.wer!.anmeldename, (c) => speichereTag(c, kontakt_id, datum, eingabe, art));
});
app.delete("/api/zeiten/:kontakt_id/:datum", async (req, reply) => {
const { kontakt_id, datum } = z.object({ kontakt_id: z.uuid(), datum: Tag }).parse(req.params);
const n = await transaktion(pool, req.wer!.anmeldename, async (c) => (await c.query("delete from zeiteintrag where kontakt_id = $1 and datum = $2", [kontakt_id, datum])).rowCount);
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
// Ist-Stunden je Projekt (Projektseite, später Nachkalkulation)
app.get("/api/zeiten/projekte", async () => {
const r = await pool.query("select projekt_id, sum(stunden) as stunden from zeitanteil where projekt_id is not null group by projekt_id");
return Object.fromEntries(r.rows.map((x) => [x.projekt_id, Number(x.stunden)]));
});
}