Files
Betriebsf-hrungssoftware/src/web/personal.ts
Claude 82da397c96
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.47.0: Kontaktmaske, übergeordnete Kontakte, freie Rollen, Ansprechpartner im Projekt
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-11-08 07:29:16 +00:00

696 lines
53 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Personal (Lastenheft 5.1): Mitarbeiter mit Stammdaten, Arbeitszeitmodell (M8), Abwesenheiten (M4) und Urlaubskonto (M10).
// Inhaber und Büro; den Stundenlohn sieht nur der Inhaber (U2).
import { formatEuro } from "../domain/geld.js";
import { montagDerWoche } from "../domain/datum.js";
import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/personal.js";
import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, modulAn, seite } from "./ui.js";
import { liste as tabelle } from "./liste.js";
import { entscheiden } from "./urlaub.js";
import { stundensaetzeTeil } from "./stundensaetze.js";
const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
const zahl = (h: number | null | undefined) => (h == null ? "" : String(Math.round(h * 100) / 100).replace(".", ","));
const tageText = (n: number) => `${zahl(n)} ${n === 1 ? "Tag" : "Tage"}`;
const wtag = (d: string) => (new Date(`${d}T00:00:00Z`).getUTCDay() + 6) % 7;
const ARTEN = Object.entries(ABWESENHEIT_TEXT) as [AbwesenheitArt, string][];
const STATUS: [string, string][] = [["genehmigt", "genehmigt"], ["beantragt", "beantragt"], ["abgelehnt", "abgelehnt"]];
/** Kurz, was heute ist: „Urlaub“, „4 von 8 Std.“, „8 Std.“, „frei“ */
function heuteText(t: Zeile | undefined): string {
if (!t) return "";
const a = t.abwesend.find((x: Zeile) => x.status === "genehmigt");
if (t.feiertag) return `<span class="marke grau">${esc(t.feiertag)}</span>`;
if (t.soll === 0) return '<span class="marke grau">frei</span>';
if (a && t.frei === 0) return `<span class="marke offen">${esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt])}</span>`;
if (t.frei < t.soll) return `${zahl(t.frei)} von ${zahl(t.soll)} Std.`;
return `${zahl(t.soll)} Std.`;
}
// Rolle = Lohnart der Stundensätze (M17): die Tabellen der heute geltenden Version, sonst Planer, Geselle, Helfer
const FUNKTION: Record<string, string> = { chef: "Chef", planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
let FUNKTIONEN = Object.entries(FUNKTION).filter(([k]) => k !== "chef") as [string, string][];
async function rollenLaden(): Promise<void> {
const l = await api<{ id: string; name: string }[]>("lohnarten").catch(() => null);
if (!l) return;
for (const x of l) FUNKTION[x.id] = x.name;
FUNKTIONEN = l.map((x) => [x.id, x.name]);
}
// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026); Stundensätze nur für den Inhaber (U2)
const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"], ["stundensaetze", "Stundensätze"]];
const subName = (k: Zeile) => (k.firma?.trim() ? k.firma : k.name) as string;
const prozent = (n: number | null | undefined) => (n == null ? "" : `${String(Number(n)).replace(".", ",")} %`);
/** Stunden pro Arbeitstag Mo–Do aus dem Arbeitszeitmodell (Woche Mo … So) */
const tagesStunden = (stunden: number[] | undefined, vorgabe: number) => (stunden ? stunden.slice(0, 4).reduce((s, h) => s + Number(h), 0) / 4 : vorgabe);
/** Urlaub und Zeiten gehören zur Zeiterfassung; beides und die Stundensätze lassen sich abschalten (Henning, 23.10.2026) */
const teilAn = (t: string, inhaber: boolean) =>
t === "stundensaetze" ? inhaber && modulAn("stundensaetze") : t === "urlaub" || t === "zeiten" ? modulAn("zeiterfassung") : true;
function teileLeiste(aktiv: string): void {
const kopf = document.createElement("div");
kopf.className = "teile-kopf personal-teile";
const inhaber = document.body.classList.contains("rolle-inhaber");
kopf.innerHTML = `<nav class="teile">${TEILE.filter(([t]) => teilAn(t, inhaber)).map(([t, titel]) => `<button data-teil="${t}" class="${t === aktiv ? "aktiv" : ""}">${titel}</button>`).join("")}</nav>`;
kopf.addEventListener("click", (ev) => {
const t = (ev.target as HTMLElement).closest<HTMLElement>("[data-teil]")?.dataset.teil;
if (t) location.hash = t === "mitarbeiter" ? "personal" : `personal-${t}`;
});
inhalt.querySelector(".kopf")!.after(kopf);
}
/** Status aus Eintritt und Austritt */
function personStatus(s: Zeile | null): ["aktiv" | "geplant" | "ausgeschieden", string] {
if (s?.austritt && s.austritt < heute()) return ["ausgeschieden", "grau"];
if (s?.eintritt && s.eintritt > heute()) return ["geplant", "offen"];
return ["aktiv", "gut"];
}
export async function personalSeite(teil = "mitarbeiter"): Promise<void> {
if (teil === "kolonnen") return kolonnenTeil();
if (teil === "subunternehmer") return subunternehmerTeil();
if (!teilAn(teil, true)) teil = "mitarbeiter";
if (teil === "urlaub") return urlaubTeil();
if (teil === "zeiten") return zeitenTeil();
if (teil === "stundensaetze") return stundensaetzeTeil(teileLeiste);
const [, liste, tp, kolonnen, mitglieder] = await Promise.all([
rollenLaden(),
api<Zeile[]>(`personal?heute=${heute()}`), api<Zeile>("terminplan"), api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
]);
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
teileLeiste("mitarbeiter");
if (!liste.length) {
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.</p>');
return;
}
// T16: Auslastung der nächsten vier Wochen, eingeplant gegen verfügbar
const wochen = (tp.auslastung ?? []).filter((w: Zeile) => w.ab >= montagDerWoche(heute())).slice(0, 4);
const last = (id: string) => {
const p = wochen.map((w: Zeile) => w.personen.find((x: Zeile) => x.kontakt_id === id)).filter(Boolean);
const geplant = p.reduce((s: number, x: Zeile) => s + x.geplant, 0), verfuegbar = p.reduce((s: number, x: Zeile) => s + x.verfuegbar, 0);
return { geplant, verfuegbar, anteil: verfuegbar > 0 ? Math.round((geplant / verfuegbar) * 100) : null };
};
const kolonnenVon = (id: string) => mitglieder.filter((m) => m.kontakt_id === id).map((m) => kolonnen.find((o) => o.id === m.kolonne_id)?.name).filter(Boolean) as string[];
const zeilen = liste.map((z) => ({ ...z, last: last(z.id), kolonnen: kolonnenVon(z.id), status: personStatus(z.stammdaten) }));
inhalt.appendChild(tabelle({
schluessel: "personal", einheit: ["Person", "Personen"],
spalten: [
{ id: "name", titel: "Name", text: (z) => z.name, wert: (z) => `${esc(z.name)}${z.antraege ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
{ id: "rolle", titel: "Rolle", text: (z) => FUNKTION[z.stammdaten?.funktion] ?? "", wert: (z) => esc(FUNKTION[z.stammdaten?.funktion] ?? "–") },
{ id: "kolonne", titel: "Kolonne", text: (z) => z.kolonnen.join(", "), wert: (z) => esc(z.kolonnen.join(", ") || "–"), klasse: "optional" },
{ id: "arbeitszeit", titel: "Arbeitszeit", text: (z) => modellText(z.stunden), wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), klasse: "optional" },
{ id: "heute", titel: "Heute", wert: (z) => heuteText(z.heute) },
{ id: "rest", titel: "Resturlaub", art: "zahl", text: (z) => tageText(z.urlaub.rest), sortWert: (z) => z.urlaub.rest, wert: (z) => `${tageText(z.urlaub.rest)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
{ id: "auslastung", titel: "Auslastung 4 Wochen", art: "zahl", sortWert: (z) => z.last.anteil ?? -1, text: (z) => (z.last.anteil == null ? "" : `${z.last.anteil} %`),
wert: (z) => (z.last.anteil == null ? '<span class="hinweis">–</span>'
: `<span class="last-anteil${z.last.anteil > 100 ? " ueber" : z.last.anteil < 50 ? " leer" : ""}" title="${zahl(z.last.geplant)} von ${zahl(z.last.verfuegbar)} Std. eingeplant"><i style="width:${Math.min(100, z.last.anteil)}%"></i></span> ${z.last.anteil} %`) },
{ id: "status", titel: "Status", text: (z) => z.status[0], wert: (z) => `<span class="marke ${z.status[1]}">${z.status[0]}</span>` },
{ id: "zugang", titel: "Zugang", text: (z) => z.anmeldename ?? "", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), klasse: "optional" },
],
zeilen, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; },
}));
}
// ---------- Kolonnen ----------
async function kolonnenTeil(): Promise<void> {
const [kolonnen, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([
api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"), api<Zeile[]>("kontakte"), api<Zeile[]>(`personal?heute=${heute()}`),
api<Zeile[]>("subunternehmer"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
]);
seite("Personal", { text: "Neue Kolonne", aktion: () => void neueKolonne(kontakte) });
teileLeiste("kolonnen");
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis">Eine Kolonne fasst Mitarbeiter und Subunternehmer zusammen und lässt sich im Terminplan unter „+ Personal“ als eine Ressource einplanen. Jeder kann in mehreren Kolonnen sein.</p>');
if (!kolonnen.length) { inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Kolonne. Oben rechts „Neue Kolonne“.</p>'); return; }
const kName = (id: string) => { const k = kontakte.find((x) => x.id === id); return k ? (k.rolle === "subunternehmer" ? subName(k) : k.name) : "?"; };
const zeilen = kolonnen.map((o) => {
const ids = mitglieder.filter((m) => m.kolonne_id === o.id).map((m) => m.kontakt_id as string);
const kap = kapazitaet(ids, kontakte, liste, subs, e.stundenProTag);
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kolonne_id === o.id && (tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id)?.ende ?? "") >= heute()).length;
return { ...o, ids, kap, einsaetze, leitung: o.leitung_kontakt_id ? kName(o.leitung_kontakt_id) : "" };
});
inhalt.appendChild(tabelle({
schluessel: "kolonnen", einheit: ["Kolonne", "Kolonnen"],
spalten: [
{ id: "name", titel: "Kolonne", wert: (z) => `<b>${esc(z.name)}</b>` },
{ id: "leitung", titel: "Leitung", wert: (z) => esc(z.leitung || "–") },
{ id: "mitglieder", titel: "Mitglieder", text: (z) => z.ids.map(kName).join(", "), wert: (z) => esc(z.ids.map(kName).join(", ") || "noch niemand") },
{ id: "personen", titel: "Personen", art: "zahl", sortWert: (z) => z.kap.personen, wert: (z) => zahl(z.kap.personen), klasse: "zahl" },
{ id: "kapazitaet", titel: "Kapazität", art: "zahl", sortWert: (z) => z.kap.stunden, wert: (z) => `${zahl(z.kap.stunden)} Std./Tag`, klasse: "zahl" },
{ id: "einsaetze", titel: "Einsätze offen", art: "zahl", sortWert: (z) => z.einsaetze, wert: (z) => String(z.einsaetze), klasse: "zahl" },
{ id: "status", titel: "Status", text: (z) => (z.aktiv ? "aktiv" : "ruht"), wert: (z) => `<span class="marke ${z.aktiv ? "gut" : "grau"}">${z.aktiv ? "aktiv" : "ruht"}</span>` },
],
zeilen, klick: (z) => { location.hash = `kolonne-${z.id}`; },
}));
}
/** Personen und Stunden pro Arbeitstag einer Kolonne: Mitarbeiter nach Arbeitszeitmodell, Subunternehmer mit ihrer Kolonnengröße */
function kapazitaet(ids: string[], kontakte: Zeile[], liste: Zeile[], subs: Zeile[], stundenProTag: number) {
let personen = 0, stunden = 0;
for (const id of ids) {
const k = kontakte.find((x) => x.id === id);
if (k?.rolle === "subunternehmer") {
const n = Number(subs.find((s) => s.kontakt_id === id)?.kolonnengroesse ?? 1);
personen += n; stunden += n * stundenProTag;
} else {
personen += 1; stunden += tagesStunden(liste.find((p) => p.id === id)?.stunden, stundenProTag);
}
}
return { personen, stunden };
}
async function neueKolonne(kontakte: Zeile[]): Promise<void> {
const leute = kontakte.filter((k) => k.rolle === "mitarbeiter").map((k): [string, string] => [k.id, k.name]);
const r = await dialog("Neue Kolonne", [{ name: "name", titel: "Name", pflicht: true, hilfe: "z. B. Kolonne 1 oder Dachkolonne" },
{ name: "leitung_kontakt_id", titel: "Leitung", art: "auswahl", optionen: [["", "– keine –"], ...leute] }], {}, false);
if (r?.aktion !== "speichern") return;
const o = await api<Zeile>("kolonnen", "POST", r.daten);
if (r.daten.leitung_kontakt_id) await api("kolonnen-mitglieder", "POST", { kolonne_id: o.id, kontakt_id: r.daten.leitung_kontakt_id });
location.hash = `kolonne-${o.id}`;
}
export async function kolonneSeite(id: string): Promise<void> {
const [o, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([
api<Zeile>(`kolonnen/${id}`), api<Zeile[]>("kolonnen-mitglieder"), api<Zeile[]>("kontakte"), api<Zeile[]>(`personal?heute=${heute()}`),
api<Zeile[]>("subunternehmer"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
]);
const neuLaden = () => kolonneSeite(id);
const eigene = mitglieder.filter((m) => m.kolonne_id === id);
const ids = eigene.map((m) => m.kontakt_id as string);
const kap = kapazitaet(ids, kontakte, liste, subs, e.stundenProTag);
const leute = kontakte.filter((k) => k.rolle === "mitarbeiter" || k.rolle === "subunternehmer");
const kName = (k: Zeile) => (k.rolle === "subunternehmer" ? subName(k) : k.name);
seite(o.name);
inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '<a class="neben zurueck" href="#personal-kolonnen">← Kolonnen</a>');
const projektVon = (v: Zeile) => tp.projekte.find((p: Zeile) => tp.abschnitte.some((a: Zeile) => a.id === v.abschnitt_id && a.projekt_id === p.id));
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kolonne_id === id).map((b: Zeile) => ({ ...b, v: tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id) }))
.filter((b: Zeile) => b.v && b.v.ende >= heute()).sort((a: Zeile, b: Zeile) => (a.v.anfang < b.v.anfang ? -1 : 1));
const raster = document.createElement("div");
raster.className = "personal-raster";
raster.innerHTML = `
<section class="karte"><div class="karte-kopf"><h2>Kolonne</h2><button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
<dl class="werte">
<dt>Leitung</dt><dd>${esc(kontakte.find((k) => k.id === o.leitung_kontakt_id)?.name ?? "–")}</dd>
<dt>Status</dt><dd>${o.aktiv ? "aktiv, im Terminplan wählbar" : "ruht, im Terminplan nicht wählbar"}</dd>
<dt>Kapazität</dt><dd>${zahl(kap.personen)} ${kap.personen === 1 ? "Person" : "Personen"}, ${zahl(kap.stunden)} Std. pro Arbeitstag</dd>
${o.notiz ? `<dt>Notiz</dt><dd>${esc(o.notiz)}</dd>` : ""}
</dl></section>
<section class="karte"><div class="karte-kopf"><h2>Mitglieder</h2></div>
${eigene.length ? `<table class="einfach"><tbody>${eigene.map((m) => {
const k = kontakte.find((x) => x.id === m.kontakt_id) ?? {};
const st = liste.find((p) => p.id === m.kontakt_id);
const groesse = subs.find((s) => s.kontakt_id === k.id)?.kolonnengroesse;
const rolle = k.rolle === "subunternehmer" ? `Subunternehmer${groesse ? `, ${zahl(Number(groesse))} P.` : ""}`
: FUNKTION[st?.stammdaten?.funktion] ?? "Mitarbeiter";
return `<tr><td>${esc(kName(k))}${k.id === o.leitung_kontakt_id ? ' <span class="marke gut">Leitung</span>' : ""}</td><td class="hinweis">${esc(rolle)}</td>
<td><button class="neben" data-weg="${m.id}" title="Aus der Kolonne nehmen">×</button></td></tr>`;
}).join("")}</tbody></table>` : '<p class="hinweis">Noch niemand in dieser Kolonne.</p>'}
<div class="zeile-dazu"><select id="k-wer" aria-label="Mitglied hinzufügen"><option value="">– hinzufügen –</option>${leute.filter((k) => !ids.includes(k.id)).map((k) => `<option value="${k.id}">${esc(kName(k))} (${k.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"})</option>`).join("")}</select>
<button class="haupt" data-a="dazu">Hinzufügen</button></div>
<p class="fehler" id="k-fehler"></p></section>
<section class="karte breit"><div class="karte-kopf"><h2>Einsätze</h2><a class="neben" href="#terminplan">Terminplan</a></div>
${einsaetze.length ? `<table class="einfach"><tbody>${einsaetze.map((b: Zeile) => { const p = projektVon(b.v); return `<tr><td>${esc(p ? `${p.nummer} ${p.bezeichnung}` : "")}</td><td>${esc(b.v.name)}</td><td>${dat(b.v.anfang)} – ${dat(b.v.ende)}</td>
<td>${b.freigegeben ? '<span class="marke gut">freigegeben</span>' : '<span class="marke offen">vorgemerkt</span>'}</td></tr>`; }).join("")}</tbody></table>`
: '<p class="hinweis">Keine anstehenden Einsätze. Im Terminplan beim Vorgang unter „+ Personal“ die Kolonne wählen.</p>'}</section>`;
inhalt.appendChild(raster);
raster.addEventListener("click", async (ev) => {
const t = ev.target as HTMLElement;
try {
if (t.dataset.weg) { await api(`kolonnen-mitglieder/${t.dataset.weg}`, "DELETE"); return neuLaden(); }
if (t.dataset.a === "dazu") {
const w = raster.querySelector<HTMLSelectElement>("#k-wer")!.value;
if (!w) throw new Error("Bitte jemanden auswählen.");
await api("kolonnen-mitglieder", "POST", { kolonne_id: id, kontakt_id: w });
return neuLaden();
}
if (t.dataset.a === "bearbeiten") {
const r = await dialog("Kolonne", [
{ name: "name", titel: "Name", pflicht: true },
{ name: "leitung_kontakt_id", titel: "Leitung", art: "auswahl", optionen: [["", "– keine –"], ...ids.map((x): [string, string] => [x, kName(kontakte.find((k) => k.id === x) ?? {})])] },
{ name: "aktiv", titel: "Status", art: "auswahl", optionen: [["ja", "aktiv"], ["nein", "ruht (im Terminplan nicht wählbar)"]] },
{ name: "notiz", titel: "Notiz", art: "langtext" },
], { ...o, aktiv: o.aktiv ? "ja" : "nein" }, true);
if (!r) return;
if (r.aktion === "loeschen") { await api(`kolonnen/${id}`, "DELETE"); location.hash = "personal-kolonnen"; return; }
await api(`kolonnen/${id}`, "PATCH", { ...r.daten, aktiv: r.daten.aktiv !== "nein" });
return neuLaden();
}
} catch (e) { raster.querySelector("#k-fehler")!.textContent = (e as Error).message; }
});
}
// ---------- Subunternehmer ----------
/** § 48b: Freistellungsbescheinigung gültig, bald fällig, abgelaufen oder fehlt */
function freistellung(s: Zeile | undefined): [string, string] {
const bis = s?.freistellung_bis as string | undefined;
if (!bis) return ["fehlt", "schlecht"];
if (bis < heute()) return [`abgelaufen seit ${dat(bis)}`, "schlecht"];
const bald = new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 10);
return [`gültig bis ${dat(bis)}`, bis <= bald ? "offen" : "gut"];
}
const satzText = (s: Zeile | undefined) => !s ? "–" : s.abrechnung === "pauschale" ? "Pauschale"
: s.stundensatz != null ? `${formatEuro(Number(s.stundensatz))}/Std.${s.helfersatz != null ? ` · Helfer ${formatEuro(Number(s.helfersatz))}` : ""}` : "–";
const zahlungText = (s: Zeile | undefined) => !s ? "–" : [s.zahlungsziel_tage != null ? `${s.zahlungsziel_tage} Tage` : "",
Number(s.skonto_prozent) > 0 ? `${prozent(s.skonto_prozent)} Skonto${s.skonto_tage != null ? ` in ${s.skonto_tage} Tagen` : ""}` : ""].filter(Boolean).join(" · ") || "–";
async function subunternehmerTeil(): Promise<void> {
const [kontakte, subs, kosten, tp] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("subunternehmer"), api<Zeile[]>("kosten"), api<Zeile>("terminplan")]);
seite("Personal", { text: "Neuer Subunternehmer", aktion: () => void neuerSub() });
teileLeiste("subunternehmer");
const liste = kontakte.filter((k) => k.rolle === "subunternehmer").map((k) => {
const s = subs.find((x) => x.kontakt_id === k.id);
const offen = kosten.filter((x) => x.kontakt_id === k.id && x.status !== "bezahlt").reduce((n, x) => n + Number(x.netto), 0);
const einsaetze = tp.besetzungen.filter((b: Zeile) => (b.kontakt_id === k.id || b.mitglieder?.includes(k.id)) && (tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id)?.ende ?? "") >= heute()).length;
return { ...k, s, offen, einsaetze, frei: freistellung(s) };
});
if (!liste.length) { inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Subunternehmer. Oben rechts „Neuer Subunternehmer“, oder einem Kontakt die Rolle „Subunternehmer“ geben.</p>'); return; }
inhalt.appendChild(tabelle({
schluessel: "subunternehmer", einheit: ["Subunternehmer", "Subunternehmer"],
spalten: [
{ id: "name", titel: "Subunternehmer", text: (z) => subName(z), wert: (z) => `<b>${esc(subName(z))}</b>${z.firma?.trim() && z.name !== z.firma ? ` <small class="hinweis">${esc(z.name)}</small>` : ""}` },
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk ?? "–") },
{ id: "satz", titel: "Stundensatz", text: (z) => satzText(z.s), wert: (z) => esc(satzText(z.s)), sortWert: (z) => Number(z.s?.stundensatz ?? -1) },
{ id: "zahlung", titel: "Zahlung", text: (z) => zahlungText(z.s), wert: (z) => esc(zahlungText(z.s)), klasse: "optional" },
{ id: "einbehalt", titel: "Einbehalt", art: "zahl", sortWert: (z) => Number(z.s?.einbehalt_prozent ?? 0), wert: (z) => esc(prozent(z.s?.einbehalt_prozent) || "–"), klasse: "optional" },
{ id: "freistellung", titel: "§ 48b", text: (z) => z.frei[0], sortWert: (z) => z.s?.freistellung_bis ?? "", wert: (z) => `<span class="marke ${z.frei[1]}">${esc(z.frei[0])}</span>` },
{ id: "einsaetze", titel: "Einsätze offen", art: "zahl", sortWert: (z) => z.einsaetze, wert: (z) => String(z.einsaetze), klasse: "zahl" },
{ id: "offen", titel: "Kosten offen", art: "zahl", sortWert: (z) => z.offen, wert: (z) => (z.offen ? formatEuro(z.offen) : "–"), klasse: "zahl" },
],
zeilen: liste, klick: (z) => { location.hash = `subunternehmer-${z.id}`; },
}));
}
const SUB_FELDER = (): Feld[] => [
{ name: "firma", titel: "Firma" },
{ name: "name", titel: "Ansprechpartner", pflicht: true },
{ name: "gewerk", titel: "Gewerk", hilfe: "z. B. Dachdecker, Trockenbau, Kran" },
{ name: "telefon", titel: "Telefon" },
{ name: "email", titel: "E-Mail" },
{ name: "abrechnung", titel: "Abrechnung", art: "auswahl", optionen: [["stunden", "nach Stunden"], ["pauschale", "Pauschale je Auftrag"]] },
{ name: "stundensatz", titel: "Stundensatz netto (€)", art: "euro", hilfe: "Für die erste Person (Geselle). Mit Satz und Freigabe entstehen die Kosten im Terminplan von selbst." },
{ name: "helfersatz", titel: "Satz je weiterer Person (€)", art: "euro", hilfe: "Leer = derselbe Stundensatz" },
{ name: "kolonnengroesse", titel: "Übliche Kolonnengröße (Personen)", art: "zahl" },
{ name: "zahlungsziel_tage", titel: "Zahlungsziel (Tage)", art: "zahl", hilfe: "Leer = Vorgabe aus den Einstellungen" },
{ name: "skonto_prozent", titel: "Skonto (%)", art: "zahl" },
{ name: "skonto_tage", titel: "Skonto innerhalb von (Tagen)", art: "zahl", hilfe: "Mit Skonto plant die Liquidität die Zahlung zur Skontofrist." },
{ name: "einbehalt_prozent", titel: "Sicherheitseinbehalt (%)", art: "zahl", hilfe: "Wird erst nach der Gewährleistung (5 Jahre) ausgezahlt." },
{ name: "freistellung_nr", titel: "Freistellungsbescheinigung § 48b, Nummer" },
{ name: "freistellung_bis", titel: "Freistellungsbescheinigung gültig bis", art: "datum", hilfe: "30 Tage vor Ablauf kommt eine Warnung in der Übersicht." },
{ name: "notiz", titel: "Notiz", art: "langtext" },
];
const KONTAKT_TEIL = ["firma", "name", "gewerk", "telefon", "email"];
/** Kontakt und Konditionen zusammen speichern */
async function subSpeichern(d: Zeile, kontaktId: string | null, s: Zeile | undefined): Promise<string> {
const kontakt = Object.fromEntries(KONTAKT_TEIL.map((f) => [f, d[f]]));
const k = kontaktId ? await api<Zeile>(`kontakte/${kontaktId}`, "PATCH", kontakt) : await api<Zeile>("kontakte", "POST", { ...kontakt, rolle: "subunternehmer" });
const kond = Object.fromEntries(Object.entries(d).filter(([f]) => !KONTAKT_TEIL.includes(f)));
kond.abrechnung ??= "stunden";
if (s) await api(`subunternehmer/${s.id}`, "PATCH", kond);
else await api("subunternehmer", "POST", { ...kond, kontakt_id: k.id });
return k.id;
}
async function neuerSub(): Promise<void> {
const r = await dialog("Neuer Subunternehmer", SUB_FELDER(), { abrechnung: "stunden" }, false);
if (r?.aktion !== "speichern") return;
location.hash = `subunternehmer-${await subSpeichern(r.daten, null, undefined)}`;
}
let subTeil = "einsaetze";
export async function subunternehmerSeite(kontaktId: string): Promise<void> {
const [k, subs, kosten, tp, e] = await Promise.all([
api<Zeile>(`kontakte/${kontaktId}`), api<Zeile[]>("subunternehmer"), api<Zeile[]>("kosten"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
]);
const s = subs.find((x) => x.kontakt_id === kontaktId);
const neuLaden = () => subunternehmerSeite(kontaktId);
const frei = freistellung(s);
seite(subName(k));
inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '<a class="neben zurueck" href="#personal-subunternehmer">← Subunternehmer</a>');
const projekt = (pid: string) => tp.projekte.find((p: Zeile) => p.id === pid);
const projektVon = (v: Zeile) => projekt(tp.abschnitte.find((a: Zeile) => a.id === v.abschnitt_id)?.projekt_id);
const eigeneKosten = kosten.filter((x) => x.kontakt_id === kontaktId);
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kontakt_id === kontaktId || b.mitglieder?.includes(kontaktId))
.map((b: Zeile) => ({ ...b, v: tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id) })).filter((b: Zeile) => b.v)
.sort((a: Zeile, b: Zeile) => (a.v.anfang < b.v.anfang ? 1 : -1));
const ziel = (x: Zeile) => x.zahlungsziel_tage ?? e.zahlungsziele?.fremdTage ?? 7;
const faellig = (x: Zeile) => new Date(Date.parse(`${x.termin}T00:00:00Z`) + ziel(x) * 86400000).toISOString().slice(0, 10);
const raster = document.createElement("div");
raster.className = "personal-raster";
raster.innerHTML = `
<section class="karte"><div class="karte-kopf"><h2>Konditionen</h2><button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
<dl class="werte">
<dt>Gewerk</dt><dd>${esc(k.gewerk ?? "–")}</dd>
<dt>Abrechnung</dt><dd>${esc(satzText(s))}</dd>
<dt>Kolonnengröße</dt><dd>${s?.kolonnengroesse ? `${zahl(Number(s.kolonnengroesse))} Personen` : "–"}</dd>
<dt>Zahlungsziel</dt><dd>${esc(zahlungText(s))}</dd>
<dt>Sicherheitseinbehalt</dt><dd>${esc(prozent(s?.einbehalt_prozent) || "–")}</dd>
<dt>Kontakt</dt><dd>${esc([k.firma?.trim() ? k.name : "", k.telefon, k.email].filter(Boolean).join(" · ") || "–")}</dd>
</dl>
${s?.abrechnung !== "pauschale" && !s?.stundensatz ? '<p class="hinweis">Mit einem Stundensatz entstehen die Kosten jedes freigegebenen Einsatzes von selbst im Terminplan und in der Liquidität.</p>' : ""}</section>
<section class="karte"><div class="karte-kopf"><h2>Freistellung § 48b</h2></div>
<p><span class="marke ${frei[1]}">${esc(frei[0])}</span>${s?.freistellung_nr ? ` <span class="hinweis">Nr. ${esc(s.freistellung_nr)}</span>` : ""}</p>
<p class="hinweis">Ohne gültige Freistellungsbescheinigung musst du 15 % jeder Rechnung als Bauabzugsteuer einbehalten und ans Finanzamt abführen. 30 Tage vor Ablauf erscheint eine Warnung in der Übersicht.</p></section>
<section class="karte breit projekt-teile"><div class="teile-kopf"><nav class="teile">${([["einsaetze", "Einsätze und Kosten"], ["rechnungen", "Rechnungen"], ["dokumente", "Dokumente"], ["ausschreibungen", "Ausschreibungen"]] as const)
.map(([t, titel]) => `<button data-teil="${t}" class="${t === subTeil ? "aktiv" : ""}">${titel}${t === "rechnungen" && eigeneKosten.length ? ` <small>${eigeneKosten.length}</small>` : ""}</button>`).join("")}</nav></div><div id="sub-teil"></div></section>`;
inhalt.appendChild(raster);
const ziel0 = raster.querySelector<HTMLElement>("#sub-teil")!;
const zeigeTeil = () => {
ziel0.innerHTML = "";
raster.querySelectorAll<HTMLElement>("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === subTeil));
if (subTeil === "einsaetze") {
if (!einsaetze.length) { ziel0.innerHTML = '<p class="hinweis">Noch nicht eingeplant. Im Terminplan beim Vorgang unter „+ Personal“ wählen oder in eine Kolonne aufnehmen.</p>'; return; }
ziel0.appendChild(tabelle({
schluessel: "sub-einsaetze", klein: true, einheit: ["Einsatz", "Einsätze"],
zeilen: einsaetze.map((b: Zeile) => {
const p = projektVon(b.v);
const personen = b.kolonne_id ? Number(s?.kolonnengroesse ?? 1) : Number(b.personen);
const leistung = eigeneKosten.filter((x) => x.besetzung_id === b.id && x.besetzung_teil === "leistung");
return { ...b, projekt: p ? `${p.nummer} ${p.bezeichnung}` : "", personen, stunden: Number(b.v.dauer) * e.stundenProTag * personen,
kosten: leistung.reduce((n, x) => n + Number(x.netto), 0), mitKosten: leistung.length > 0 };
}),
spalten: [
{ id: "projekt", titel: "Projekt", wert: (z) => esc(z.projekt) },
{ id: "vorgang", titel: "Vorgang", wert: (z) => `${esc(z.v.name)}${z.kolonne_id ? ` <small class="hinweis">über ${esc(z.anzeige)}</small>` : ""}` },
{ id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (z) => z.v.anfang, wert: (z) => `${dat(z.v.anfang)} – ${dat(z.v.ende)}` },
{ id: "personen", titel: "Personen", art: "zahl", sortWert: (z) => z.personen, wert: (z) => zahl(z.personen), klasse: "zahl" },
{ id: "stunden", titel: "Stunden", art: "zahl", sortWert: (z) => z.stunden, wert: (z) => zahl(z.stunden), klasse: "zahl" },
{ id: "kosten", titel: "Kosten", art: "zahl", sortWert: (z) => z.kosten, wert: (z) => (z.mitKosten ? formatEuro(z.kosten) : z.freigegeben ? '<span class="hinweis">ohne Satz</span>' : '<span class="hinweis">nach Freigabe</span>'), klasse: "zahl" },
{ id: "status", titel: "Status", text: (z) => (z.freigegeben ? "freigegeben" : "vorgemerkt"), wert: (z) => `<span class="marke ${z.freigegeben ? "gut" : "offen"}">${z.freigegeben ? "freigegeben" : "vorgemerkt"}</span>` },
],
klick: () => { location.hash = "terminplan"; },
}));
}
if (subTeil === "rechnungen") {
if (!eigeneKosten.length) { ziel0.innerHTML = '<p class="hinweis">Noch keine Kosten. Sie entstehen aus freigegebenen Einsätzen mit Stundensatz oder auf der Projektseite unter Kosten.</p>'; return; }
const STATUS_TEXT: Record<string, string> = { geplant: "geplant", bestellt: "Rechnung da", bezahlt: "bezahlt" };
ziel0.appendChild(tabelle({
schluessel: "sub-rechnungen", klein: true, einheit: ["Posten", "Posten"],
zeilen: eigeneKosten.map((x) => ({ ...x, projekt: projekt(x.projekt_id), faellig: faellig(x) })),
spalten: [
{ id: "bezeichnung", titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}${z.automatisch ? ' <small class="hinweis">aus dem Einsatz</small>' : ""}` },
{ id: "projekt", titel: "Projekt", text: (z) => z.projekt?.nummer ?? "", wert: (z) => esc(z.projekt ? `${z.projekt.nummer} ${z.projekt.bezeichnung}` : "") },
{ id: "termin", titel: "Leistung bis", art: "datum", sortWert: (z) => z.termin, wert: (z) => dat(z.termin) },
{ id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig, wert: (z) => dat(z.faellig) },
{ id: "netto", titel: "Betrag netto", art: "zahl", sortWert: (z) => Number(z.netto), wert: (z) => formatEuro(Number(z.netto)), klasse: "zahl" },
{ id: "status", titel: "Status", text: (z) => STATUS_TEXT[z.status] ?? z.status, wert: (z) => `<span class="marke ${z.status === "bezahlt" ? "gut" : z.status === "bestellt" ? "offen" : "grau"}">${esc(STATUS_TEXT[z.status] ?? z.status)}</span>` },
],
klick: (z) => void (async () => {
const r = await dialog(z.bezeichnung, [
{ name: "netto", titel: "Betrag netto (€)", art: "euro", pflicht: true, hilfe: z.automatisch ? "Wer den Betrag ändert, hält ihn fest; er rechnet sich dann nicht mehr aus dem Einsatz." : undefined },
{ name: "termin", titel: "Leistung bis / Rechnungsdatum", art: "datum", pflicht: true },
{ name: "status", titel: "Status", art: "auswahl", optionen: Object.entries(STATUS_TEXT) as [string, string][] },
], z, false);
if (r?.aktion !== "speichern") return;
const daten: Zeile = { termin: r.daten.termin, status: r.daten.status };
if (r.daten.netto !== Number(z.netto)) daten.netto = r.daten.netto;
await api(`kosten/${z.id}`, "PATCH", daten);
void neuLaden();
})(),
fuss: (l) => `<p>Offen: <strong>${formatEuro(l.filter((x) => x.status !== "bezahlt").reduce((n, x) => n + Number(x.netto), 0))}</strong> · bezahlt: ${formatEuro(l.filter((x) => x.status === "bezahlt").reduce((n, x) => n + Number(x.netto), 0))}</p>`,
}));
}
if (subTeil === "dokumente") {
ziel0.innerHTML = `<table class="einfach"><tbody><tr><td>Freistellungsbescheinigung § 48b</td><td>${s?.freistellung_nr ? `Nr. ${esc(s.freistellung_nr)}` : "–"}</td><td><span class="marke ${frei[1]}">${esc(frei[0])}</span></td></tr></tbody></table>
<p class="hinweis">Verträge, Nachweise und die Bescheinigung selbst legst du vorerst in der Nextcloud ab. Eine Ablage hier kommt mit der Baustelle am Handy (Stufe 4).</p>`;
}
if (subTeil === "ausschreibungen") {
ziel0.innerHTML = '<p class="hinweis">Ausschreibungen an Subunternehmer entstehen mit dem Angebotsmodul (Stufe 5): Positionen aus deinem Angebot an mehrere Subunternehmer schicken, Preise vergleichen und den günstigsten übernehmen. Sie erscheinen dann hier.</p>';
}
};
zeigeTeil();
raster.addEventListener("click", async (ev) => {
const t = ev.target as HTMLElement;
const teil = t.closest<HTMLElement>("[data-teil]")?.dataset.teil;
if (teil) { subTeil = teil; zeigeTeil(); return; }
if (t.dataset.a === "bearbeiten") {
const werte = { ...k, ...(s ?? { abrechnung: "stunden" }), id: undefined };
const r = await dialog(subName(k), SUB_FELDER(), werte, false);
if (r?.aktion !== "speichern") return;
await subSpeichern(r.daten, kontaktId, s);
void neuLaden();
}
});
}
// ---------- Urlaub und Zeiten aller ----------
async function urlaubTeil(): Promise<void> {
const jahr = Number(heute().slice(0, 4));
const [abw, liste] = await Promise.all([api<Zeile[]>("abwesenheiten"), api<Zeile[]>(`personal?heute=${heute()}`)]);
seite("Personal");
teileLeiste("urlaub");
const name = (id: string) => liste.find((p) => p.id === id)?.name ?? "";
const zeilen: Zeile[] = abw.filter((a) => a.bis >= `${jahr}-01-01` && liste.some((p) => p.id === a.kontakt_id)).map((a) => ({ ...a, name: name(a.kontakt_id) }));
const antraege = zeilen.filter((a) => a.status === "beantragt").length;
inhalt.insertAdjacentHTML("beforeend", `<div class="summen">${liste.map((p) => `<div><small>${esc(p.name)}</small><b>${tageText(p.urlaub.rest)}</b><small>Rest von ${zahl(p.urlaub.anspruch + p.urlaub.uebertrag)}</small></div>`).join("")}</div>
${antraege ? `<p class="warnung">${antraege} ${antraege === 1 ? "Urlaubsantrag wartet" : "Urlaubsanträge warten"} auf deine Antwort.</p>` : ""}`);
if (!zeilen.length) { inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis leer">Keine Abwesenheiten in ${jahr}. Eintragen auf der Seite des Mitarbeiters.</p>`); return; }
inhalt.appendChild(tabelle({
schluessel: "urlaub-alle", einheit: ["Abwesenheit", "Abwesenheiten"],
vorgabe: { sort: [["zeitraum", "auf"]] },
spalten: [
{ id: "name", titel: "Person", wert: (a) => esc(a.name) },
{ id: "art", titel: "Art", text: (a) => ABWESENHEIT_TEXT[a.art as AbwesenheitArt], wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) },
{ id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (a) => a.von, wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) },
{ id: "umfang", titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags"), klasse: "optional" },
{ id: "status", titel: "Status", text: (a) => a.status, wert: (a) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
{ id: "notiz", titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" },
],
zeilen, klick: (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void urlaubTeil(); }) : (location.hash = `mitarbeiter-${a.kontakt_id}`)),
}));
}
async function zeitenTeil(): Promise<void> {
const monat = heute().slice(0, 7);
const von = `${monat}-01`;
const [d, verf, liste] = await Promise.all([api<Zeile>(`zeiten?von=${von}&bis=${heute()}`), api<Zeile[]>(`verfuegbarkeit?von=${von}&bis=${heute()}`), api<Zeile[]>(`personal?heute=${heute()}`)]);
seite("Personal");
teileLeiste("zeiten");
const ist = new Map<string, number>();
for (const t of d.tage) ist.set(t.kontakt_id, (ist.get(t.kontakt_id) ?? 0) + t.netto_min / 60);
const zeilen = liste.map((p) => {
const soll = p.stammdaten && !p.stammdaten.angestellt ? 0 : (verf.find((v) => v.kontakt_id === p.id)?.tage ?? []).reduce((s: number, t: Zeile) => s + t.frei, 0);
const i = ist.get(p.id) ?? 0;
return { ...p, ist: i, soll, diff: soll ? i - soll : null, tage: d.tage.filter((t: Zeile) => t.kontakt_id === p.id).length };
});
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Gebuchte Stunden vom 1. bis heute gegen das Soll aus dem Arbeitszeitmodell (ohne Urlaub, Krankheit, Feiertage). Einzelne Tage, Nachtragen und die Stundenliste fürs Steuerbüro stehen unter <a href="#stunden">Stunden</a>.</p>`);
inhalt.appendChild(tabelle({
schluessel: "zeiten-alle", einheit: ["Person", "Personen"],
spalten: [
{ id: "name", titel: "Person", wert: (z) => esc(z.name) },
{ id: "tage", titel: "Tage gebucht", art: "zahl", sortWert: (z) => z.tage, wert: (z) => String(z.tage), klasse: "zahl" },
{ id: "ist", titel: "Ist", art: "zahl", sortWert: (z) => z.ist, wert: (z) => `${zahl(z.ist)} Std.`, klasse: "zahl" },
{ id: "soll", titel: "Soll bis heute", art: "zahl", sortWert: (z) => z.soll, wert: (z) => (z.soll ? `${zahl(z.soll)} Std.` : "–"), klasse: "zahl" },
{ id: "diff", titel: "Differenz", art: "zahl", sortWert: (z) => z.diff ?? 0, wert: (z) => (z.diff == null ? "–" : `<span class="${z.diff < 0 ? "fehler" : ""}">${z.diff >= 0 ? "+" : ""}${zahl(z.diff)} Std.</span>`), klasse: "zahl" },
],
zeilen, klick: () => { location.hash = "stunden"; },
}));
}
const ROLLE_TEXT: Record<string, string> = { bauherr: "Bauherr", subunternehmer: "Subunternehmer", lieferant: "Lieferant", planer: "Planer", sonstige: "Sonstige" };
// Mitarbeiter aus den Kontakten wählen, wie den Kunden im Projekt (Henning, 08.11.2026); ein neuer Kontakt entsteht direkt als Mitarbeiter
async function neuerMitarbeiter(): Promise<void> {
const kontakte = (await api<Zeile[]>("kontakte")).filter((k) => k.rolle !== "mitarbeiter").sort((a, b) => a.name.localeCompare(b.name, "de"));
const r = await dialog("Neuer Mitarbeiter", [{
name: "kontakt_id", titel: "Kontakt", art: "auswahl", pflicht: true,
optionen: [["", "– aus den Kontakten wählen –"], ...kontakte.map((k): [string, string] => [k.id, `${k.name}${k.firma && k.firma !== k.name ? ` · ${k.firma}` : ""}${ROLLE_TEXT[k.rolle] ? ` (${ROLLE_TEXT[k.rolle]})` : ""}`])],
hilfe: "Ein vorhandener Kontakt wird zum Mitarbeiter; Telefon, E-Mail und Adresse bleiben an einer Stelle.",
neu: { text: "+ Neuer Kontakt …", titel: "Neuen Kontakt anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" }],
anlegen: async (d) => { const k = await api<Zeile>("kontakte", "POST", { ...d, rolle: "mitarbeiter" }); return [k.id, k.name]; } },
}], {}, false);
if (r?.aktion !== "speichern" || !r.daten.kontakt_id) return;
const id = String(r.daten.kontakt_id);
if (kontakte.some((k) => k.id === id)) await api(`kontakte/${id}`, "PATCH", { rolle: "mitarbeiter" });
location.hash = `mitarbeiter-${id}`;
}
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
const jahr = Number(heute().slice(0, 4));
const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10);
await rollenLaden();
const [kontakt, liste, alleStamm, modelle, abw, konten, verf, kolonnen, mitglieder] = await Promise.all([
api<Zeile>(`kontakte/${kontaktId}`),
api<Zeile[]>(`personal?heute=${heute()}`),
api<Zeile[]>("mitarbeiter"),
api<Zeile[]>("arbeitszeitmodelle"),
api<Zeile[]>("abwesenheiten"),
api<Zeile[]>("urlaubskonten"),
api<Zeile[]>(`verfuegbarkeit?von=${heute()}&bis=${bis}&kontakt_id=${kontaktId}`),
api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
]);
const kolonnenNamen = mitglieder.filter((m) => m.kontakt_id === kontaktId).map((m) => kolonnen.find((o) => o.id === m.kolonne_id)?.name).filter(Boolean) as string[];
const ich = liste.find((x) => x.id === kontaktId);
const stamm = alleStamm.find((m) => m.kontakt_id === kontaktId) ?? null;
const eigeneModelle = modelle.filter((m) => m.kontakt_id === kontaktId).sort((a, b) => (a.gueltig_ab < b.gueltig_ab ? 1 : -1));
const eigeneAbw = abw.filter((a) => a.kontakt_id === kontaktId && a.bis >= `${jahr - 1}-01-01`).sort((a, b) => (a.von < b.von ? 1 : -1));
const konto = konten.find((k) => k.kontakt_id === kontaktId && k.jahr === jahr) ?? null;
const neuLaden = () => mitarbeiterSeite(kontaktId, inhaber);
seite(kontakt.name);
inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '<a class="neben zurueck" href="#personal">← Personal</a>');
const raster = document.createElement("div");
raster.className = "personal-raster";
const u = ich?.urlaub;
const kAdresse = [kontakt.strasse, [kontakt.plz, kontakt.ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
raster.innerHTML = `
<section class="karte"><div class="karte-kopf"><h2>Kontakt</h2><a class="neben knopf" href="#kontakt-${esc(kontaktId)}">Bearbeiten</a></div>
<dl class="werte">
<dt>Telefon</dt><dd>${kontakt.telefon ? `<a href="tel:${esc(kontakt.telefon)}">${esc(kontakt.telefon)}</a>` : "–"}</dd>
<dt>Mobil</dt><dd>${kontakt.mobil ? `<a href="tel:${esc(kontakt.mobil)}">${esc(kontakt.mobil)}</a>` : "–"}</dd>
<dt>E-Mail</dt><dd>${kontakt.email ? `<a href="mailto:${esc(kontakt.email)}">${esc(kontakt.email)}</a>` : "–"}</dd>
<dt>Adresse</dt><dd>${esc(kAdresse || "–")}</dd>
</dl><p class="hinweis">Steht auch unter <a href="#kontakte">Kontakte</a>; Änderungen gelten an beiden Stellen.</p></section>
<section class="karte"><div class="karte-kopf"><h2>Stammdaten</h2><button class="neben" data-a="stamm">Bearbeiten</button></div>
<dl class="werte">
<dt>Personalnummer</dt><dd>${esc(stamm?.personalnummer ?? "–")}</dd>
<dt>Eintritt</dt><dd>${stamm?.eintritt ? dat(stamm.eintritt) : "–"}${stamm?.austritt ? ` bis ${dat(stamm.austritt)}` : ""}</dd>
<dt>Rolle</dt><dd>${esc(FUNKTION[stamm?.funktion] ?? "–")}</dd>
<dt>Kolonnen</dt><dd>${esc(kolonnenNamen.join(", ") || "–")}</dd>
<dt>Art</dt><dd>${stamm && !stamm.angestellt ? "Inhaber (keine Pausenregel, keine Lohnübergabe)" : "angestellt"}</dd>
${inhaber ? `<dt>Lohnkosten je Stunde</dt><dd>${stamm?.lohn_cent != null ? formatEuro(stamm.lohn_cent) : "–"}</dd>` : ""}
<dt>Zugang</dt><dd>${ich?.anmeldename ? esc(ich.anmeldename) : inhaber ? '<a href="#benutzer">anlegen unter Benutzer</a>' : "keiner"}</dd>
</dl></section>
${modulAn("zeiterfassung") ? `<section class="karte"><div class="karte-kopf"><h2>Urlaub ${jahr}</h2><button class="neben" data-a="konto">Anspruch und Übertrag</button></div>
${u ? `<div class="urlaub-zahlen">
<div><small>Anspruch</small><b>${zahl(u.anspruch)}</b></div><div><small>Übertrag</small><b>${zahl(u.uebertrag)}</b></div>
<div><small>genommen</small><b>${zahl(u.genommen)}</b></div><div><small>geplant</small><b>${zahl(u.geplant)}</b></div>
${u.beantragt ? `<div><small>beantragt</small><b>${zahl(u.beantragt)}</b></div>` : ""}<div class="rest"><small>Rest</small><b>${zahl(u.rest)}</b></div></div>` : ""}
</section>` : ""}
<section class="karte breit"><div class="karte-kopf"><h2>Arbeitszeitmodell</h2><button class="neben" data-a="modell">+ Neues Modell</button></div>
<p class="hinweis">Stunden je Wochentag. Ein neues Modell gilt ab seinem Datum; was davor liegt, bleibt unverändert. Geplant wird nur Montag bis Donnerstag, der Freitag ist Reserve.</p>
<div id="modelle"></div></section>
<section class="karte breit"><div class="karte-kopf"><h2>Verfügbar in den nächsten 4 Wochen</h2></div><div id="streifen"></div></section>
<section class="karte breit"><div class="karte-kopf"><h2>Abwesenheiten</h2><button class="neben" data-a="abw">+ Abwesenheit</button></div><div id="abw"></div></section>`;
inhalt.appendChild(raster);
// Modelle
const mZiel = raster.querySelector("#modelle")!;
if (eigeneModelle.length) {
mZiel.appendChild(tabelle({
schluessel: "arbeitszeitmodelle", klein: true,
spalten: [
{ id: "ab", titel: "Gültig ab", art: "datum", wert: (m) => dat(m.gueltig_ab), sortWert: (m) => m.gueltig_ab },
...WT.map((t, i) => ({ id: `t${i}`, titel: t, art: "zahl" as const, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", sortWert: (m: Zeile) => m.stunden[i], klasse: "zahl" })),
{ id: "woche", titel: "Woche", art: "zahl", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, sortWert: (m) => m.stunden.reduce((s: number, h: number) => s + h, 0), klasse: "zahl" },
],
zeilen: eigeneModelle, klick: (m) => void modellDialog(m),
}));
} else mZiel.innerHTML = `<p class="hinweis">Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}</p>`;
// Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8)
const tage: Zeile[] = verf[0]?.tage ?? [];
raster.querySelector("#streifen")!.innerHTML = `<div class="streifen">${tage.map((t) => {
const a = t.abwesend[0];
const klasse = t.soll === 0 ? "aus" : t.frei === 0 ? "weg" : t.frei < t.soll ? "teil" : "voll";
const titel = `${WT[wtag(t.datum)]} ${dat(t.datum)}: ${t.feiertag ?? (a ? `${ABWESENHEIT_TEXT[a.art as AbwesenheitArt]}${a.status !== "genehmigt" ? ` (${a.status})` : ""}` : "")} ${zahl(t.frei)} von ${zahl(t.soll)} Std. frei`;
return `<div class="s-tag ${klasse}${wtag(t.datum) === 0 ? " montag" : ""}" title="${esc(titel)}"><small>${WT[wtag(t.datum)]}</small><span>${dat(t.datum).slice(0, 5)}</span>
<b>${klasse === "voll" || klasse === "teil" ? `${zahl(t.frei)} h` : klasse === "weg" ? esc((a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "").slice(0, 6)) : ""}</b>${a && a.status === "beantragt" ? "<i>?</i>" : ""}</div>`;
}).join("")}</div>`;
// Abwesenheiten
const aZiel = raster.querySelector("#abw")!;
if (eigeneAbw.length) aZiel.appendChild(tabelle({
schluessel: "abwesenheiten", klein: true, einheit: ["Abwesenheit", "Abwesenheiten"],
spalten: [
{ id: "art", titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) },
{ id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (a) => a.von, wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) },
{ id: "umfang", titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") },
{ id: "status", titel: "Status", text: (a) => a.status, wert: (a) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
{ id: "notiz", titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" },
],
zeilen: eigeneAbw, klick: (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void neuLaden(); }) : abwDialog(a)),
}));
else aZiel.innerHTML = '<p class="hinweis">Keine Abwesenheiten eingetragen.</p>';
// ---------- Dialoge ----------
async function stammDialog(): Promise<void> {
const felder: Feld[] = [
{ name: "funktion", titel: "Rolle", art: "auswahl", optionen: [["", "– offen –"], ...FUNKTIONEN], hilfe: "Wie die Lohnarten der Kalkulation" },
{ name: "personalnummer", titel: "Personalnummer (für das Steuerbüro)" },
{ name: "eintritt", titel: "Eintritt", art: "datum" },
{ name: "austritt", titel: "Austritt", art: "datum" },
{ name: "angestellt", titel: "Art", art: "auswahl", optionen: [["ja", "angestellt"], ["nein", "Inhaber (keine Pausenregel, keine Lohnübergabe)"]] },
...(inhaber ? [{ name: "lohn", titel: "Lohnkosten je Stunde (€)", art: "euro" as const, hilfe: "Nur für dich sichtbar; für die Nachkalkulation." }] : []),
{ name: "urlaubstage", titel: "Urlaubsanspruch je Jahr (Tage)", art: "zahl" },
];
const werte = { ...(stamm ?? { urlaubstage: 30 }), angestellt: stamm && !stamm.angestellt ? "nein" : "ja", lohn: stamm?.lohn_cent ?? null };
const r = await dialog("Stammdaten", felder, werte, false);
if (r?.aktion !== "speichern") return;
const d = r.daten;
const daten: Zeile = { funktion: d.funktion, personalnummer: d.personalnummer, eintritt: d.eintritt, austritt: d.austritt, angestellt: d.angestellt !== "nein", urlaubstage: d.urlaubstage ?? 30 };
if (inhaber) daten.lohn_cent = d.lohn;
if (stamm) await api(`mitarbeiter/${stamm.id}`, "PATCH", daten);
else await api("mitarbeiter", "POST", { ...daten, kontakt_id: kontaktId });
neuLaden();
}
async function kontoDialog(): Promise<void> {
const felder: Feld[] = [
{ name: "anspruch", titel: `Anspruch ${jahr} (leer = ${zahl(stamm ? Number(stamm.urlaubstage) : 30)} aus den Stammdaten)`, art: "zahl" },
{ name: "uebertrag", titel: `Resturlaub aus ${jahr - 1}`, art: "zahl" },
];
const r = await dialog(`Urlaub ${jahr}`, felder, konto ?? {}, false);
if (r?.aktion !== "speichern") return;
const daten = { anspruch: r.daten.anspruch, uebertrag: r.daten.uebertrag ?? 0 };
if (konto) await api(`urlaubskonten/${konto.id}`, "PATCH", daten);
else await api("urlaubskonten", "POST", { ...daten, kontakt_id: kontaktId, jahr });
neuLaden();
}
async function modellDialog(m: Zeile | null): Promise<void> {
const vorlage = m?.stunden ?? eigeneModelle[0]?.stunden ?? ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0];
const felder: Feld[] = [
{ name: "gueltig_ab", titel: "Gültig ab", art: "datum", pflicht: true },
...WT.map((t, i): Feld => ({ name: `t${i}`, titel: `${t} (Std.)`, art: "zahl" })),
];
const werte: Zeile = { gueltig_ab: m?.gueltig_ab ?? heute(), ...Object.fromEntries(vorlage.map((h: number, i: number) => [`t${i}`, zahl(h)])) };
const r = await dialog(m ? "Arbeitszeitmodell" : "Neues Arbeitszeitmodell", felder, werte, !!m);
if (!r) return;
if (r.aktion === "loeschen") await api(`arbeitszeitmodelle/${m!.id}`, "DELETE");
else {
const daten = { gueltig_ab: r.daten.gueltig_ab, stunden: WT.map((_, i) => r.daten[`t${i}`] ?? 0) };
if (m) await api(`arbeitszeitmodelle/${m.id}`, "PATCH", daten);
else await api("arbeitszeitmodelle", "POST", { ...daten, kontakt_id: kontaktId });
}
neuLaden();
}
async function abwDialog(a: Zeile | null): Promise<void> {
const felder: Feld[] = [
{ name: "art", titel: "Art", art: "auswahl", optionen: ARTEN },
{ name: "von", titel: "Von", art: "datum", pflicht: true },
{ name: "bis", titel: "Bis (leer = nur ein Tag)", art: "datum" },
{ name: "umfang", titel: "Umfang", art: "auswahl", optionen: [["ganz", "ganztags"], ["halb", "halber Tag (nur ein Tag)"], ["stunden", "einige Stunden"]] },
{ name: "stunden", titel: "Stunden nicht verfügbar (bei „einige Stunden“)", art: "zahl", hilfe: "Beispiel „Do nur bis 12 Uhr“ bei 8 Std.: 4 eintragen." },
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
{ name: "notiz", titel: "Notiz" },
...(a?.status === "beantragt" || a?.antwort ? [{ name: "antwort", titel: "Antwort an den Mitarbeiter" }] : []),
];
const werte: Zeile = a ? { ...a, umfang: a.halbtag ? "halb" : a.stunden ? "stunden" : "ganz", stunden: zahl(a.stunden) } : { art: "urlaub", von: heute(), umfang: "ganz", status: "genehmigt" };
const r = await dialog(a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "Neue Abwesenheit", felder, werte, !!a);
if (!r) return;
if (r.aktion === "loeschen") await api(`abwesenheiten/${a!.id}`, "DELETE");
else {
const d = r.daten;
const daten: Zeile = { art: d.art, von: d.von, bis: d.bis || d.von, halbtag: d.umfang === "halb", stunden: d.umfang === "stunden" ? d.stunden : null, status: d.status, notiz: d.notiz };
if ("antwort" in d) daten.antwort = d.antwort;
if (a) await api(`abwesenheiten/${a.id}`, "PATCH", daten);
else await api("abwesenheiten", "POST", { ...daten, kontakt_id: kontaktId });
}
neuLaden();
}
raster.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (a === "stamm") void stammDialog();
if (a === "konto") void kontoDialog();
if (a === "modell") void modellDialog(null);
if (a === "abw") void abwDialog(null);
});
}