Zeiterfassung mit Pausenabzug, offline am Handy, Ansicht für alle (0.9.0)
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:
62
src/domain/zeit.ts
Normal file
62
src/domain/zeit.ts
Normal file
@@ -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;
|
||||
@@ -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"`);
|
||||
|
||||
@@ -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),
|
||||
});
|
||||
|
||||
42
src/server/migrations/009_zeiterfassung.sql
Normal file
42
src/server/migrations/009_zeiterfassung.sql
Normal 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;
|
||||
@@ -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
|
||||
|
||||
@@ -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
200
src/server/zeiten.ts
Normal 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)]));
|
||||
});
|
||||
}
|
||||
@@ -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<void> {
|
||||
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben] = await Promise.all([
|
||||
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt] = await Promise.all([
|
||||
api<Zeile>(`projekte/${id}`), api<Zeile[]>("kontakte"), api<Zeile>("terminplan"),
|
||||
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"),
|
||||
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"), api<Record<string, number>>("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<void> {
|
||||
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 = `<div class="uebersicht-kacheln">
|
||||
${kachel("stunden", "Arbeitsstunden", `<div class="stunden"><div><p class="gross">${stundenText(ist)}</p><p>/ ${soll ? stundenText(soll) : "0:00 Std."}</p></div>
|
||||
<svg class="ring" viewBox="0 0 36 36" role="img" aria-label="${anteil === null ? "keine Stunden geplant" : `${anteil} Prozent verbraucht`}"><circle cx="18" cy="18" r="15.5"/>${anteil ? `<circle class="wert" cx="18" cy="18" r="15.5" pathLength="100" stroke-dasharray="${Math.min(100, anteil)} 100"/>` : ""}<text x="18" y="21.5">${anteil === null ? "– %" : `${anteil} %`}</text></svg></div>
|
||||
<p class="hinweis">Ist-Stunden kommen mit der Zeiterfassung.</p>`)}
|
||||
<svg class="ring" viewBox="0 0 36 36" role="img" aria-label="${anteil === null ? "keine Stunden geplant" : `${anteil} Prozent verbraucht`}"><circle cx="18" cy="18" r="15.5"/>${anteil ? `<circle class="wert" cx="18" cy="18" r="15.5" pathLength="100" stroke-dasharray="${Math.min(100, anteil)} 100"/>` : ""}<text x="18" y="21.5">${anteil === null ? "– %" : `${anteil} %`}</text></svg></div>`)}
|
||||
${kachel("kunde", "Kunde", kunde
|
||||
? `<p><a href="#kontakte" class="gross">${esc(kunde.name)}</a>${kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
|
||||
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>`
|
||||
@@ -750,6 +750,7 @@ async function daten(): Promise<void> {
|
||||
{ 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<void> {
|
||||
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<void> {
|
||||
type Reiter = [string, string, () => Promise<void>];
|
||||
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<string, string> = {
|
||||
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
|
||||
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
|
||||
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
|
||||
stunden: '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
|
||||
personal: '<circle cx="12" cy="7" r="3.5"/><path d="M5 21v-2a5 5 0 0 1 5-5h4a5 5 0 0 1 5 5v2"/><path d="M9 14l3 4 3-4"/>',
|
||||
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
|
||||
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
|
||||
|
||||
334
src/web/stunden.ts
Normal file
334
src/web/stunden.ts
Normal file
@@ -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<number> {
|
||||
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) => `<option value="${esc(v)}"${v === wert ? " selected" : ""}>${esc(t)}</option>`;
|
||||
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 ? `<optgroup label="Eingeteilt">${heute.map((e) => opt(`v:${e.id}`, `${projekt.get(e.projekt_id)?.nummer ?? ""} ${e.name}`)).join("")}</optgroup>` : "")
|
||||
+ a.projekte.map((p) => `<optgroup label="${esc(`${p.nummer} ${p.bezeichnung}`)}">${opt(`p:${p.id}`, `${p.nummer} ganzes Projekt`)}${p.vorgaenge.map((v) => opt(`v:${v.id}`, `${p.nummer} ${v.name}`)).join("")}</optgroup>`).join("")
|
||||
+ `<optgroup label="Ohne Baustelle">${opt("", "Werkstatt, Lager, Büro …")}</optgroup>`;
|
||||
}
|
||||
|
||||
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<Zeile | "wartet">;
|
||||
loeschen?(): Promise<void>;
|
||||
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 = `<form class="stunden-form">
|
||||
<div class="zeiten">
|
||||
<label>Beginn<input type="time" name="beginn" value="${esc(beginn)}" step="300" required></label>
|
||||
<label>Ende<input type="time" name="ende" value="${esc(ende)}" step="300" required></label>
|
||||
<label>Pause<select name="pause">${PAUSEN.map((p) => `<option value="${p}"${p === (x?.pause_min ?? 0) ? " selected" : ""}>${p ? `${p} Min` : "keine"}</option>`).join("")}</select></label>
|
||||
</div>
|
||||
<div class="anteile"></div>
|
||||
<button type="button" class="verweis" data-a="mehr">+ weitere Baustelle am selben Tag</button>
|
||||
<p class="rechnung" aria-live="polite"></p>
|
||||
<label class="notiz">Bemerkung<input name="notiz" value="${esc(x?.notiz ?? "")}" placeholder="optional"></label>
|
||||
<p class="fehler" role="alert"></p>
|
||||
<div class="knoepfe">${x && e.loeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
||||
<button type="submit" class="haupt gross">${x ? "Änderung speichern" : "Speichern"}</button></div>
|
||||
</form>`;
|
||||
const form = ziel.querySelector("form")!;
|
||||
const feld = (n: string) => form.querySelector<HTMLInputElement>(`[name="${n}"]`)!;
|
||||
const anteilZiel = form.querySelector<HTMLElement>(".anteile")!;
|
||||
|
||||
const zeichneAnteile = () => {
|
||||
anteilZiel.innerHTML = anteile.map((a, i) => `<div class="anteil" data-i="${i}">
|
||||
<label>Baustelle${anteile.length > 1 ? ` ${i + 1}` : ""}<select data-f="wahl">${baustellenOptionen(e.auswahl, e.datum, a.wahl)}</select></label>
|
||||
<label>Tätigkeit<input data-f="taetigkeit" value="${esc(a.taetigkeit)}" placeholder="z. B. Abbund, Richten, Eindecken"></label>
|
||||
${anteile.length > 1 ? `<label class="std">Stunden<input data-f="stunden" inputmode="decimal" value="${a.stunden != null ? zahl(a.stunden) : ""}" placeholder="${i === anteile.length - 1 ? "Rest" : ""}"></label>
|
||||
<button type="button" class="verweis" data-weg="${i}" aria-label="Baustelle entfernen">entfernen</button>` : ""}</div>`).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 <b>${dauerText(r.netto)} Std.</b> <small>(da ${dauerText(r.anwesend)}, Pause ${r.handPause} Min${abzug})</small>${r.ueberZehn ? '<br><span class="fehler">Mehr als 10 Std. Arbeitszeit: Das erlaubt das Arbeitszeitgesetz nur ausnahmsweise.</span>' : ""}`;
|
||||
// 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<HTMLInputElement>(`.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<HTMLElement>(".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<HTMLButtonElement>('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<void> {
|
||||
const neu = () => meineStunden(mitUmschalter);
|
||||
const warten = await sendeWartende();
|
||||
const tag = gewaehlt || heute();
|
||||
const bis = heute();
|
||||
const von = plusTage(bis, -34);
|
||||
const d = await api<Zeile>(`ich/zeiten?von=${von}&bis=${bis}`);
|
||||
seite("Meine Stunden");
|
||||
const kopf = inhalt.querySelector(".kopf h1")!;
|
||||
kopf.insertAdjacentHTML("afterend", `<div class="tag-wahl"><button class="neben" data-tag="-1" aria-label="Tag davor">‹</button>
|
||||
<input type="date" value="${tag}" max="${bis}"${d.rueckwirkend ? ` min="${plusTage(bis, -d.rueckwirkend)}"` : ""}><button class="neben" data-tag="1" aria-label="Tag danach"${tag >= bis ? " disabled" : ""}>›</button></div>`);
|
||||
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 = `<h2>${tag === bis ? "Heute, " : ""}${WT_LANG[wt(tag)]} ${dat(tag)}</h2>
|
||||
${warten ? `<p class="warnung">${warten} Buchung${warten > 1 ? "en warten" : " wartet"} auf Netz und ${warten > 1 ? "werden" : "wird"} gesendet, sobald das Handy wieder online ist.</p>` : ""}
|
||||
${offen ? '<p class="hinweis">Für diesen Tag wartet eine Buchung ohne Netz.</p>' : ""}<div class="formular"></div>`;
|
||||
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<string, Zeile[]>();
|
||||
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 `<h3>Woche ab ${dat(mo).slice(0, 6)} <small>${dauerText(summe)} Std.</small></h3><ul>${tage.map((t) =>
|
||||
`<li><button class="eintrag" data-datum="${t.datum}"><span>${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}</span><span>${t.beginn}–${t.ende}</span>
|
||||
<b>${dauerText(t.netto_min)}</b><small>${esc(t.anteile.map((a: Zeile) => a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle").join(", "))}</small></button></li>`).join("")}</ul>`;
|
||||
}).join("") || '<p class="hinweis">Noch keine Stunden gebucht.</p>';
|
||||
inhalt.appendChild(liste);
|
||||
|
||||
const wahl = inhalt.querySelector<HTMLInputElement>(".tag-wahl input")!;
|
||||
wahl.onchange = () => { if (wahl.value) { gewaehlt = wahl.value > bis ? bis : wahl.value; void neu(); } };
|
||||
inhalt.querySelectorAll<HTMLButtonElement>("[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<HTMLElement>("[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<void> {
|
||||
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<Zeile>(`zeiten?von=${von}&bis=${bis}${person ? `&kontakt_id=${person}` : ""}`),
|
||||
api<Zeile>(`ich/zeiten?von=${heute()}&bis=${heute()}`),
|
||||
api<Zeile[]>(`verfuegbarkeit?von=${von}&bis=${bis}`),
|
||||
]);
|
||||
seite("Stunden");
|
||||
umschalter();
|
||||
const leiste = inhalt.querySelector(".leiste")!;
|
||||
leiste.innerHTML = `<div class="tag-wahl"><button class="neben" data-monat="-1" aria-label="Monat davor">‹</button><b>${MONATE[Number(monat.slice(5, 7)) - 1]} ${monat.slice(0, 4)}</b><button class="neben" data-monat="1" aria-label="Monat danach">›</button></div>
|
||||
<select id="person"><option value="">Alle Personen</option>${d.leute.map((l: Zeile) => `<option value="${l.id}"${l.id === person ? " selected" : ""}>${esc(l.name)}${l.rolle === "subunternehmer" ? " (Sub)" : ""}</option>`).join("")}</select>
|
||||
<button class="neben" data-a="neu">+ Stunden nachtragen</button>`;
|
||||
|
||||
// Summen je Person: Ist gegen Soll aus dem Arbeitszeitmodell (abzüglich Urlaub, Krankheit, Feiertage)
|
||||
const jePerson = new Map<string, number>();
|
||||
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", `<div class="summen">${leute.map((l: Zeile) => {
|
||||
const ist = jePerson.get(l.id) ?? 0, soll = l.angestellt ? sollJe.get(l.id) ?? 0 : 0;
|
||||
return `<div><small>${esc(l.name)}</small><b>${dauerText(ist)} Std.</b>${soll ? `<small>Soll ${dauerText(soll)} · <span class="${ist - soll < 0 ? "fehler" : ""}">${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}</span></small>` : ""}</div>`;
|
||||
}).join("")}</div>`);
|
||||
|
||||
const tabelle = document.createElement("div");
|
||||
tabelle.className = "tabelle-rolle";
|
||||
tabelle.innerHTML = d.tage.length ? `<table><thead><tr><th>Tag</th><th>Person</th><th>Zeit</th><th class="zahl">Pause</th><th class="zahl">Abzug</th><th class="zahl">Arbeitszeit</th><th class="optional">Baustellen</th></tr></thead>
|
||||
<tbody>${d.tage.map((t: Zeile, i: number) => `<tr class="klickbar" data-i="${i}"><td>${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}</td><td>${esc(t.name)}</td><td>${t.beginn}–${t.ende}</td>
|
||||
<td class="zahl">${t.pause_min || ""}</td><td class="zahl">${t.abzug_min || ""}</td><td class="zahl"><b>${dauerText(t.netto_min)}</b></td>
|
||||
<td class="optional">${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 ? ` <i>${esc(t.notiz)}</i>` : ""}</td></tr>`).join("")}</tbody></table>`
|
||||
: '<p class="hinweis leer">In diesem Monat sind keine Stunden gebucht.</p>';
|
||||
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<Zeile[]>(`verfuegbarkeit?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`))[0]?.tage[0]?.soll : 8;
|
||||
const vorhanden = t ?? (kontakt ? (await api<Zeile>(`zeiten?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`)).tage[0] ?? null : null);
|
||||
huelle.innerHTML = `<div class="dialog breit"><h2>${t ? `${esc(t.name)}, ${WT[wt(t.datum)]} ${dat(t.datum)}` : "Stunden nachtragen"}</h2>
|
||||
${t ? "" : `<label>Person<select id="n-person"><option value="">– wählen –</option>${d.leute.map((x: Zeile) => `<option value="${x.id}"${x.id === kontakt ? " selected" : ""}>${esc(x.name)}</option>`).join("")}</select></label>
|
||||
<label>Tag<input type="date" id="n-datum" value="${datum}"></label>`}<div class="formular"></div>
|
||||
<div class="knoepfe"><button class="neben" data-a="zu">Schließen</button></div></div>`;
|
||||
huelle.hidden = false;
|
||||
const zu = () => { huelle.hidden = true; huelle.innerHTML = ""; };
|
||||
huelle.querySelector<HTMLElement>('[data-a="zu"]')!.onclick = zu;
|
||||
const np = huelle.querySelector<HTMLSelectElement>("#n-person"), nd = huelle.querySelector<HTMLInputElement>("#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<HTMLSelectElement>("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); };
|
||||
tabelle.onclick = (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest<HTMLElement>("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", `<div class="umschalter" role="tablist"><button role="tab" data-ansicht="meine"${ansicht === "meine" ? ' class="aktiv" aria-selected="true"' : ""}>Meine</button><button role="tab" data-ansicht="alle"${ansicht === "alle" ? ' class="aktiv" aria-selected="true"' : ""}>Alle</button></div>`);
|
||||
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();
|
||||
});
|
||||
}
|
||||
@@ -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; }
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user