// 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 `${esc(t.feiertag)}`; if (t.soll === 0) return 'frei'; if (a && t.frei === 0) return `${esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt])}`; 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 = { chef: "Chef", planer: "Planer", geselle: "Geselle", helfer: "Helfer" }; let FUNKTIONEN = Object.entries(FUNKTION).filter(([k]) => k !== "chef") as [string, string][]; async function rollenLaden(): Promise { 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 = ``; kopf.addEventListener("click", (ev) => { const t = (ev.target as HTMLElement).closest("[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 { 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(`personal?heute=${heute()}`), api("terminplan"), api("kolonnen"), api("kolonnen-mitglieder"), ]); seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter }); teileLeiste("mitarbeiter"); if (!liste.length) { inhalt.insertAdjacentHTML("beforeend", '

Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.

'); 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 ? ` ${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}` : ""}` }, { 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 ? "" : ' (Vorgabe)'), 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)} von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}` }, { 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 ? '–' : ` ${z.last.anteil} %`) }, { id: "status", titel: "Status", text: (z) => z.status[0], wert: (z) => `${z.status[0]}` }, { id: "zugang", titel: "Zugang", text: (z) => z.anmeldename ?? "", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : 'keiner'), klasse: "optional" }, ], zeilen, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; }, })); } // ---------- Kolonnen ---------- async function kolonnenTeil(): Promise { const [kolonnen, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([ api("kolonnen"), api("kolonnen-mitglieder"), api("kontakte"), api(`personal?heute=${heute()}`), api("subunternehmer"), api("terminplan"), api("einstellungen"), ]); seite("Personal", { text: "Neue Kolonne", aktion: () => void neueKolonne(kontakte) }); teileLeiste("kolonnen"); inhalt.insertAdjacentHTML("beforeend", '

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.

'); if (!kolonnen.length) { inhalt.insertAdjacentHTML("beforeend", '

Noch keine Kolonne. Oben rechts „Neue Kolonne“.

'); 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) => `${esc(z.name)}` }, { 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) => `${z.aktiv ? "aktiv" : "ruht"}` }, ], 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 { 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("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 { const [o, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([ api(`kolonnen/${id}`), api("kolonnen-mitglieder"), api("kontakte"), api(`personal?heute=${heute()}`), api("subunternehmer"), api("terminplan"), api("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", '← Kolonnen'); 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 = `

Kolonne

Leitung
${esc(kontakte.find((k) => k.id === o.leitung_kontakt_id)?.name ?? "–")}
Status
${o.aktiv ? "aktiv, im Terminplan wählbar" : "ruht, im Terminplan nicht wählbar"}
Kapazität
${zahl(kap.personen)} ${kap.personen === 1 ? "Person" : "Personen"}, ${zahl(kap.stunden)} Std. pro Arbeitstag
${o.notiz ? `
Notiz
${esc(o.notiz)}
` : ""}

Mitglieder

