Personal mit Reitern, Kolonnen, Subunternehmer mit Kosten und § 48b, % erledigt im Terminplan (0.15.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
// 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, seite } from "./ui.js";
|
||||
import { liste as tabelle } from "./liste.js";
|
||||
@@ -25,23 +26,452 @@ function heuteText(t: Zeile | undefined): string {
|
||||
return `${zahl(t.soll)} Std.`;
|
||||
}
|
||||
|
||||
export async function personalSeite(): Promise<void> {
|
||||
const liste = await api<Zeile[]>(`personal?heute=${heute()}`);
|
||||
const FUNKTION: Record<string, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
|
||||
const FUNKTIONEN = Object.entries(FUNKTION) as [string, string][];
|
||||
// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026)
|
||||
const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"]];
|
||||
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);
|
||||
|
||||
function teileLeiste(aktiv: string): void {
|
||||
const kopf = document.createElement("div");
|
||||
kopf.className = "teile-kopf personal-teile";
|
||||
kopf.innerHTML = `<nav class="teile">${TEILE.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 (teil === "urlaub") return urlaubTeil();
|
||||
if (teil === "zeiten") return zeitenTeil();
|
||||
const [liste, tp, kolonnen, mitglieder] = await Promise.all([
|
||||
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: liste, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; },
|
||||
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"; },
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -55,7 +485,7 @@ async function neuerMitarbeiter(): Promise<void> {
|
||||
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);
|
||||
const [kontakt, liste, alleStamm, modelle, abw, konten, verf] = await Promise.all([
|
||||
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"),
|
||||
@@ -63,7 +493,9 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
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));
|
||||
@@ -81,6 +513,8 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
<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>
|
||||
@@ -140,6 +574,7 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
// ---------- 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" },
|
||||
@@ -151,7 +586,7 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
const r = await dialog("Stammdaten", felder, werte, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const d = r.daten;
|
||||
const daten: Zeile = { personalnummer: d.personalnummer, eintritt: d.eintritt, austritt: d.austritt, angestellt: d.angestellt !== "nein", urlaubstage: d.urlaubstage ?? 30 };
|
||||
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 });
|
||||
|
||||
Reference in New Issue
Block a user