Leiste anpassbar, Mehr gruppiert, PC-Ansicht erzwingen; Listen mit Suche, Filterblatt (mehrstufige Sortierung, Häkchen, Ansichten) und Wischen zum Ausblenden; Projektseite mit Reitern Überblick/Ablauf/Geld/Ablage; Terminplan als Tages-/Wochen-/Personenliste mit Warnungen und Freigabe; Angebot am Handy (Menge/EP, freigeben, annehmen); Stammdaten nur lesen; Stunden mit sichtbarem Pausenabzug und Verteilung auf die Einsätze. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
400 lines
25 KiB
TypeScript
400 lines
25 KiB
TypeScript
// Z1, M3: Stunden buchen am Handy (in drei Tipps: Stunden öffnen, Baustelle prüfen, Speichern) und für Inhaber
|
||
// und Büro die Monatsübersicht aller. Ohne Netz bleibt die Buchung im Handy und geht raus, sobald wieder Netz da ist.
|
||
|
||
import { type Abzugsart, dauerText, minuten, rechneTag, regelPause, uhrzeit } from "../domain/zeit.js";
|
||
import { type Zeile, api, dat, dateiSpeichern, esc, heute, inhalt, lies, merke, seite } from "./ui.js";
|
||
import { liste as tabelleMit } from "./liste.js";
|
||
|
||
const WT = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"];
|
||
const WT_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
|
||
const wt = (d: string) => new Date(`${d}T00:00:00Z`).getUTCDay();
|
||
const plusTage = (d: string, n: number) => new Date(Date.parse(`${d}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10);
|
||
const zahl = (h: number) => String(Math.round(h * 100) / 100).replace(".", ",");
|
||
const PAUSEN = [0, 15, 30, 45, 60, 90];
|
||
|
||
// ---------- ohne Netz: Warteschlange im Handy ----------
|
||
const SCHLANGE = "betrieb-stunden-warteschlange";
|
||
type Wartend = { pfad: string; body: unknown; datum: string };
|
||
const schlange = (): Wartend[] => { try { return JSON.parse(lies(SCHLANGE) ?? "[]"); } catch { return []; } };
|
||
const sichereSchlange = (l: Wartend[]) => merke(SCHLANGE, l.length ? JSON.stringify(l) : null);
|
||
|
||
/** Gespeicherte Buchungen senden; gibt zurück, wie viele noch warten */
|
||
export async function sendeWartende(): Promise<number> {
|
||
const offen = schlange();
|
||
const rest: Wartend[] = [];
|
||
for (const w of offen) {
|
||
try { await api(w.pfad, "PUT", w.body); } catch (e) { if (e instanceof TypeError) rest.push(w); /* sonst verwerfen: Server sagt nein */ }
|
||
}
|
||
sichereSchlange(rest);
|
||
return rest.length;
|
||
}
|
||
window.addEventListener("online", () => { void sendeWartende(); });
|
||
|
||
// ---------- Eingabe eines Tages ----------
|
||
|
||
interface Auswahl {
|
||
projekte: { id: string; nummer: string; bezeichnung: string; vorgaenge: { id: string; name: string }[] }[];
|
||
einsaetze: { id: string; name: string; projekt_id: string; anfang: string; ende: string }[];
|
||
}
|
||
|
||
function baustellenOptionen(a: Auswahl, datum: string, wert: string): string {
|
||
const opt = (v: string, t: string) => `<option value="${esc(v)}"${v === wert ? " selected" : ""}>${esc(t)}</option>`;
|
||
const projekt = new Map(a.projekte.map((p) => [p.id, p]));
|
||
const heute = a.einsaetze.filter((e) => e.anfang <= datum && e.ende >= datum);
|
||
return (heute.length ? `<optgroup label="Eingeteilt">${heute.map((e) => opt(`v:${e.id}`, `${projekt.get(e.projekt_id)?.nummer ?? ""} ${e.name}`)).join("")}</optgroup>` : "")
|
||
+ a.projekte.map((p) => `<optgroup label="${esc(`${p.nummer} ${p.bezeichnung}`)}">${opt(`p:${p.id}`, `${p.nummer} ganzes Projekt`)}${p.vorgaenge.map((v) => opt(`v:${v.id}`, `${p.nummer} ${v.name}`)).join("")}</optgroup>`).join("")
|
||
+ `<optgroup label="Ohne Baustelle">${opt("", "Werkstatt, Lager, Büro …")}</optgroup>`;
|
||
}
|
||
|
||
export interface Editor {
|
||
datum: string;
|
||
eintrag: Zeile | null;
|
||
angestellt: boolean;
|
||
pausenabzug: Abzugsart;
|
||
/** Soll des Tages in Stunden für die Vorgabe des Endes */
|
||
soll: number;
|
||
auswahl: Auswahl;
|
||
speichern(body: unknown): Promise<Zeile | "wartet">;
|
||
loeschen?(): Promise<void>;
|
||
fertig(): void;
|
||
}
|
||
|
||
/** „6:25“, „6,5“ oder „6“ → Minuten; leer → null */
|
||
function leseDauer(text: string): number | null {
|
||
const t = text.trim();
|
||
if (!t) return null;
|
||
const m = /^(\d{1,2}):(\d{1,2})$/.exec(t);
|
||
if (m) return Number(m[1]) * 60 + Number(m[2]);
|
||
const h = Number(t.replace(",", "."));
|
||
if (!(h >= 0) || h > 24) throw new Error(`„${t}“ ist keine Dauer, z. B. 6:30`);
|
||
return Math.round(h * 60);
|
||
}
|
||
|
||
/** Warum so viel Pause abgezogen wird, in einem Satz */
|
||
function pausenSatz(r: { anwesend: number; handPause: number; abzug: number }, angestellt: boolean): string {
|
||
if (!angestellt) return r.handPause ? `${r.handPause} Min. Pause von Hand eingetragen.` : "Pause trägst du selbst ein.";
|
||
if (!regelPause(r.anwesend)) return "Bis 6 Std. ist keine Pause vorgeschrieben.";
|
||
const stufe = r.anwesend <= 540 ? "über 6 Std." : r.anwesend <= 600 ? "über 9 Std." : "über 10 Std.";
|
||
return r.abzug ? `Anwesend ${stufe} → ${r.handPause + r.abzug} Min. Pause werden abgezogen.` : `Anwesend ${stufe}: deine Pause von ${r.handPause} Min. reicht.`;
|
||
}
|
||
|
||
/**
|
||
* Formular für einen Tag (Henning „Ok“, 21.10.2026): Beginn und Ende, darunter sichtbar Anwesend, Pause nach Gesetz und
|
||
* Arbeitszeit; die Arbeitszeit wird auf die heutigen Einsätze verteilt. Rechnet live wie der Server (domain/zeit.ts).
|
||
*/
|
||
export function tagFormular(ziel: HTMLElement, e: Editor): void {
|
||
const x = e.eintrag;
|
||
const beginn = x?.beginn ?? "07:00";
|
||
const sollMin = Math.round((e.soll || 8) * 60);
|
||
const ende = x?.ende ?? uhrzeit(minuten(beginn) + sollMin + (e.angestellt ? regelPause(sollMin + 30) : 0));
|
||
const projekt = new Map(e.auswahl.projekte.map((p) => [p.id, p]));
|
||
const heutige = e.auswahl.einsaetze.filter((v) => v.anfang <= e.datum && v.ende >= e.datum);
|
||
const einsatzName = (id: string) => { const v = heutige.find((y) => y.id === id); return v ? `${projekt.get(v.projekt_id)?.nummer ?? ""} ${projekt.get(v.projekt_id)?.bezeichnung ?? ""} · ${v.name}` : null; };
|
||
// Zeilen: wahl (v:Vorgang, p:Projekt, leer = ohne Baustelle), Minuten oder null = bekommt den Rest
|
||
type Reihe = { wahl: string; taetigkeit: string; min: number | null; fest: boolean };
|
||
const reihen: Reihe[] = x?.anteile?.length
|
||
? x.anteile.map((t: Zeile, i: number) => {
|
||
const wahl = t.vorgang_id ? `v:${t.vorgang_id}` : t.projekt_id ? `p:${t.projekt_id}` : "";
|
||
return { wahl, taetigkeit: t.taetigkeit ?? "", min: i === 0 ? null : Math.round(Number(t.stunden) * 60), fest: wahl.startsWith("v:") && !!einsatzName(wahl.slice(2)) };
|
||
})
|
||
: heutige.length ? heutige.map((v, i) => ({ wahl: `v:${v.id}`, taetigkeit: "", min: i === 0 ? null : 0, fest: true }))
|
||
: [{ wahl: "", taetigkeit: "", min: null, fest: false }];
|
||
// eingeplante Einsätze, die beim Bearbeiten noch fehlen, als 0-Zeilen dazu
|
||
for (const v of heutige) if (!reihen.some((r) => r.wahl === `v:${v.id}`)) reihen.push({ wahl: `v:${v.id}`, taetigkeit: "", min: 0, fest: true });
|
||
|
||
ziel.innerHTML = `<form class="stunden-form">
|
||
<div class="zeiten">
|
||
<label>Beginn<input type="time" name="beginn" value="${esc(beginn)}" step="300" required></label>
|
||
<label>Ende<input type="time" name="ende" value="${esc(ende)}" step="300" required></label>
|
||
<label>Pause<select name="pause">${PAUSEN.map((p) => `<option value="${p}"${p === (x?.pause_min ?? 0) ? " selected" : ""}>${p ? `${p} Min` : "keine"}</option>`).join("")}</select></label>
|
||
</div>
|
||
<div class="tag-rechnung" aria-live="polite"></div>
|
||
<h3 class="verteilen-kopf">Aufteilen auf Arbeiten</h3>
|
||
<ul class="verteilen"></ul>
|
||
<button type="button" class="verweis" data-a="mehr">+ andere Arbeit</button>
|
||
<p class="verteilt" aria-live="polite"></p>
|
||
<label class="notiz">Notiz (optional)<input name="notiz" value="${esc(x?.notiz ?? "")}" placeholder="z. B. Material fehlt …"></label>
|
||
<p class="fehler" role="alert"></p>
|
||
<div class="knoepfe">${x && e.loeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
||
<button type="submit" class="haupt gross speichern-gruen">${x ? "Änderung speichern" : "Speichern"}</button></div>
|
||
<p class="hinweis">Ohne Netz bleibt die Buchung im Handy und wird gesendet, sobald wieder Netz da ist.</p>
|
||
</form>`;
|
||
const form = ziel.querySelector("form")!;
|
||
const feld = (n: string) => form.querySelector<HTMLInputElement>(`[name="${n}"]`)!;
|
||
const liste = form.querySelector<HTMLElement>(".verteilen")!;
|
||
|
||
const rechnung = () => {
|
||
try {
|
||
const an = minuten(feld("ende").value) - minuten(feld("beginn").value);
|
||
if (an <= 0) return null;
|
||
return rechneTag(an, Number(feld("pause").value), e.angestellt, e.pausenabzug);
|
||
} catch { return null; }
|
||
};
|
||
/** Minuten je Zeile; die erste leere Zeile bekommt den Rest */
|
||
const verteilung = (netto: number) => {
|
||
const rest = reihen.findIndex((r) => r.min === null);
|
||
const fest = reihen.reduce((s, r, i) => s + (i === rest ? 0 : r.min ?? 0), 0);
|
||
return { rest, werte: reihen.map((r, i) => (i === rest ? Math.max(0, netto - fest) : r.min ?? 0)), summe: rest >= 0 ? Math.max(fest, netto) : fest };
|
||
};
|
||
|
||
const zeichneReihen = () => {
|
||
liste.innerHTML = reihen.map((r, i) => `<li class="anteil" data-i="${i}">
|
||
<div class="wer">${r.fest ? `<b>${esc(einsatzName(r.wahl.slice(2)))}</b><span class="unter">eingeplant</span>`
|
||
: `<select data-f="wahl" aria-label="Arbeit">${baustellenOptionen(e.auswahl, e.datum, r.wahl)}</select>`}
|
||
<input data-f="taetigkeit" value="${esc(r.taetigkeit)}" placeholder="Tätigkeit (optional)" aria-label="Tätigkeit"></div>
|
||
<input class="dauer" data-f="min" inputmode="decimal" value="${r.min !== null ? dauerText(r.min) : ""}" aria-label="Stunden">
|
||
${reihen.length > 1 && !r.fest ? `<button type="button" class="weg" data-weg="${i}" aria-label="Zeile entfernen">×</button>` : ""}</li>`).join("");
|
||
};
|
||
const zeigeRechnung = () => {
|
||
const r = rechnung();
|
||
const box = form.querySelector(".tag-rechnung")!;
|
||
const vt = form.querySelector(".verteilt")!;
|
||
if (!r) { box.innerHTML = '<p class="fehler">Ende muss nach dem Beginn liegen.</p>'; vt.textContent = ""; return; }
|
||
const pause = r.handPause + r.abzug;
|
||
box.innerHTML = `<div class="tr-zahlen"><div><small>Anwesend</small><b>${dauerText(r.anwesend)}</b></div>
|
||
<div><small>${e.angestellt ? "Pause (Gesetz)" : "Pause"}</small><b>${pause ? `− ${dauerText(pause)}` : "0:00"}</b></div>
|
||
<div><small>Arbeitszeit</small><b class="akzent">${dauerText(r.netto)}</b></div></div>
|
||
<p class="hinweis">${esc(pausenSatz(r, e.angestellt))}</p>${r.ueberZehn ? '<p class="fehler">Mehr als 10 Std. Arbeitszeit: Das erlaubt das Arbeitszeitgesetz nur ausnahmsweise.</p>' : ""}`;
|
||
const v = verteilung(r.netto);
|
||
liste.querySelectorAll<HTMLInputElement>('[data-f="min"]').forEach((f, i) => { f.placeholder = i === v.rest ? dauerText(v.werte[i]!) : "0:00"; f.title = i === v.rest ? "leer = bekommt den Rest" : ""; });
|
||
const ok = v.summe === r.netto;
|
||
vt.className = `verteilt ${ok ? "gut" : "schlecht"}`;
|
||
vt.innerHTML = `<span>Verteilt</span><b>${dauerText(v.summe)} von ${dauerText(r.netto)}${ok ? " ✓" : ""}</b>`;
|
||
};
|
||
zeichneReihen();
|
||
zeigeRechnung();
|
||
|
||
form.addEventListener("input", (ev) => {
|
||
const t = ev.target as HTMLInputElement;
|
||
const i = Number(t.closest<HTMLElement>(".anteil")?.dataset.i);
|
||
if (!Number.isNaN(i) && t.dataset.f) {
|
||
const r = reihen[i]!;
|
||
if (t.dataset.f === "min") { try { r.min = leseDauer(t.value); } catch { /* beim Speichern gemeldet */ } }
|
||
else if (t.dataset.f === "wahl") r.wahl = t.value;
|
||
else r.taetigkeit = t.value;
|
||
}
|
||
zeigeRechnung();
|
||
});
|
||
form.addEventListener("change", () => zeigeRechnung());
|
||
form.addEventListener("click", async (ev) => {
|
||
const t = ev.target as HTMLElement;
|
||
if (t.dataset.a === "mehr") { reihen.push({ wahl: "", taetigkeit: "", min: reihen.some((r) => r.min === null) ? 0 : null, fest: false }); zeichneReihen(); zeigeRechnung(); }
|
||
if (t.dataset.weg) { reihen.splice(Number(t.dataset.weg), 1); zeichneReihen(); zeigeRechnung(); }
|
||
if (t.dataset.a === "loeschen" && e.loeschen) { await e.loeschen(); e.fertig(); }
|
||
});
|
||
form.addEventListener("submit", async (ev) => {
|
||
ev.preventDefault();
|
||
const fehler = form.querySelector(".fehler")!;
|
||
fehler.textContent = "";
|
||
const r = rechnung();
|
||
if (!r) { fehler.textContent = "Bitte Beginn und Ende prüfen."; return; }
|
||
try { for (const f of liste.querySelectorAll<HTMLInputElement>('[data-f="min"]')) leseDauer(f.value); } catch (err) { fehler.textContent = (err as Error).message; return; }
|
||
const v = verteilung(r.netto);
|
||
if (v.summe > r.netto) { fehler.textContent = `Verteilt ist mehr (${dauerText(v.summe)}) als gearbeitet (${dauerText(r.netto)}).`; return; }
|
||
if (v.summe < r.netto) { fehler.textContent = `Noch ${dauerText(r.netto - v.summe)} verteilen oder ein Feld leer lassen, das bekommt den Rest.`; return; }
|
||
// Zeilen ohne Zeit fallen weg; genau eine Zeile bekommt alles
|
||
let teile = reihen.map((x, i) => ({ ...x, min: v.werte[i]! })).filter((x) => x.min > 0);
|
||
if (!teile.length) teile = [{ ...reihen[0]!, min: r.netto }];
|
||
const body = {
|
||
beginn: feld("beginn").value, ende: feld("ende").value, pause_min: Number(feld("pause").value), notiz: feld("notiz").value || null,
|
||
anteile: teile.map((a) => ({
|
||
vorgang_id: a.wahl.startsWith("v:") ? a.wahl.slice(2) : null, projekt_id: a.wahl.startsWith("p:") ? a.wahl.slice(2) : null,
|
||
taetigkeit: a.taetigkeit || null, ...(teile.length > 1 ? { stunden: a.min / 60 } : {}),
|
||
})),
|
||
};
|
||
const knopf = form.querySelector<HTMLButtonElement>('button[type="submit"]')!;
|
||
knopf.disabled = true;
|
||
try {
|
||
await e.speichern(body);
|
||
e.fertig();
|
||
} catch (err) {
|
||
fehler.textContent = (err as Error).message;
|
||
knopf.disabled = false;
|
||
}
|
||
});
|
||
}
|
||
|
||
// ---------- Meine Stunden ----------
|
||
|
||
let gewaehlt = "";
|
||
|
||
/** mitUmschalter: Inhaber und Büro sehen oben „Meine | Alle“ */
|
||
export async function meineStunden(mitUmschalter = false): Promise<void> {
|
||
const neu = () => meineStunden(mitUmschalter);
|
||
const warten = await sendeWartende();
|
||
const tag = gewaehlt || heute();
|
||
const bis = heute();
|
||
const von = plusTage(bis, -34);
|
||
const d = await api<Zeile>(`ich/zeiten?von=${von}&bis=${bis}`);
|
||
seite("Meine Stunden");
|
||
const kopf = inhalt.querySelector(".kopf h1")!;
|
||
kopf.insertAdjacentHTML("afterend", `<div class="tag-wahl"><button class="neben" data-tag="-1" aria-label="Tag davor">‹</button>
|
||
<input type="date" value="${tag}" max="${bis}"${d.rueckwirkend ? ` min="${plusTage(bis, -d.rueckwirkend)}"` : ""}><button class="neben" data-tag="1" aria-label="Tag danach"${tag >= bis ? " disabled" : ""}>›</button></div>`);
|
||
const eintrag = d.tage.find((t: Zeile) => t.datum === tag) ?? null;
|
||
const offen = schlange().find((w) => w.datum === tag);
|
||
const karte = document.createElement("section");
|
||
karte.className = "karte stunden-karte";
|
||
karte.innerHTML = `<h2>${tag === bis ? "Heute, " : ""}${WT_LANG[wt(tag)]} ${dat(tag)}</h2>
|
||
${warten ? `<p class="warnung">${warten} Buchung${warten > 1 ? "en warten" : " wartet"} auf Netz und ${warten > 1 ? "werden" : "wird"} gesendet, sobald das Handy wieder online ist.</p>` : ""}
|
||
${offen ? '<p class="hinweis">Für diesen Tag wartet eine Buchung ohne Netz.</p>' : ""}<div class="formular"></div>`;
|
||
inhalt.appendChild(karte);
|
||
const sollTag = (d.soll as Zeile[]).find((s) => s.datum === tag);
|
||
tagFormular(karte.querySelector(".formular")!, {
|
||
datum: tag, eintrag, angestellt: d.angestellt, pausenabzug: d.pausenabzug, soll: sollTag?.soll || 8, auswahl: d as unknown as Auswahl,
|
||
speichern: async (body) => {
|
||
try {
|
||
return await api(`ich/zeiten/${tag}`, "PUT", body);
|
||
} catch (e) {
|
||
if (!(e instanceof TypeError)) throw e;
|
||
sichereSchlange([...schlange().filter((w) => w.datum !== tag), { pfad: `ich/zeiten/${tag}`, body, datum: tag }]);
|
||
return "wartet";
|
||
}
|
||
},
|
||
loeschen: eintrag ? async () => { await api(`ich/zeiten/${tag}`, "DELETE"); } : undefined,
|
||
fertig: () => { void neu(); },
|
||
});
|
||
if (mitUmschalter) umschalter();
|
||
|
||
// Liste der letzten Wochen mit Summe je Woche
|
||
const wochen = new Map<string, Zeile[]>();
|
||
for (const t of [...d.tage].reverse()) {
|
||
const mo = plusTage(t.datum, -((wt(t.datum) + 6) % 7));
|
||
wochen.set(mo, [...(wochen.get(mo) ?? []), t]);
|
||
}
|
||
const liste = document.createElement("section");
|
||
liste.className = "stunden-liste";
|
||
liste.innerHTML = [...wochen].map(([mo, tage]) => {
|
||
const summe = tage.reduce((s, t) => s + t.netto_min, 0);
|
||
return `<h3>Woche ab ${dat(mo).slice(0, 6)} <small>${dauerText(summe)} Std.</small></h3><ul>${tage.map((t) =>
|
||
`<li><button class="eintrag" data-datum="${t.datum}"><span>${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}</span><span>${t.beginn}–${t.ende}</span>
|
||
<b>${dauerText(t.netto_min)}</b><small>${esc(t.anteile.map((a: Zeile) => a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle").join(", "))}</small></button></li>`).join("")}</ul>`;
|
||
}).join("") || '<p class="hinweis">Noch keine Stunden gebucht.</p>';
|
||
inhalt.appendChild(liste);
|
||
|
||
const wahl = inhalt.querySelector<HTMLInputElement>(".tag-wahl input")!;
|
||
wahl.onchange = () => { if (wahl.value) { gewaehlt = wahl.value > bis ? bis : wahl.value; void neu(); } };
|
||
inhalt.querySelectorAll<HTMLButtonElement>("[data-tag]").forEach((b) => b.onclick = () => {
|
||
const neu2 = plusTage(tag, Number(b.dataset.tag));
|
||
if (neu2 <= bis) { gewaehlt = neu2; void neu(); }
|
||
});
|
||
liste.onclick = (ev) => {
|
||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-datum]");
|
||
if (b) { gewaehlt = b.dataset.datum!; void neu(); window.scrollTo({ top: 0 }); }
|
||
};
|
||
}
|
||
|
||
// ---------- Alle Stunden (Inhaber und Büro) ----------
|
||
|
||
let monat = heute().slice(0, 7);
|
||
let person = "";
|
||
let ansicht = "";
|
||
|
||
const MONATE = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||
const monatsEnde = (m: string) => new Date(Date.UTC(Number(m.slice(0, 4)), Number(m.slice(5, 7)), 0)).toISOString().slice(0, 10);
|
||
|
||
export async function stundenSeite(): Promise<void> {
|
||
ansicht ||= lies("betrieb-stunden-ansicht") ?? "alle";
|
||
if (ansicht === "meine") return meineStunden(true);
|
||
const von = `${monat}-01`, bis = monatsEnde(monat);
|
||
const [d, auswahl, verf] = await Promise.all([
|
||
api<Zeile>(`zeiten?von=${von}&bis=${bis}${person ? `&kontakt_id=${person}` : ""}`),
|
||
api<Zeile>(`ich/zeiten?von=${heute()}&bis=${heute()}`),
|
||
api<Zeile[]>(`verfuegbarkeit?von=${von}&bis=${bis}`),
|
||
]);
|
||
seite("Stunden");
|
||
umschalter();
|
||
const leiste = inhalt.querySelector(".leiste")!;
|
||
leiste.innerHTML = `<div class="tag-wahl"><button class="neben" data-monat="-1" aria-label="Monat davor">‹</button><b>${MONATE[Number(monat.slice(5, 7)) - 1]} ${monat.slice(0, 4)}</b><button class="neben" data-monat="1" aria-label="Monat danach">›</button></div>
|
||
<select id="person"><option value="">Alle Personen</option>${d.leute.map((l: Zeile) => `<option value="${l.id}"${l.id === person ? " selected" : ""}>${esc(l.name)}${l.rolle === "subunternehmer" ? " (Sub)" : ""}</option>`).join("")}</select>
|
||
<button class="neben" data-a="neu">+ Stunden nachtragen</button>
|
||
<button class="neben" data-a="csv" title="Alle Angestellten, je Tag mit Urlaub, Krankheit und Feiertagen, mit Summen">Stundenliste fürs Steuerbüro</button><span id="csv-meldung" class="hinweis"></span>`;
|
||
|
||
// Summen je Person: Ist gegen Soll aus dem Arbeitszeitmodell (abzüglich Urlaub, Krankheit, Feiertage)
|
||
const jePerson = new Map<string, number>();
|
||
for (const t of d.tage) jePerson.set(t.kontakt_id, (jePerson.get(t.kontakt_id) ?? 0) + t.netto_min);
|
||
// im laufenden Monat nur bis heute, sonst stünde am Monatsanfang ein großes Minus da
|
||
const sollJe = new Map(verf.map((v) => [v.kontakt_id, v.tage.filter((t: Zeile) => t.datum <= heute()).reduce((s: number, t: Zeile) => s + t.frei, 0) * 60]));
|
||
const leute = d.leute.filter((l: Zeile) => (!person || l.id === person) && (jePerson.has(l.id) || (l.rolle === "mitarbeiter" && sollJe.has(l.id))));
|
||
inhalt.insertAdjacentHTML("beforeend", `<div class="summen">${leute.map((l: Zeile) => {
|
||
const ist = jePerson.get(l.id) ?? 0, soll = l.angestellt ? sollJe.get(l.id) ?? 0 : 0;
|
||
return `<div><small>${esc(l.name)}</small><b>${dauerText(ist)} Std.</b>${soll ? `<small>Soll ${dauerText(soll)} · <span class="${ist - soll < 0 ? "fehler" : ""}">${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}</span></small>` : ""}</div>`;
|
||
}).join("")}</div>`);
|
||
|
||
const baustellen = (t: Zeile) => t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", ");
|
||
inhalt.appendChild(tabelleMit({
|
||
schluessel: "stunden", einheit: ["Tag", "Tage"], leer: "In diesem Monat sind keine Stunden gebucht.",
|
||
zeilen: d.tage.map((t: Zeile) => ({ ...t, id: t.id ?? `${t.kontakt_id}-${t.datum}` })),
|
||
spalten: [
|
||
{ id: "tag", titel: "Tag", art: "datum", wert: (t) => `${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}`, sortWert: (t) => t.datum },
|
||
{ id: "person", titel: "Person", wert: (t) => esc(t.name) },
|
||
{ id: "zeit", titel: "Zeit", wert: (t) => `${t.beginn}–${t.ende}`, sortWert: (t) => t.beginn },
|
||
{ id: "pause", titel: "Pause", art: "zahl", wert: (t) => String(t.pause_min || ""), sortWert: (t) => t.pause_min || 0, klasse: "zahl" },
|
||
{ id: "abzug", titel: "Abzug", art: "zahl", wert: (t) => String(t.abzug_min || ""), sortWert: (t) => t.abzug_min || 0, klasse: "zahl" },
|
||
{ id: "arbeitszeit", titel: "Arbeitszeit", art: "zahl", wert: (t) => `<b>${dauerText(t.netto_min)}</b>`, sortWert: (t) => t.netto_min, klasse: "zahl" },
|
||
{ id: "baustellen", titel: "Baustellen", text: baustellen, wert: (t) => `${esc(baustellen(t))}${t.notiz ? ` <i>${esc(t.notiz)}</i>` : ""}`, klasse: "optional" },
|
||
],
|
||
klick: (t) => void oeffne(d.tage.find((x: Zeile) => x.kontakt_id === t.kontakt_id && x.datum === t.datum) ?? t),
|
||
fuss: (l) => (l.length && l.length !== d.tage.length ? `<p>Summe der gezeigten Tage: <strong>${dauerText(l.reduce((s, t) => s + t.netto_min, 0))} Std.</strong></p>` : ""),
|
||
}));
|
||
|
||
const oeffne = async (t: Zeile | null) => {
|
||
const huelle = document.getElementById("dialog-huelle")!;
|
||
let kontakt = t?.kontakt_id ?? person ?? "";
|
||
let datum = t?.datum ?? heute();
|
||
const zeichne = async () => {
|
||
const l = d.leute.find((x: Zeile) => x.id === kontakt);
|
||
const soll = kontakt ? (await api<Zeile[]>(`verfuegbarkeit?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`))[0]?.tage[0]?.soll : 8;
|
||
const vorhanden = t ?? (kontakt ? (await api<Zeile>(`zeiten?von=${datum}&bis=${datum}&kontakt_id=${kontakt}`)).tage[0] ?? null : null);
|
||
huelle.innerHTML = `<div class="dialog breit"><h2>${t ? `${esc(t.name)}, ${WT[wt(t.datum)]} ${dat(t.datum)}` : "Stunden nachtragen"}</h2>
|
||
${t ? "" : `<label>Person<select id="n-person"><option value="">– wählen –</option>${d.leute.map((x: Zeile) => `<option value="${x.id}"${x.id === kontakt ? " selected" : ""}>${esc(x.name)}</option>`).join("")}</select></label>
|
||
<label>Tag<input type="date" id="n-datum" value="${datum}"></label>`}<div class="formular"></div>
|
||
<div class="knoepfe"><button class="neben" data-a="zu">Schließen</button></div></div>`;
|
||
huelle.hidden = false;
|
||
const zu = () => { huelle.hidden = true; huelle.innerHTML = ""; };
|
||
huelle.querySelector<HTMLElement>('[data-a="zu"]')!.onclick = zu;
|
||
const np = huelle.querySelector<HTMLSelectElement>("#n-person"), nd = huelle.querySelector<HTMLInputElement>("#n-datum");
|
||
if (np) np.onchange = () => { kontakt = np.value; void zeichne(); };
|
||
if (nd) nd.onchange = () => { datum = nd.value; void zeichne(); };
|
||
if (!kontakt) return;
|
||
tagFormular(huelle.querySelector(".formular")!, {
|
||
datum, eintrag: vorhanden, angestellt: !!l?.angestellt, pausenabzug: d.pausenabzug, soll: soll || 8,
|
||
auswahl: { projekte: auswahl.projekte, einsaetze: [] },
|
||
speichern: (body) => api(`zeiten/${kontakt}/${datum}`, "PUT", body),
|
||
loeschen: vorhanden ? () => api(`zeiten/${kontakt}/${datum}`, "DELETE") : undefined,
|
||
fertig: () => { zu(); void stundenSeite(); },
|
||
});
|
||
};
|
||
await zeichne();
|
||
};
|
||
|
||
leiste.addEventListener("click", (ev) => {
|
||
const b = ev.target as HTMLElement;
|
||
if (b.dataset.monat) {
|
||
const [j, m] = monat.split("-").map(Number) as [number, number];
|
||
const n = new Date(Date.UTC(j, m - 1 + Number(b.dataset.monat), 1));
|
||
monat = n.toISOString().slice(0, 7);
|
||
void stundenSeite();
|
||
}
|
||
if (b.dataset.a === "neu") void oeffne(null);
|
||
if (b.dataset.a === "csv") {
|
||
const meldung = leiste.querySelector<HTMLElement>("#csv-meldung")!;
|
||
dateiSpeichern(`zeiten/csv?monat=${monat}`, `stunden-${monat}.csv`)
|
||
.then((t) => { meldung.textContent = t; }, (e: Error) => { meldung.textContent = e.message; });
|
||
}
|
||
});
|
||
leiste.querySelector<HTMLSelectElement>("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); };
|
||
}
|
||
|
||
/** Inhaber und Büro: zwischen eigenen Stunden und allen umschalten */
|
||
function umschalter(): void {
|
||
const kopf = inhalt.querySelector(".kopf")!;
|
||
kopf.insertAdjacentHTML("beforeend", `<div class="umschalter" role="tablist"><button role="tab" data-ansicht="meine"${ansicht === "meine" ? ' class="aktiv" aria-selected="true"' : ""}>Meine</button><button role="tab" data-ansicht="alle"${ansicht === "alle" ? ' class="aktiv" aria-selected="true"' : ""}>Alle</button></div>`);
|
||
kopf.querySelector(".umschalter")!.addEventListener("click", (ev) => {
|
||
const a = (ev.target as HTMLElement).dataset.ansicht;
|
||
if (!a || a === ansicht) return;
|
||
ansicht = a;
|
||
merke("betrieb-stunden-ansicht", a);
|
||
void stundenSeite();
|
||
});
|
||
}
|