diff --git a/CHANGELOG.md b/CHANGELOG.md index 6cc0731..f146d5b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.9.0 + +- Zeiterfassung (Z1, M3): Neuer Reiter „Stunden“. Mitarbeiter tragen am Handy Beginn, Ende und Pause ein und wählen die Baustelle; vorgeschlagen werden zuerst die Vorgänge, für die sie heute eingeteilt sind. Ein Tag lässt sich auf mehrere Baustellen und Tätigkeiten aufteilen, die letzte bekommt automatisch den Rest. +- Pausenabzug für Angestellte nach deiner Regel (bis 6 Std. keiner, über 6 bis 9 Std. 30 Min., über 9 bis 10 Std. 45 Min., über 10 Std. 1 Std.), eingetragene Pausen zählen mit. Knapp über einer Grenze wird nur bis zur Grenze abgezogen (6:10 → 6:00); umstellbar unter Daten → Einstellungen. Über 10 Std. gibt es einen Hinweis. +- Ohne Netz werden die Stunden auf dem Handy gemerkt und gesendet, sobald wieder Verbindung da ist. Mitarbeiter können bis 14 Tage zurück nachtragen, nicht im Voraus. +- Für dich und das Büro: Ansicht „Alle“ mit Monat und Person, Ist- und Soll-Stunden, Stunden nachtragen oder korrigieren. Du selbst kannst unter „Meine“ eigene Stunden erfassen (ohne Pausenabzug). +- Projektseite: Die Kachel Arbeitsstunden zeigt jetzt die erfassten Ist-Stunden. + ## 0.8.0 - Neuer Reiter „Personal“: alle Mitarbeiter mit Arbeitszeit, was heute ist (z. B. Urlaub oder „4 von 8 Std.“), Resturlaub und offenen Urlaubsanträgen. diff --git a/demo/kern.ts b/demo/kern.ts index db6295d..9982d7b 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -10,11 +10,13 @@ import m005 from "../src/server/migrations/005_projektseite_kategorien.sql"; import m006 from "../src/server/migrations/006_zahlungsplan_automatisch.sql"; import m007 from "../src/server/migrations/007_anmeldung.sql"; import m008 from "../src/server/migrations/008_personal.sql"; +import m009 from "../src/server/migrations/009_zeiterfassung.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], ["005_projektseite_kategorien.sql", m005], ["006_zahlungsplan_automatisch.sql", m006], ["007_anmeldung.sql", m007], ["008_personal.sql", m008], + ["009_zeiterfassung.sql", m009], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/demo/main.ts b/demo/main.ts index 569f764..f1c2a61 100644 --- a/demo/main.ts +++ b/demo/main.ts @@ -3,7 +3,7 @@ import { PGlite } from "@electric-sql/pglite"; import { starte } from "./kern.js"; import { PARSER } from "./pool.js"; -import { TABELLEN } from "../src/server/tabellen.js"; +import { NUR_SICHERUNG, TABELLEN } from "../src/server/tabellen.js"; type Doc = { id: string; exists: boolean; data(): Record | undefined }; type Query = { where(f: string, op: string, v: unknown): Query; orderBy(f: string): Query; limit(n: number): Query; get(): Promise<{ docs: Doc[] }> }; @@ -62,7 +62,7 @@ async function main() { if (speicher) { melde("Deine Daten werden geladen …"); const daten: Record[]> = {}; - for (const pfad of [...TABELLEN.map((t) => t.pfad), "benutzer"]) daten[pfad] = await nochmal(() => alle(speicher, pfad)); + for (const pfad of [...TABELLEN, ...NUR_SICHERUNG].map((t) => t.pfad).concat("benutzer")) daten[pfad] = await nochmal(() => alle(speicher, pfad)); const e = await nochmal(() => speicher.doc("meta/einstellungen").get()); if (Object.values(daten).some((z) => z.length) || e.exists) { const r = await app.verarbeite("POST", "/api/import/stand", { programm: "betrieb", einstellungen: e.data()?.daten, daten }); diff --git a/package.json b/package.json index 1bedb14..f06f1cf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.8.0", + "version": "0.9.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/zeit.ts b/src/domain/zeit.ts new file mode 100644 index 0000000..86d2d0b --- /dev/null +++ b/src/domain/zeit.ts @@ -0,0 +1,62 @@ +// Arbeitszeit und Pausenabzug (M3, Henning 18.10.2026). Rechnet in Minuten. +// Abzug nach der Summe des Tages: bis 6 Std keiner, über 6 bis 9 Std 30 Min, über 9 bis 10 Std 45 Min, über 10 Std 1 Std. +// Von Hand eingetragene Pausen zählen mit; längere Pausen als 1 Std trägt man von Hand ein. +// Nur für Angestellte, nicht für den Inhaber. + +/** bis_grenze: knapp über einer Grenze wird nur bis zur Grenze abgezogen (6:10 → 6:00); voll: immer der ganze Abzug */ +export type Abzugsart = "bis_grenze" | "voll"; + +const STUFEN: [number, number][] = [[360, 0], [540, 30], [600, 45], [Infinity, 60]]; + +/** Pause nach der Regel für eine Anwesenheit (Ende minus Beginn) */ +export function regelPause(anwesend: number): number { + for (const [bis, pause] of STUFEN) if (anwesend <= bis) return pause; + return 60; +} + +export interface Tagesrechnung { + /** Ende minus Beginn */ + anwesend: number; + /** von Hand eingetragen */ + handPause: number; + /** zusätzlich automatisch abgezogen */ + abzug: number; + /** bezahlte Arbeitszeit */ + netto: number; + /** über 10 Std. Arbeitszeit (Grenze nach Arbeitszeitgesetz) */ + ueberZehn: boolean; +} + +export function rechneTag(anwesend: number, handPause: number, angestellt: boolean, art: Abzugsart = "bis_grenze"): Tagesrechnung { + if (!(anwesend >= 0) || !(handPause >= 0)) throw new Error("Zeiten ungültig"); + const hand = Math.min(handPause, anwesend); + let pflicht = 0; + if (angestellt) { + pflicht = regelPause(anwesend); + if (art === "bis_grenze") { + // länger da sein ergibt nie weniger Stunden: höchstens bis zur zuletzt überschrittenen Grenze abziehen + let netto = anwesend - pflicht; + for (const [grenze] of STUFEN) if (grenze < anwesend) netto = Math.max(netto, grenze - regelPause(grenze)); + pflicht = anwesend - netto; + } + } + const pause = Math.max(hand, pflicht); + const netto = anwesend - pause; + return { anwesend, handPause: hand, abzug: pause - hand, netto, ueberZehn: netto > 600 }; +} + +/** "07:30" → 450 */ +export function minuten(uhrzeit: string): number { + const m = /^(\d{1,2}):(\d{2})(?::\d{2})?$/.exec(uhrzeit.trim()); + if (!m || Number(m[1]) > 24 || Number(m[2]) > 59) throw new Error(`Uhrzeit ungültig: ${uhrzeit}`); + return Number(m[1]) * 60 + Number(m[2]); +} + +/** 450 → "07:30" */ +export const uhrzeit = (min: number) => `${String(Math.floor(min / 60)).padStart(2, "0")}:${String(Math.round(min % 60)).padStart(2, "0")}`; + +/** 510 → "8:30" (Stunden:Minuten) */ +export const dauerText = (min: number) => `${min < 0 ? "−" : ""}${Math.floor(Math.abs(min) / 60)}:${String(Math.round(Math.abs(min) % 60)).padStart(2, "0")}`; + +/** 510 → 8.5 (Stunden mit zwei Stellen) */ +export const stunden = (min: number) => Math.round((min / 60) * 100) / 100; diff --git a/src/server/app.ts b/src/server/app.ts index 877de62..1e154f1 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -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 { 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 { // D1: kompletter Stand als JSON-Datei app.get("/api/export", async (_req, reply) => { const daten: Record = {}; - 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"`); diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 69abaac..42f76a9 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -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), }); diff --git a/src/server/migrations/009_zeiterfassung.sql b/src/server/migrations/009_zeiterfassung.sql new file mode 100644 index 0000000..bb0d39f --- /dev/null +++ b/src/server/migrations/009_zeiterfassung.sql @@ -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; diff --git a/src/server/stand.ts b/src/server/stand.ts index 0f26305..db6cdcc 100644 --- a/src/server/stand.ts +++ b/src/server/stand.ts @@ -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> { 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 = {}; - // 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 diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index a6236ef..3fac3e2 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -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" }, +]; diff --git a/src/server/zeiten.ts b/src/server/zeiten.ts new file mode 100644 index 0000000..f872c18 --- /dev/null +++ b/src/server/zeiten.ts @@ -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; +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; + +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 { + 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 { + 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): 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)])); + }); +} diff --git a/src/web/app.ts b/src/web/app.ts index 2b06176..538895b 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -6,6 +6,7 @@ import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeite import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js"; import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js"; import { mitarbeiterSeite, personalSeite } from "./personal.js"; +import { meineStunden, stundenSeite } from "./stunden.js"; // ---------- Reiter ---------- @@ -116,13 +117,13 @@ let projektOben = "uebersicht"; let projektTeil = "dokumente"; const projektAufgabenFilter = { kategorie: "", erledigte: false }; const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN); -const stundenText = (h: number) => `${Math.floor(h)}:${String(Math.round((h % 1) * 60)).padStart(2, "0")} Std.`; +const stundenText = (h: number) => { const m = Math.round(h * 60); return `${Math.floor(m / 60)}:${String(m % 60).padStart(2, "0")} Std.`; }; const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`); async function projektSeite(id: string): Promise { - const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben] = await Promise.all([ + const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt] = await Promise.all([ api(`projekte/${id}`), api("kontakte"), api("terminplan"), - api("zahlungen"), api("kosten"), aufgabenDaten(), api("aufgaben"), + api("zahlungen"), api("kosten"), aufgabenDaten(), api("aufgaben"), api>("zeiten/projekte"), ]); const neuLaden = () => projektSeite(id); const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k])); @@ -171,13 +172,12 @@ async function projektSeite(id: string): Promise { const anfang = vorgaenge.map((v: Zeile) => v.anfang).sort()[0]; const ende = vorgaenge.map((v: Zeile) => v.ende).sort().at(-1); const soll = vorgaenge.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 0), 0) || Number(p.soll_stunden) || 0; - const ist = 0; // kommt mit der Zeiterfassung (Stufe 2) + const ist = istJeProjekt[id] ?? 0; const anteil = soll ? Math.round((ist / soll) * 100) : null; const adresse = ortZeile(p); ziel.innerHTML = `
${kachel("stunden", "Arbeitsstunden", `

${stundenText(ist)}

/ ${soll ? stundenText(soll) : "0:00 Std."}

- ${anteil ? `` : ""}${anteil === null ? "– %" : `${anteil} %`}
-

Ist-Stunden kommen mit der Zeiterfassung.

`)} + ${anteil ? `` : ""}${anteil === null ? "– %" : `${anteil} %`}
`)} ${kachel("kunde", "Kunde", kunde ? `

