|
|
|
|
@@ -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)]));
|
|
|
|
|
});
|
|
|
|
|
}
|