${eigene.length ? `${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 ``; }).join("")}
${esc(kName(k))}${k.id === o.leitung_kontakt_id ? ' Leitung' : ""}${esc(rolle)}
` : '

Noch niemand in dieser Kolonne.

'}

Einsätze

Terminplan
${einsaetze.length ? `${einsaetze.map((b: Zeile) => { const p = projektVon(b.v); return ``; }).join("")}
${esc(p ? `${p.nummer} ${p.bezeichnung}` : "")}${esc(b.v.name)}${dat(b.v.anfang)} – ${dat(b.v.ende)} ${b.freigegeben ? 'freigegeben' : 'vorgemerkt'}
` : '

Keine anstehenden Einsätze. Im Terminplan beim Vorgang unter „+ Personal“ die Kolonne wählen.

'}
`; 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("#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 { const [kontakte, subs, kosten, tp] = await Promise.all([api("kontakte"), api("subunternehmer"), api("kosten"), api("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", '

Noch keine Subunternehmer. Oben rechts „Neuer Subunternehmer“, oder einem Kontakt die Rolle „Subunternehmer“ geben.

'); return; } inhalt.appendChild(tabelle({ schluessel: "subunternehmer", einheit: ["Subunternehmer", "Subunternehmer"], spalten: [ { id: "name", titel: "Subunternehmer", text: (z) => subName(z), wert: (z) => `${esc(subName(z))}${z.firma?.trim() && z.name !== z.firma ? ` ${esc(z.name)}` : ""}` }, { 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) => `${esc(z.frei[0])}` }, { 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 { const kontakt = Object.fromEntries(KONTAKT_TEIL.map((f) => [f, d[f]])); const k = kontaktId ? await api(`kontakte/${kontaktId}`, "PATCH", kontakt) : await api("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 { 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 { const [k, subs, kosten, tp, e] = await Promise.all([ api(`kontakte/${kontaktId}`), api("subunternehmer"), api("kosten"), api("terminplan"), api("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", '← Subunternehmer'); 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 = `

Konditionen

Gewerk
${esc(k.gewerk ?? "–")}
Abrechnung
${esc(satzText(s))}
Kolonnengröße
${s?.kolonnengroesse ? `${zahl(Number(s.kolonnengroesse))} Personen` : "–"}
Zahlungsziel
${esc(zahlungText(s))}
Sicherheitseinbehalt
${esc(prozent(s?.einbehalt_prozent) || "–")}
Kontakt
${esc([k.firma?.trim() ? k.name : "", k.telefon, k.email].filter(Boolean).join(" · ") || "–")}
${s?.abrechnung !== "pauschale" && !s?.stundensatz ? '

Mit einem Stundensatz entstehen die Kosten jedes freigegebenen Einsatzes von selbst im Terminplan und in der Liquidität.

' : ""}

Freistellung § 48b

${esc(frei[0])}${s?.freistellung_nr ? ` Nr. ${esc(s.freistellung_nr)}` : ""}

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.

`; inhalt.appendChild(raster); const ziel0 = raster.querySelector("#sub-teil")!; const zeigeTeil = () => { ziel0.innerHTML = ""; raster.querySelectorAll("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === subTeil)); if (subTeil === "einsaetze") { if (!einsaetze.length) { ziel0.innerHTML = '

Noch nicht eingeplant. Im Terminplan beim Vorgang unter „+ Personal“ wählen oder in eine Kolonne aufnehmen.

'; 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 ? ` über ${esc(z.anzeige)}` : ""}` }, { 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 ? 'ohne Satz' : 'nach Freigabe'), klasse: "zahl" }, { id: "status", titel: "Status", text: (z) => (z.freigegeben ? "freigegeben" : "vorgemerkt"), wert: (z) => `${z.freigegeben ? "freigegeben" : "vorgemerkt"}` }, ], klick: () => { location.hash = "terminplan"; }, })); } if (subTeil === "rechnungen") { if (!eigeneKosten.length) { ziel0.innerHTML = '

Noch keine Kosten. Sie entstehen aus freigegebenen Einsätzen mit Stundensatz oder auf der Projektseite unter Kosten.

'; return; } const STATUS_TEXT: Record = { 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 ? ' aus dem Einsatz' : ""}` }, { 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) => `${esc(STATUS_TEXT[z.status] ?? z.status)}` }, ], 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) => `

Offen: ${formatEuro(l.filter((x) => x.status !== "bezahlt").reduce((n, x) => n + Number(x.netto), 0))} · bezahlt: ${formatEuro(l.filter((x) => x.status === "bezahlt").reduce((n, x) => n + Number(x.netto), 0))}

`, })); } if (subTeil === "dokumente") { ziel0.innerHTML = `
Freistellungsbescheinigung § 48b${s?.freistellung_nr ? `Nr. ${esc(s.freistellung_nr)}` : "–"}${esc(frei[0])}

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).

`; } if (subTeil === "ausschreibungen") { ziel0.innerHTML = '

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.

'; } }; zeigeTeil(); raster.addEventListener("click", async (ev) => { const t = ev.target as HTMLElement; const teil = t.closest("[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 { const jahr = Number(heute().slice(0, 4)); const [abw, liste] = await Promise.all([api("abwesenheiten"), api(`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", `
${liste.map((p) => `
${esc(p.name)}${tageText(p.urlaub.rest)}Rest von ${zahl(p.urlaub.anspruch + p.urlaub.uebertrag)}
`).join("")}
${antraege ? `

${antraege} ${antraege === 1 ? "Urlaubsantrag wartet" : "Urlaubsanträge warten"} auf deine Antwort.

` : ""}`); if (!zeilen.length) { inhalt.insertAdjacentHTML("beforeend", `

Keine Abwesenheiten in ${jahr}. Eintragen auf der Seite des Mitarbeiters.

`); 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) => `${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}` }, { 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 { const monat = heute().slice(0, 7); const von = `${monat}-01`; const [d, verf, liste] = await Promise.all([api(`zeiten?von=${von}&bis=${heute()}`), api(`verfuegbarkeit?von=${von}&bis=${heute()}`), api(`personal?heute=${heute()}`)]); seite("Personal"); teileLeiste("zeiten"); const ist = new Map(); 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", `

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 Stunden.

`); 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 ? "–" : `${z.diff >= 0 ? "+" : ""}${zahl(z.diff)} Std.`), klasse: "zahl" }, ], zeilen, klick: () => { location.hash = "stunden"; }, })); } async function neuerMitarbeiter(): Promise { const r = await dialog("Neuer Mitarbeiter", [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }], {}, false); if (r?.aktion !== "speichern") return; const k = await api("kontakte", "POST", { ...r.daten, rolle: "mitarbeiter" }); location.hash = `mitarbeiter-${k.id}`; } export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise { 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(`kontakte/${kontaktId}`), api(`personal?heute=${heute()}`), api("mitarbeiter"), api("arbeitszeitmodelle"), api("abwesenheiten"), api("urlaubskonten"), api(`verfuegbarkeit?von=${heute()}&bis=${bis}&kontakt_id=${kontaktId}`), api("kolonnen"), api("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", '← Personal'); const raster = document.createElement("div"); raster.className = "personal-raster"; const u = ich?.urlaub; raster.innerHTML = `

Stammdaten

Personalnummer
${esc(stamm?.personalnummer ?? "–")}
Eintritt
${stamm?.eintritt ? dat(stamm.eintritt) : "–"}${stamm?.austritt ? ` bis ${dat(stamm.austritt)}` : ""}
Rolle
${esc(FUNKTION[stamm?.funktion] ?? "–")}
Kolonnen
${esc(kolonnenNamen.join(", ") || "–")}
Art
${stamm && !stamm.angestellt ? "Inhaber (keine Pausenregel, keine Lohnübergabe)" : "angestellt"}
${inhaber ? `
Lohnkosten je Stunde
${stamm?.lohn_cent != null ? formatEuro(stamm.lohn_cent) : "–"}
` : ""}
Zugang
${ich?.anmeldename ? esc(ich.anmeldename) : inhaber ? 'anlegen unter Benutzer' : "keiner"}
${modulAn("zeiterfassung") ? `

Urlaub ${jahr}

${u ? `
Anspruch${zahl(u.anspruch)}
Übertrag${zahl(u.uebertrag)}
genommen${zahl(u.genommen)}
geplant${zahl(u.geplant)}
${u.beantragt ? `
beantragt${zahl(u.beantragt)}
` : ""}
Rest${zahl(u.rest)}
` : ""}
` : ""}

Arbeitszeitmodell

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.

Verfügbar in den nächsten 4 Wochen

Abwesenheiten

`; 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 = `

Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}

`; // Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8) const tage: Zeile[] = verf[0]?.tage ?? []; raster.querySelector("#streifen")!.innerHTML = `
${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 `
${WT[wtag(t.datum)]}${dat(t.datum).slice(0, 5)} ${klasse === "voll" || klasse === "teil" ? `${zahl(t.frei)} h` : klasse === "weg" ? esc((a ? ABWESENHEIT_TEXT[a.art as AbwesenheitArt] : "").slice(0, 6)) : ""}${a && a.status === "beantragt" ? "?" : ""}
`; }).join("")}
`; // 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) => `${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}` }, { 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 = '

Keine Abwesenheiten eingetragen.

'; // ---------- Dialoge ---------- async function stammDialog(): Promise { 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 { 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 { 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 { 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); }); }