${esc(kunde.name)}${kunde.firma ? `
${esc(kunde.firma)}` : ""}

${[kunde.telefon && `${esc(kunde.telefon)}`, kunde.email && esc(kunde.email)].filter(Boolean).join("
")}

` @@ -750,6 +750,7 @@ async function daten(): Promise { { name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] }, { name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] }, { name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" }, + { name: "pausenabzug", titel: "Pausenabzug knapp über einer Grenze", art: "auswahl", optionen: [["bis_grenze", "Nur bis zur Grenze (6:10 → 6:00)"], ["voll", "Immer ganz abziehen (6:10 → 5:40)"]] }, ]; const knopf = document.createElement("button"); knopf.className = "neben"; @@ -759,7 +760,7 @@ async function daten(): Promise { if (r?.aktion !== "speichern") return; const d = r.daten; await api("einstellungen", "PUT", { - ...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag, + ...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag, pausenabzug: d.pausenabzug ?? e.pausenabzug, // Datum merken, damit die Startseite weiß, dass der Kontostand eingetragen ist startsaldoDatum: (d.startsaldo ?? 0) !== e.startsaldo ? heute() : e.startsaldoDatum, zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 }, @@ -775,10 +776,10 @@ async function daten(): Promise { type Reiter = [string, string, () => Promise]; function reiterFuer(s: Sitzung): Reiter[] { const rolle = s.benutzer?.rolle; - if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]]; + if (rolle === "mitarbeiter") return [["stunden", "Meine Stunden", () => meineStunden()], ["meine-einsaetze", "Meine Einsätze", meineEinsaetze]]; const alle: Reiter[] = [ ["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte], - ["terminplan", "Terminplan", terminplan], ["personal", "Personal", personalSeite], ["kontakte", "Kontakte", kontakte], + ["terminplan", "Terminplan", terminplan], ["personal", "Personal", personalSeite], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten], ]; if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); @@ -795,6 +796,7 @@ const SYMBOLE: Record = { liquiditaet: '', "laufende-kosten": '', benutzer: '', + stunden: '', personal: '', "meine-einsaetze": '', daten: '', diff --git a/src/web/stunden.ts b/src/web/stunden.ts new file mode 100644 index 0000000..a3127af --- /dev/null +++ b/src/web/stunden.ts @@ -0,0 +1,334 @@ +// Z1, M3: Stunden buchen am Handy (in drei Tipps: Stunden öffnen, Baustelle prüfen, Speichern) und für Inhaber +// und Büro die Monatsübersicht aller. Ohne Netz bleibt die Buchung im Handy und geht raus, sobald wieder Netz da ist. + +import { type Abzugsart, dauerText, minuten, rechneTag, regelPause, uhrzeit } from "../domain/zeit.js"; +import { type Zeile, api, dat, esc, heute, inhalt, lies, merke, seite } from "./ui.js"; + +const WT = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"]; +const WT_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"]; +const wt = (d: string) => new Date(`${d}T00:00:00Z`).getUTCDay(); +const plusTage = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10); +const zahl = (h: number) => String(Math.round(h * 100) / 100).replace(".", ","); +const PAUSEN = [0, 15, 30, 45, 60, 90]; + +// ---------- ohne Netz: Warteschlange im Handy ---------- +const SCHLANGE = "betrieb-stunden-warteschlange"; +type Wartend = { pfad: string; body: unknown; datum: string }; +const schlange = (): Wartend[] => { try { return JSON.parse(lies(SCHLANGE) ?? "[]"); } catch { return []; } }; +const sichereSchlange = (l: Wartend[]) => merke(SCHLANGE, l.length ? JSON.stringify(l) : null); + +/** Gespeicherte Buchungen senden; gibt zurück, wie viele noch warten */ +export async function sendeWartende(): Promise { + const offen = schlange(); + const rest: Wartend[] = []; + for (const w of offen) { + try { await api(w.pfad, "PUT", w.body); } catch (e) { if (e instanceof TypeError) rest.push(w); /* sonst verwerfen: Server sagt nein */ } + } + sichereSchlange(rest); + return rest.length; +} +window.addEventListener("online", () => { void sendeWartende(); }); + +// ---------- Eingabe eines Tages ---------- + +interface Auswahl { + projekte: { id: string; nummer: string; bezeichnung: string; vorgaenge: { id: string; name: string }[] }[]; + einsaetze: { id: string; name: string; projekt_id: string; anfang: string; ende: string }[]; +} + +function baustellenOptionen(a: Auswahl, datum: string, wert: string): string { + const opt = (v: string, t: string) => ``; + const projekt = new Map(a.projekte.map((p) => [p.id, p])); + const heute = a.einsaetze.filter((e) => e.anfang <= datum && e.ende >= datum); + return (heute.length ? `${heute.map((e) => opt(`v:${e.id}`, `${projekt.get(e.projekt_id)?.nummer ?? ""} ${e.name}`)).join("")}` : "") + + a.projekte.map((p) => `${opt(`p:${p.id}`, `${p.nummer} ganzes Projekt`)}${p.vorgaenge.map((v) => opt(`v:${v.id}`, `${p.nummer} ${v.name}`)).join("")}`).join("") + + `${opt("", "Werkstatt, Lager, Büro …")}`; +} + +export interface Editor { + datum: string; + eintrag: Zeile | null; + angestellt: boolean; + pausenabzug: Abzugsart; + /** Soll des Tages in Stunden für die Vorgabe des Endes */ + soll: number; + auswahl: Auswahl; + speichern(body: unknown): Promise; + loeschen?(): Promise; + fertig(): void; +} + +/** Formular für einen Tag. Rechnet live wie der Server (domain/zeit.ts). */ +export function tagFormular(ziel: HTMLElement, e: Editor): void { + const x = e.eintrag; + const beginn = x?.beginn ?? "07:00"; + const sollMin = Math.round((e.soll || 8) * 60); + const ende = x?.ende ?? uhrzeit(minuten(beginn) + sollMin + (e.angestellt ? regelPause(sollMin + 30) : 0)); + const erster = (a: Auswahl) => a.einsaetze.find((v) => v.anfang <= e.datum && v.ende >= e.datum); + const anteile: Zeile[] = x?.anteile?.length ? x.anteile.map((t: Zeile) => ({ wahl: t.vorgang_id ? `v:${t.vorgang_id}` : t.projekt_id ? `p:${t.projekt_id}` : "", taetigkeit: t.taetigkeit ?? "", stunden: t.stunden })) + : [{ wahl: erster(e.auswahl) ? `v:${erster(e.auswahl)!.id}` : "", taetigkeit: "", stunden: null }]; + + ziel.innerHTML = `
+
+ + + +
+
+ +

+ + +
${x && e.loeschen ? '' : ""} +
+
`; + const form = ziel.querySelector("form")!; + const feld = (n: string) => form.querySelector(`[name="${n}"]`)!; + const anteilZiel = form.querySelector(".anteile")!; + + const zeichneAnteile = () => { + anteilZiel.innerHTML = anteile.map((a, i) => `
+ + + ${anteile.length > 1 ? ` + ` : ""}
`).join(""); + }; + zeichneAnteile(); + + const rechnung = () => { + try { + const an = minuten(feld("ende").value) - minuten(feld("beginn").value); + if (an <= 0) return null; + return rechneTag(an, Number(feld("pause").value), e.angestellt, e.pausenabzug); + } catch { return null; } + }; + const zeigeRechnung = () => { + const r = rechnung(); + const p = form.querySelector(".rechnung")!; + if (!r) { p.textContent = "Ende muss nach dem Beginn liegen."; return; } + const abzug = r.abzug ? ` + ${r.abzug} Min Pausenabzug` : ""; + p.innerHTML = `Arbeitszeit ${dauerText(r.netto)} Std. (da ${dauerText(r.anwesend)}, Pause ${r.handPause} Min${abzug})${r.ueberZehn ? '
Mehr als 10 Std. Arbeitszeit: Das erlaubt das Arbeitszeitgesetz nur ausnahmsweise.' : ""}`; + // Rest auf die letzte Baustelle + if (anteile.length > 1) { + const vorher = anteile.slice(0, -1).reduce((s, a) => s + (Number(a.stunden) || 0), 0); + const letzte = anteilZiel.querySelector(`.anteil[data-i="${anteile.length - 1}"] [data-f="stunden"]`); + if (letzte) letzte.placeholder = `Rest ${zahl(Math.max(0, r.netto / 60 - vorher))}`; + } + }; + zeigeRechnung(); + + form.addEventListener("input", (ev) => { + const t = ev.target as HTMLInputElement; + const i = Number(t.closest(".anteil")?.dataset.i); + if (t.dataset.f && !Number.isNaN(i)) anteile[i]![t.dataset.f] = t.dataset.f === "stunden" ? (t.value ? Number(t.value.replace(",", ".")) : null) : t.value; + zeigeRechnung(); + }); + form.addEventListener("change", () => zeigeRechnung()); + form.addEventListener("click", async (ev) => { + const t = ev.target as HTMLElement; + if (t.dataset.a === "mehr") { anteile.push({ wahl: "", taetigkeit: "", stunden: null }); zeichneAnteile(); zeigeRechnung(); } + if (t.dataset.weg) { anteile.splice(Number(t.dataset.weg), 1); zeichneAnteile(); zeigeRechnung(); } + if (t.dataset.a === "loeschen" && e.loeschen) { await e.loeschen(); e.fertig(); } + }); + form.addEventListener("submit", async (ev) => { + ev.preventDefault(); + const fehler = form.querySelector(".fehler")!; + const r = rechnung(); + if (!r) { fehler.textContent = "Bitte Beginn und Ende prüfen."; return; } + // letzte Baustelle bekommt den Rest + const liste = anteile.map((a) => ({ ...a })); + if (liste.length > 1) { + const vorher = liste.slice(0, -1).reduce((s, a) => s + (Number(a.stunden) || 0), 0); + if (liste.at(-1)!.stunden == null) liste.at(-1)!.stunden = Math.round((r.netto / 60 - vorher) * 100) / 100; + } + const body = { + beginn: feld("beginn").value, ende: feld("ende").value, pause_min: Number(feld("pause").value), notiz: feld("notiz").value || null, + anteile: liste.map((a) => ({ + vorgang_id: a.wahl.startsWith("v:") ? a.wahl.slice(2) : null, projekt_id: a.wahl.startsWith("p:") ? a.wahl.slice(2) : null, + taetigkeit: a.taetigkeit || null, ...(liste.length > 1 ? { stunden: a.stunden } : {}), + })), + }; + const knopf = form.querySelector('button[type="submit"]')!; + knopf.disabled = true; + try { + await e.speichern(body); + e.fertig(); + } catch (err) { + fehler.textContent = (err as Error).message; + knopf.disabled = false; + } + }); +} + +// ---------- Meine Stunden ---------- + +let gewaehlt = ""; + +/** mitUmschalter: Inhaber und Büro sehen oben „Meine | Alle“ */ +export async function meineStunden(mitUmschalter = false): Promise { + const neu = () => meineStunden(mitUmschalter); + const warten = await sendeWartende(); + const tag = gewaehlt || heute(); + const bis = heute(); + const von = plusTage(bis, -34); + const d = await api(`ich/zeiten?von=${von}&bis=${bis}`); + seite("Meine Stunden"); + const kopf = inhalt.querySelector(".kopf h1")!; + kopf.insertAdjacentHTML("afterend", `
+
`); + const eintrag = d.tage.find((t: Zeile) => t.datum === tag) ?? null; + const offen = schlange().find((w) => w.datum === tag); + const karte = document.createElement("section"); + karte.className = "karte stunden-karte"; + karte.innerHTML = `

${tag === bis ? "Heute, " : ""}${WT_LANG[wt(tag)]} ${dat(tag)}

+ ${warten ? `

${warten} Buchung${warten > 1 ? "en warten" : " wartet"} auf Netz und ${warten > 1 ? "werden" : "wird"} gesendet, sobald das Handy wieder online ist.

` : ""} + ${offen ? '

Für diesen Tag wartet eine Buchung ohne Netz.

' : ""}
`; + inhalt.appendChild(karte); + const sollTag = (d.soll as Zeile[]).find((s) => s.datum === tag); + tagFormular(karte.querySelector(".formular")!, { + datum: tag, eintrag, angestellt: d.angestellt, pausenabzug: d.pausenabzug, soll: sollTag?.soll || 8, auswahl: d as unknown as Auswahl, + speichern: async (body) => { + try { + return await api(`ich/zeiten/${tag}`, "PUT", body); + } catch (e) { + if (!(e instanceof TypeError)) throw e; + sichereSchlange([...schlange().filter((w) => w.datum !== tag), { pfad: `ich/zeiten/${tag}`, body, datum: tag }]); + return "wartet"; + } + }, + loeschen: eintrag ? async () => { await api(`ich/zeiten/${tag}`, "DELETE"); } : undefined, + fertig: () => { void neu(); }, + }); + if (mitUmschalter) umschalter(); + + // Liste der letzten Wochen mit Summe je Woche + const wochen = new Map(); + for (const t of [...d.tage].reverse()) { + const mo = plusTage(t.datum, -((wt(t.datum) + 6) % 7)); + wochen.set(mo, [...(wochen.get(mo) ?? []), t]); + } + const liste = document.createElement("section"); + liste.className = "stunden-liste"; + liste.innerHTML = [...wochen].map(([mo, tage]) => { + const summe = tage.reduce((s, t) => s + t.netto_min, 0); + return `

Woche ab ${dat(mo).slice(0, 6)} ${dauerText(summe)} Std.

    ${tage.map((t) => + `
  • `).join("")}
`; + }).join("") || '

Noch keine Stunden gebucht.

'; + inhalt.appendChild(liste); + + const wahl = inhalt.querySelector(".tag-wahl input")!; + wahl.onchange = () => { if (wahl.value) { gewaehlt = wahl.value > bis ? bis : wahl.value; void neu(); } }; + inhalt.querySelectorAll("[data-tag]").forEach((b) => b.onclick = () => { + const neu2 = plusTage(tag, Number(b.dataset.tag)); + if (neu2 <= bis) { gewaehlt = neu2; void neu(); } + }); + liste.onclick = (ev) => { + const b = (ev.target as HTMLElement).closest("[data-datum]"); + if (b) { gewaehlt = b.dataset.datum!; void neu(); window.scrollTo({ top: 0 }); } + }; +} + +// ---------- Alle Stunden (Inhaber und Büro) ---------- + +let monat = heute().slice(0, 7); +let person = ""; +let ansicht = ""; + +const MONATE = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]; +const monatsEnde = (m: string) => new Date(Date.UTC(Number(m.slice(0, 4)), Number(m.slice(5, 7)), 0)).toISOString().slice(0, 10); + +export async function stundenSeite(): Promise { + ansicht ||= lies("betrieb-stunden-ansicht") ?? "alle"; + if (ansicht === "meine") return meineStunden(true); + const von = `${monat}-01`, bis = monatsEnde(monat); + const [d, auswahl, verf] = await Promise.all([ + api(`zeiten?von=${von}&bis=${bis}${person ? `&kontakt_id=${person}` : ""}`), + api(`ich/zeiten?von=${heute()}&bis=${heute()}`), + api(`verfuegbarkeit?von=${von}&bis=${bis}`), + ]); + seite("Stunden"); + umschalter(); + const leiste = inhalt.querySelector(".leiste")!; + leiste.innerHTML = `
${MONATE[Number(monat.slice(5, 7)) - 1]} ${monat.slice(0, 4)}
+ + `; + + // Summen je Person: Ist gegen Soll aus dem Arbeitszeitmodell (abzüglich Urlaub, Krankheit, Feiertage) + const jePerson = new Map(); + for (const t of d.tage) jePerson.set(t.kontakt_id, (jePerson.get(t.kontakt_id) ?? 0) + t.netto_min); + const sollJe = new Map(verf.map((v) => [v.kontakt_id, v.tage.reduce((s: number, t: Zeile) => s + t.frei, 0) * 60])); + const leute = d.leute.filter((l: Zeile) => (!person || l.id === person) && (jePerson.has(l.id) || (l.rolle === "mitarbeiter" && sollJe.has(l.id)))); + inhalt.insertAdjacentHTML("beforeend", `
${leute.map((l: Zeile) => { + const ist = jePerson.get(l.id) ?? 0, soll = l.angestellt ? sollJe.get(l.id) ?? 0 : 0; + return `
${esc(l.name)}${dauerText(ist)} Std.${soll ? `Soll ${dauerText(soll)} · ${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}` : ""}
`; + }).join("")}
`); + + const tabelle = document.createElement("div"); + tabelle.className = "tabelle-rolle"; + tabelle.innerHTML = d.tage.length ? ` + ${d.tage.map((t: Zeile, i: number) => ` + + `).join("")}
TagPersonZeitPauseAbzugArbeitszeitBaustellen
${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}${esc(t.name)}${t.beginn}–${t.ende}${t.pause_min || ""}${t.abzug_min || ""}${dauerText(t.netto_min)}${esc(t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", "))}${t.notiz ? ` ${esc(t.notiz)}` : ""}
` + : '

In diesem Monat sind keine Stunden gebucht.

'; + inhalt.appendChild(tabelle); + + const oeffne = async (t: Zeile | null) => { + const huelle = document.getElementById("dialog-huelle")!; + let kontakt = t?.kontakt_id ?? person ?? ""; + let datum = t?.datum ?? heute(); + const zeichne = async () => { + const l = d.leute.find((x: Zeile) => x.id === kontakt); + const soll = kontakt ? (await api(`verfuegbarkeit?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`))[0]?.tage[0]?.soll : 8; + const vorhanden = t ?? (kontakt ? (await api(`zeiten?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`)).tage[0] ?? null : null); + huelle.innerHTML = `

${t ? `${esc(t.name)}, ${WT[wt(t.datum)]} ${dat(t.datum)}` : "Stunden nachtragen"}

+ ${t ? "" : ` + `}
+
`; + huelle.hidden = false; + const zu = () => { huelle.hidden = true; huelle.innerHTML = ""; }; + huelle.querySelector('[data-a="zu"]')!.onclick = zu; + const np = huelle.querySelector("#n-person"), nd = huelle.querySelector("#n-datum"); + if (np) np.onchange = () => { kontakt = np.value; void zeichne(); }; + if (nd) nd.onchange = () => { datum = nd.value; void zeichne(); }; + if (!kontakt) return; + tagFormular(huelle.querySelector(".formular")!, { + datum, eintrag: vorhanden, angestellt: !!l?.angestellt, pausenabzug: d.pausenabzug, soll: soll || 8, + auswahl: { projekte: auswahl.projekte, einsaetze: [] }, + speichern: (body) => api(`zeiten/${kontakt}/${datum}`, "PUT", body), + loeschen: vorhanden ? () => api(`zeiten/${kontakt}/${datum}`, "DELETE") : undefined, + fertig: () => { zu(); void stundenSeite(); }, + }); + }; + await zeichne(); + }; + + leiste.addEventListener("click", (ev) => { + const b = ev.target as HTMLElement; + if (b.dataset.monat) { + const [j, m] = monat.split("-").map(Number) as [number, number]; + const n = new Date(Date.UTC(j, m - 1 + Number(b.dataset.monat), 1)); + monat = n.toISOString().slice(0, 7); + void stundenSeite(); + } + if (b.dataset.a === "neu") void oeffne(null); + }); + leiste.querySelector("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); }; + tabelle.onclick = (ev) => { + const tr = (ev.target as HTMLElement).closest("tr[data-i]"); + if (tr) void oeffne(d.tage[Number(tr.dataset.i)]); + }; +} + +/** Inhaber und Büro: zwischen eigenen Stunden und allen umschalten */ +function umschalter(): void { + const kopf = inhalt.querySelector(".kopf")!; + kopf.insertAdjacentHTML("beforeend", `
`); + kopf.querySelector(".umschalter")!.addEventListener("click", (ev) => { + const a = (ev.target as HTMLElement).dataset.ansicht; + if (!a || a === ansicht) return; + ansicht = a; + merke("betrieb-stunden-ansicht", a); + void stundenSeite(); + }); +} diff --git a/src/web/styles.css b/src/web/styles.css index 519d84d..cee9c0e 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -481,3 +481,48 @@ dl.werte dd { margin: 0; } .s-tag i { position: absolute; top: 2px; right: 4px; font-style: normal; color: var(--warn); font-weight: 700; } td.zahl, th.zahl { text-align: right; } @media (max-width: 800px) { .personal-raster { grid-template-columns: 1fr; } } + +/* Stunden (Z1): große Felder fürs Handy, mit Handschuhen bedienbar */ +.tag-wahl { display: flex; align-items: center; gap: 6px; } +.tag-wahl input { font: inherit; padding: 7px 8px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); } +.tag-wahl b { min-width: 9em; text-align: center; } +.kopf .tag-wahl { margin-left: auto; } +.stunden-karte { max-width: 640px; } +.stunden-karte h2 { margin: 0 0 10px; font-size: 18px; } +.stunden-form label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; } +.stunden-form select { width: 100%; } +.stunden-form .zeiten select { width: auto; } +.stunden-form input, .stunden-form select { font: inherit; font-size: 17px; color: var(--text); padding: 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--bg); min-width: 0; } +.stunden-form .zeiten { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 10px; } +.stunden-form .anteil { display: grid; grid-template-columns: 1fr; gap: 8px; margin-top: 12px; padding-top: 12px; border-top: 1px dashed var(--linie); } +.stunden-form .anteil:first-child { border-top: 0; padding-top: 0; } +.stunden-form .anteil .std input { max-width: 9em; } +.stunden-form [data-a="mehr"] { margin-top: 10px; } +.stunden-form .rechnung { background: var(--akzent-hell); border-radius: 8px; padding: 10px 12px; margin: 14px 0 0; } +.stunden-form .rechnung b { font-size: 18px; } +.stunden-form .notiz { margin-top: 12px; } +.stunden-form .fehler:empty { display: none; } +.stunden-form .knoepfe { display: flex; gap: 10px; margin-top: 14px; } +.stunden-form .knoepfe .links { margin-right: auto; } +button.haupt.gross { padding: 14px 22px; font-size: 17px; flex: 1; } +.stunden-liste { max-width: 640px; margin-top: 18px; } +.stunden-liste h3 { font-size: 14px; margin: 14px 0 6px; display: flex; justify-content: space-between; color: var(--leise); } +.stunden-liste ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; } +.stunden-liste .eintrag { width: 100%; display: grid; grid-template-columns: 5.5em 7.5em 4em 1fr; gap: 8px; align-items: baseline; text-align: left; font: inherit; color: var(--text); background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; padding: 9px 12px; cursor: pointer; } +.stunden-liste .eintrag small { color: var(--leise); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.umschalter { display: inline-flex; border: 1px solid var(--linie); border-radius: 8px; overflow: hidden; } +.umschalter button { font: inherit; background: var(--fl); color: var(--text); border: 0; padding: 7px 14px; cursor: pointer; } +.umschalter button.aktiv { background: var(--akzent); color: var(--akzent-text); } +.summen { display: flex; flex-wrap: wrap; gap: 10px; margin-bottom: 14px; } +.summen div { display: flex; flex-direction: column; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 10px 14px; min-width: 150px; } +.summen small { color: var(--leise); } +.summen b { font-size: 20px; } +.tabelle-rolle { overflow-x: auto; } +.dialog.breit { width: min(640px, 100%); } +.dialog label select, .dialog label input { display: block; width: 100%; } +@media (max-width: 800px) { + .stunden-liste .eintrag { grid-template-columns: 5em 1fr auto; } + .stunden-liste .eintrag small { grid-column: 1 / -1; } + .kopf { flex-wrap: wrap; gap: 8px; } + .kopf .tag-wahl { margin-left: 0; } +} diff --git a/test/api.test.ts b/test/api.test.ts index cb5e1be..30e032a 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -572,6 +572,55 @@ describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => { expect((await als(jj, "GET", "/api/mitarbeiter")).statusCode).toBe(403); }); + it("Zeiterfassung: ein Eintrag je Tag, Pausenabzug nach M3, Anteile je Vorgang (Z1, E21)", async () => { + const heute = new Date().toISOString().slice(0, 10); + const tag = (n: number) => new Date(Date.now() + n * 86400000).toISOString().slice(0, 10); + const jj = await anmelden("jan", "neuespasswort"); + const ich = (await als(jj, "GET", "/api/ich/zeiten")).json(); + expect(ich.angestellt).toBe(true); + expect(ich.projekte.map((p: { nummer: string }) => p.nummer)).toContain("P-26-101"); + expect(JSON.stringify(ich)).not.toMatch(/umsatz|netto"|lohn/); + const v1 = ich.einsaetze[0]; + expect(v1).toMatchObject({ name: "Abbund" }); + + // 7:00 bis 16:10 ohne Pause: 9:10 da, 40 Min Abzug bis zur Grenze → 8:30 + const r = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "7:00", ende: "16:10", anteile: [{ vorgang_id: v1.id, taetigkeit: "Abbund Sparren" }] }); + expect(r.statusCode, r.body).toBe(200); + expect(r.json()).toMatchObject({ beginn: "07:00", ende: "16:10", pause_min: 0, abzug_min: 40, netto_min: 510, ueber_zehn: false }); + expect(r.json().anteile).toMatchObject([{ vorgang_id: v1.id, projekt_id: v1.projekt_id, stunden: 8.5, taetigkeit: "Abbund Sparren" }]); + // gleicher Tag noch einmal: ersetzt, aufgeteilt auf zwei Baustellen + const p2 = ich.projekte.find((p: { nummer: string }) => p.nummer === "P-26-102"); + const falsch = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 4 }, { projekt_id: p2.id, stunden: 3 }] }); + expect(falsch.statusCode).toBe(400); + expect(falsch.json().fehler).toMatch(/ergeben 7, gearbeitet wurden 8 Stunden/); + const zwei = await als(jj, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "07:00", ende: "15:30", pause_min: 30, anteile: [{ vorgang_id: v1.id, stunden: 5 }, { projekt_id: p2.id, stunden: 3 }] }); + expect(zwei.statusCode, zwei.body).toBe(200); + expect(zwei.json()).toMatchObject({ pause_min: 30, abzug_min: 0, netto_min: 480 }); + expect((await pool.query("select count(*) as n from zeiteintrag")).rows[0].n).toBe(1); + + expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(1)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(400); + expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-20)}`, { beginn: "07:00", ende: "15:00" })).statusCode).toBe(403); + expect((await als(jj, "PUT", `/api/ich/zeiten/${tag(-3)}`, { beginn: "15:00", ende: "07:00" })).statusCode).toBe(400); + expect((await als(jj, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).statusCode).toBe(403); + + // Inhaber bucht für sich selbst: Kontakt entsteht, keine Pausenregel; und trägt für Jan nach + const selbst = await als(inhaber, "PUT", `/api/ich/zeiten/${heute}`, { beginn: "06:00", ende: "17:00", anteile: [{ projekt_id: p2.id }] }); + expect(selbst.statusCode, selbst.body).toBe(200); + expect(selbst.json()).toMatchObject({ abzug_min: 0, netto_min: 660, ueber_zehn: true }); + const jan = (await pool.query("select kontakt_id from benutzer where anmeldename = 'jan'")).rows[0].kontakt_id; + expect((await als(inhaber, "PUT", `/api/zeiten/${jan}/${tag(-20)}`, { beginn: "07:00", ende: "13:00" })).statusCode).toBe(200); + const alle = (await als(inhaber, "GET", `/api/zeiten?von=${tag(-30)}&bis=${heute}`)).json(); + expect(alle.tage).toHaveLength(3); + expect(alle.leute.find((l: { id: string }) => l.id === jan).angestellt).toBe(true); + expect((await als(inhaber, "GET", "/api/zeiten/projekte")).json()).toEqual({ [v1.projekt_id]: 5, [p2.id]: 14 }); + + // 2 Jahre aufbewahren: Kontakt mit Stunden lässt sich nicht löschen; Sicherung enthält die Stunden + expect((await als(inhaber, "DELETE", `/api/kontakte/${jan}`)).statusCode).toBe(409); + const sicherung = (await als(inhaber, "GET", "/api/export")).json(); + expect(sicherung.daten.zeiteintraege).toHaveLength(3); + expect(sicherung.daten.zeitanteile).toHaveLength(4); + }); + it("Testversion: wer gewählt ist, bekommt dessen Rechte", async () => { const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" }); const jan = (await pool.query("select id from benutzer where anmeldename = 'jan'")).rows[0].id; diff --git a/test/zeit.test.ts b/test/zeit.test.ts new file mode 100644 index 0000000..affbecc --- /dev/null +++ b/test/zeit.test.ts @@ -0,0 +1,59 @@ +import { describe, it, expect } from "vitest"; +import { dauerText, minuten, rechneTag, regelPause, uhrzeit } from "../src/domain/zeit.js"; + +const h = (s: string) => minuten(s); + +describe("Pausenabzug nach M3", () => { + it("Regel: bis 6 Std keiner, über 6 bis 9 Std 30 Min, über 9 bis 10 Std 45 Min, über 10 Std 1 Std", () => { + expect([h("6:00"), h("6:01"), h("9:00"), h("9:01"), h("10:00"), h("10:01"), h("12:00")].map(regelPause)).toEqual([0, 30, 30, 45, 45, 60, 60]); + }); + + it.each([ + // Anwesenheit, Abzug bis zur Grenze, Netto, Abzug voll, Netto voll + ["5:59", 0, "5:59", 0, "5:59"], + ["6:00", 0, "6:00", 0, "6:00"], + ["6:10", 10, "6:00", 30, "5:40"], + ["6:30", 30, "6:00", 30, "6:00"], + ["8:30", 30, "8:00", 30, "8:00"], + ["9:00", 30, "8:30", 30, "8:30"], + ["9:10", 40, "8:30", 45, "8:25"], + ["9:20", 45, "8:35", 45, "8:35"], + ["10:00", 45, "9:15", 45, "9:15"], + ["10:10", 55, "9:15", 60, "9:10"], + ["11:00", 60, "10:00", 60, "10:00"], + ])("%s anwesend", (an, abzug, netto, abzugVoll, nettoVoll) => { + const g = rechneTag(h(an), 0, true, "bis_grenze"); + expect([g.abzug, dauerText(g.netto)]).toEqual([abzug, netto]); + const v = rechneTag(h(an), 0, true, "voll"); + expect([v.abzug, dauerText(v.netto)]).toEqual([abzugVoll, nettoVoll]); + }); + + it("länger da sein ergibt bis zur Grenze nie weniger Stunden", () => { + let vorher = 0; + for (let m = 0; m <= 14 * 60; m++) { + const n = rechneTag(m, 0, true).netto; + expect(n).toBeGreaterThanOrEqual(vorher); + vorher = n; + } + }); + + it("von Hand eingetragene Pausen werden angerechnet, der Rest wird abgezogen", () => { + expect(rechneTag(h("7:00"), 15, true)).toMatchObject({ handPause: 15, abzug: 15, netto: h("6:30") }); + expect(rechneTag(h("8:00"), 45, true)).toMatchObject({ handPause: 45, abzug: 0, netto: h("7:15") }); + expect(rechneTag(h("10:30"), 90, true)).toMatchObject({ abzug: 0, netto: h("9:00") }); + }); + + it("nicht für den Inhaber; Hinweis über 10 Std", () => { + expect(rechneTag(h("11:00"), 0, false)).toMatchObject({ abzug: 0, netto: h("11:00"), ueberZehn: true }); + expect(rechneTag(h("11:00"), 0, true).ueberZehn).toBe(false); + expect(rechneTag(h("11:30"), 0, true).ueberZehn).toBe(true); + }); + + it("Uhrzeiten", () => { + expect(minuten("7:05")).toBe(425); + expect(uhrzeit(425)).toBe("07:05"); + expect(minuten("16:30:00")).toBe(990); + expect(() => minuten("25:00")).toThrow(); + expect(dauerText(-30)).toBe("−0:30"); + }); +});