// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft. import { kalenderwoche, terminplanSeite } from "./gantt.js"; import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, optionenHtml, seite, tabelle, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js"; import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js"; import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js"; // ---------- Reiter ---------- const ROLLEN: [string, string][] = [ ["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"], ["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"], ]; const KONTAKT_FELDER: Feld[] = [ { name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" }, { name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" }, { name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" }, ]; async function kontakte(): Promise { const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte(); seite("Kontakte", { text: "Neuer Kontakt", aktion: neu }); const zeilen = await api("kontakte"); const rolle = Object.fromEntries(ROLLEN); inhalt.appendChild(tabelle([ { titel: "Name", wert: (z) => esc(z.name) }, { titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" }, { titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) }, { titel: "Telefon", wert: (z) => (z.telefon ? `${esc(z.telefon)}` : "") }, { titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" }, ], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte())); } const STATUS: [string, string][] = [ ["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"], ["abgerechnet", "Abgerechnet"], ["gewaehrleistung", "Gewährleistung"], ["abgeschlossen", "Abgeschlossen"], ]; const STATUS_TEXT = Object.fromEntries(STATUS); const etikett = (status: string) => `${esc(STATUS_TEXT[status] ?? status)}`; const VERTRAGSARTEN: [string, string][] = [["", "–"], ["vob", "VOB/B"], ["bgb", "BGB"]]; async function projektFelder(): Promise { const kontaktListe = await api("kontakte"); const sortiert = [...kontaktListe].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de")); return [ { name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "status", titel: "Status", art: "auswahl", optionen: STATUS }, { name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])] }, { name: "baustelle_strasse", titel: "Baustelle: Straße" }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" }, { name: "vertragsart", titel: "Vertragsart", art: "auswahl", optionen: VERTRAGSARTEN }, { name: "abnahme_am", titel: "Abnahme am", art: "datum" }, { name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" }, { name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" }, { name: "notiz", titel: "Beschreibung", art: "langtext" }, ]; } const BETRAEGE = ["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"]; const ohneNull = (d: Zeile) => ({ ...d, ...Object.fromEntries(BETRAEGE.map((k) => [k, d[k] ?? 0])) }); const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten; const ortZeile = (p: Zeile) => [p.baustelle_strasse, [p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", "); async function projekte(): Promise { const neu = async () => { const e = await dialog("Neues Projekt", await projektFelder(), { status: "anfrage" }, false); if (e?.aktion !== "speichern") return; const p = await api("projekte", "POST", ohneNull(e.daten)); if (p.ordner_fehler) hinweis.text = p.ordner_fehler; location.hash = `projekt-${p.id}`; }; seite("Projekte", { text: "Neues Projekt", aktion: neu }); const [zeilen, kontaktListe] = await Promise.all([api("projekte"), api("kontakte")]); const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name])); inhalt.appendChild(tabelle([ { titel: "Name", wert: (z) => `${esc(z.bezeichnung)}${esc(z.nummer)} · ${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}` }, { titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" }, { titel: "Status", wert: (z) => etikett(z.status) }, { titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" }, { titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" }, { titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" }, ], zeilen, (z) => (location.hash = `projekt-${z.id}`))); const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0); inhalt.insertAdjacentHTML("beforeend", `

${zeilen.length} Projekte

Rohertrag gesamt: ${euro(gesamt)}

`); } // ---------- Projektseite (P2), aufgebaut wie bei Plancraft ---------- const ZAHLUNGSARTEN: [string, string][] = [["anzahlung", "Anzahlung"], ["abschlag", "Abschlag"], ["nachtrag", "Nachtrag"], ["schluss", "Schlussrechnung"], ["einbehalt", "Einbehalt"]]; const ZAHLUNGSSTATUS: [string, string][] = [["geplant", "geplant"], ["gestellt", "gestellt"], ["bezahlt", "bezahlt"]]; const KOSTENARTEN: [string, string][] = [["material", "Material"], ["fremd", "Fremdleistung"], ["sonstiges", "Sonstiges"]]; const KOSTENSTATUS: [string, string][] = [["geplant", "geplant"], ["bestellt", "bestellt"], ["bezahlt", "bezahlt"]]; const ZAHLUNG_FELDER: Feld[] = [ { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: ZAHLUNGSARTEN }, { name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true }, { name: "status", titel: "Status", art: "auswahl", optionen: ZAHLUNGSSTATUS }, { name: "rechnungsdatum", titel: "Rechnungsdatum", art: "datum" }, { name: "bezahlt_am", titel: "Bezahlt am", art: "datum" }, ]; const KACHEL_SYMBOL: Record = { kunde: '', zeitraum: '', baustelle: '', auftrag: '', stunden: '', ordner: '', beschreibung: '', }; const symbolKachel = (art: string) => ``; const kachel = (art: string, titel: string, inhaltHtml: string) => `

${symbolKachel(art)}${esc(titel)}

${inhaltHtml}
`; // Projektseite wie Plancraft (Henning, 20.10.2026): oben Übersicht/Nachkalkulation mit Kacheln, darunter // Dokumente, Berichte, Ablage und Zahlungsplan, rechts statt des Chats die offenen Aufgaben des Projekts let projektOben = "uebersicht"; let projektTeil = "dokumente"; const projektAufgabenFilter = { kategorie: "", erledigte: false }; const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN); const stundenText = (h: number) => `${Math.floor(h)}:${String(Math.round((h % 1) * 60)).padStart(2, "0")} Std.`; const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`); async function projektSeite(id: string): Promise { const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben] = await Promise.all([ api(`projekte/${id}`), api("kontakte"), api("terminplan"), api("zahlungen"), api("kosten"), aufgabenDaten(), api("aufgaben"), ]); const neuLaden = () => projektSeite(id); const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k])); const kunde = kontakt[p.bauherr_id]; const abschnitte = plan.abschnitte.filter((a: Zeile) => a.projekt_id === id); const vorgaenge = plan.vorgaenge.filter((v: Zeile) => abschnitte.some((a: Zeile) => a.id === v.abschnitt_id)); const eigeneZahlungen = zahlungen.filter((z) => z.projekt_id === id); const eigeneKosten = kosten.filter((k) => k.projekt_id === id); const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id); const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p); inhalt.innerHTML = `${hinweis.text ? `
${esc(hinweis.text)}
` : ""}
←

${esc(p.bezeichnung)} (${esc(p.nummer)})

`; hinweis.text = ""; const oben = inhalt.querySelector("#p-oben")!; const unten = inhalt.querySelector("#p-unten")!; const teil = unten.querySelector("#teil")!; const knopfOrt = unten.querySelector("#teil-knopf")!; const knopf = (text: string, aktion: () => void) => { const b = document.createElement("button"); b.className = "haupt"; b.textContent = text; b.onclick = aktion; knopfOrt.replaceChildren(b); }; const leer = (text: string) => Object.assign(document.createElement("p"), { className: "hinweis leer", textContent: text }); // ---------- oben: Übersicht und Nachkalkulation ---------- const zeigeOben = () => { oben.querySelectorAll("[data-oben]").forEach((b) => b.classList.toggle("aktiv", b.dataset.oben === projektOben)); const ziel = oben.querySelector(".oben-inhalt")!; if (projektOben === "uebersicht") { const anfang = vorgaenge.map((v: Zeile) => v.anfang).sort()[0]; const ende = vorgaenge.map((v: Zeile) => v.ende).sort().at(-1); const soll = vorgaenge.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 0), 0) || Number(p.soll_stunden) || 0; const ist = 0; // kommt mit der Zeiterfassung (Stufe 2) const anteil = soll ? Math.round((ist / soll) * 100) : null; const adresse = ortZeile(p); ziel.innerHTML = `
${kachel("stunden", "Arbeitsstunden", `

${stundenText(ist)}

/ ${soll ? stundenText(soll) : "0:00 Std."}

${anteil ? `` : ""}${anteil === null ? "– %" : `${anteil} %`}

Ist-Stunden kommen mit der Zeiterfassung.

`)} ${kachel("kunde", "Kunde", kunde ? `

${esc(kunde.name)}${kunde.firma ? `
${esc(kunde.firma)}` : ""}

${[kunde.telefon && `${esc(kunde.telefon)}`, kunde.email && esc(kunde.email)].filter(Boolean).join("
")}

` : '

')}

${symbolKachel("beschreibung")}Beschreibung

${p.notiz ? esc(p.notiz) : 'Keine Beschreibung. Klicken zum Schreiben.'}
${kachel("zeitraum", "Zeitraum", anfang ? `

${dat(anfang)} – ${dat(ende)}

${vorgaenge.length} ${vorgaenge.length === 1 ? "Vorgang" : "Vorgänge"} in ${abschnitte.length} ${abschnitte.length === 1 ? "Abschnitt" : "Abschnitten"} · Terminplan

` : '

Abschnitt im Terminplan hinzufügen

')} ${kachel("baustelle", "Baustelle", adresse ? `

${esc(p.baustelle_strasse ?? "")}
${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}

` : '

')}
`; } else { ziel.innerHTML = `
Auftragswert netto
${euro(umsatz)}
Kosten geplant
${euro(kostenGesamt)}
Rohertrag
${euro(umsatz - kostenGesamt)}${umsatz ? ` (${Math.round(((umsatz - kostenGesamt) / umsatz) * 100)} %)` : ""}
Vertrag
${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}

Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 5. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.

Einzelkosten

`; const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle)); const felder: Feld[] = [ { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN }, { name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true }, { name: "kontakt_id", titel: "Lieferant / Subunternehmer", art: "auswahl", optionen: [["", "–"], ...lieferanten.map((k): [string, string] => [k.id, k.name])] }, { name: "status", titel: "Status", art: "auswahl", optionen: KOSTENSTATUS }, ]; ziel.querySelector('[data-a="kosten-neu"]')!.onclick = async () => (await bearbeiten("kosten", "Neue Kosten", felder, null, { projekt_id: id, art: "material", status: "geplant", termin: heute() })) && neuLaden(); ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? tabelle([ { titel: "Bezeichnung", wert: (k) => `${esc(k.bezeichnung)}${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}` }, { titel: "Termin", wert: (k) => dat(k.termin) }, { titel: "Status", wert: (k) => esc(k.status), klasse: "optional" }, { titel: "Netto", wert: (k) => euro(k.netto), klasse: "zahl" }, ], eigeneKosten, async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden()) : leer("Noch keine Einzelkosten.")); } }; // ---------- unten: Dokumente, Berichte, Ablage, Zahlungsplan ---------- let ablagePfad = ""; const zeigeTeil = () => { unten.querySelectorAll("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === projektTeil)); teil.replaceChildren(); knopfOrt.replaceChildren(); if (projektTeil === "dokumente") { // Status getrennt nach Art: Rechnungen offen/überfällig/bezahlt; „Freigegeben“ heißt festgeschrieben const rechnungen = eigeneZahlungen.filter((z) => z.status !== "geplant").sort((a, b) => (a.rechnungsdatum ?? a.termin).localeCompare(b.rechnungsdatum ?? b.termin)); let abschlag = 0; const art = (z: Zeile) => (z.art === "abschlag" ? `${++abschlag}. Abschlag` : ZAHLUNGSART_TEXT[z.art] ?? z.art); teil.innerHTML = `

Angebote

Angebote, Kostenvoranschläge und Auftragsbestätigungen schreibst du bis Stufe 5 noch in Plancraft; die PDFs liegen in der Ablage unter „01 Auftrag“.

Rechnungen

${rechnungen.length ? `
    ${rechnungen.map((z) => { const ueberfaellig = z.status === "gestellt" && z.termin < heute(); return `
  • `; }).join("")}
` : '

Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.

'}`; } else if (projektTeil === "berichte") { teil.innerHTML = `

Noch keine Berichte.

  • Bautagebuch mit Wetter, Personal und Fotos, am Handy (Stufe 4)
  • Regiebericht für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)
  • Abnahmeprotokoll mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung (Stufe 5)
`; } else if (projektTeil === "ablage") { void zeigeAblage(); } else { zeigeZahlungsplan(); } }; async function zeigeAblage(): Promise { teil.innerHTML = '

Lade den Projektordner …

'; const teile = ablagePfad ? ablagePfad.split("/") : []; const pfadLeiste = ``; try { const a = await api<{ eintraege: { name: string; ordner: boolean; groesse: number; geaendert: string | null }[] }>(`projekte/${id}/ablage?pfad=${encodeURIComponent(ablagePfad)}`); if (projektTeil !== "ablage") return; const voll = (n: string) => (ablagePfad ? `${ablagePfad}/${n}` : n); teil.innerHTML = `${pfadLeiste}${a.eintraege.length ? `` : '

Der Ordner ist leer.

'}`; } catch (e) { if (projektTeil !== "ablage") return; teil.innerHTML = `

${esc((e as Error).message)}

Im Projektordner liegen die Unterordner „01 Auftrag“ (Angebote, Auftragsbestätigung, Rechnungen, Lieferscheine), „02 Umsetzung“ und „03 Bilder“.

`; } } function zeigeZahlungsplan(): void { // eine geplante Rate hängt an einem Vorgang und wandert mit dessen Ende (Meilenstein im Terminplan) const vorgangName = (vid: string) => vorgaenge.find((x: Zeile) => x.id === vid)?.name ?? ""; const felder: Feld[] = [...ZAHLUNG_FELDER]; felder.splice(4, 0, { name: "vorgang_id", titel: "Fällig nach Vorgang", art: "auswahl", optionen: [["", "– Termin von Hand –"], ...vorgaenge.map((v: Zeile): [string, string] => [v.id, v.name])] }); knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", felder, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden()); const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0); const info = document.createElement("div"); info.className = "vorschlag"; if (!eigeneZahlungen.length && p.zahlungsplan !== "fest") { info.innerHTML = `

Der Zahlungsplan entsteht automatisch, sobald der Auftragswert eingetragen ist und das Projekt Termine im Terminplan hat: 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten, 10 % Schlussrechnung nach Abnahme.

${umsatz ? "" : ''}`; } else if (!eigeneZahlungen.length) { info.innerHTML = `

Noch kein Zahlungsplan. Der Standard ist 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung nach Abnahme.

`; } else { info.innerHTML = `

${p.zahlungsplan === "auto" ? "Automatisch angelegt: Die Raten folgen dem Auftragswert und den Terminen, bis du eine davon von Hand änderst." : "Fest: Geplante Raten, die an einem Vorgang hängen, wandern mit dessen Ende; Beträge ändern sich nur von Hand."}

`; } teil.append(info); if (eigeneZahlungen.length) { teil.append(tabelle([ { titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}` }, { titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `nach ${esc(vorgangName(z.vorgang_id))}` : ""}` }, { titel: "Status", wert: (z) => `${esc(z.status)}`, klasse: "optional" }, { titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" }, ], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden())); teil.insertAdjacentHTML("beforeend", `

Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}

`); } } // ---------- rechts: offene Aufgaben statt Chat ---------- const zeigeAufgaben = () => { const f = projektAufgabenFilter; const liste = eigeneAufgaben .filter((a) => (f.erledigte || !a.erledigt_am) && (!f.kategorie || (f.kategorie === "ohne" ? !a.kategorie_id : a.kategorie_id === f.kategorie))) .sort((a, b) => Number(!!a.erledigt_am) - Number(!!b.erledigt_am) || (a.faellig_am ?? "9999").localeCompare(b.faellig_am ?? "9999")); const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length; const seite = inhalt.querySelector(".projekt-aufgaben")!; seite.innerHTML = `

Offene Aufgaben ${offen}

${liste.length ? `
    ${liste.map((a) => { const ueber = !a.erledigt_am && a.faellig_am && a.faellig_am < heute(); return `
  • `; }).join("")}
` : `

${offen ? "Keine Aufgabe in dieser Auswahl." : "Keine offenen Aufgaben zu diesem Projekt."}

`}`; seite.querySelector("#pa-kategorie")!.onchange = (ev) => { f.kategorie = (ev.target as HTMLSelectElement).value; zeigeAufgaben(); }; seite.querySelector("#pa-erledigte")!.onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; zeigeAufgaben(); }; }; zeigeOben(); zeigeTeil(); zeigeAufgaben(); inhalt.addEventListener("click", async function klick(ev) { if (!document.body.contains(unten)) return inhalt.removeEventListener("click", klick); const ziel = ev.target as HTMLElement; const o = ziel.closest("[data-oben]")?.dataset.oben; if (o) { projektOben = o; zeigeOben(); return; } const t = ziel.closest("[data-teil]")?.dataset.teil; if (t) { projektTeil = t; zeigeTeil(); return; } const ordner = ziel.closest("[data-ablage]"); if (ordner) { ablagePfad = ordner.dataset.ablage!; void zeigeAblage(); return; } const zid = ziel.closest("[data-zahlung]")?.dataset.zahlung; if (zid) { projektTeil = "zahlungen"; zeigeTeil(); return; } const erledigt = (ziel as HTMLInputElement).dataset?.erledigt; if (erledigt) { await api(`aufgaben/${erledigt}`, "PATCH", { erledigt_am: (ziel as HTMLInputElement).checked ? new Date().toISOString() : null }); return neuLaden(); } const aid = ziel.closest("[data-aufgabe]")?.dataset.aufgabe; if (aid) return (await bearbeiten("aufgaben", "Aufgabe bearbeiten", aufgabenDat.felder, eigeneAufgaben.find((a) => a.id === aid)!)) && neuLaden(); const a = ziel.closest("[data-a]")?.dataset.a; if (a === "aufgabe-neu") return (await bearbeiten("aufgaben", "Neue Aufgabe", aufgabenDat.felder, null, { projekt_id: id, kontakt_id: p.bauherr_id ?? null })) && neuLaden(); if (a === "bearbeiten") { const e = await dialog("Projekt bearbeiten", await projektFelder(), p, true); if (!e) return; if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; } const r = await api(`projekte/${id}`, "PATCH", ohneNull(e.daten)); if (r.ordner_fehler) hinweis.text = r.ordner_fehler; return neuLaden(); } if (a === "zahlungsplan") { try { await api(`projekte/${id}/zahlungsplan`, "POST"); neuLaden(); } catch (err) { teil.querySelector(".fehler")!.textContent = (err as Error).message; } return; } if (a === "beschreibung") { const feld = ziel.closest("[data-a]")!; if (feld.querySelector("textarea")) return; feld.innerHTML = `

`; feld.querySelector("textarea")!.focus(); return; } if (a === "beschreibung-sichern") { const text = inhalt.querySelector(".beschreibung textarea")!.value.trim() || null; await api(`projekte/${id}`, "PATCH", { notiz: text }); p.notiz = text; return zeigeOben(); } if (a === "beschreibung-weg") return zeigeOben(); }); (inhalt.querySelector("#p-status") as HTMLSelectElement).onchange = async (ev) => { const r = await api(`projekte/${id}`, "PATCH", { status: (ev.target as HTMLSelectElement).value }); if (r.ordner_fehler) hinweis.text = r.ordner_fehler; neuLaden(); }; } async function terminplan(): Promise { await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt }); } // Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche // oder Monat jede einzelne Zahlung mit Datum, Projekt und Betrag zum Aufklappen let liquiOffen = new Set(); async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise { const leiste = seite("Liquidität"); leiste.innerHTML = ` `; const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement; const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement; a.value = ansicht; n.value = String(anzahl); a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value)); const [perioden, projekte, einst] = await Promise.all([ api(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api("projekte"), api("einstellungen"), ]); const projektName = new Map(projekte.map((p) => [p.nummer, p.bezeichnung])); const zeitraum = (p: Zeile) => (ansicht === "woche" ? `KW ${kalenderwoche(p.von)} · ${dat(p.von).slice(0, 6)} – ${dat(p.bis).slice(0, 6)}` : `${MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]} ${p.von.slice(0, 4)}`); // Kennzahlen const tief = perioden.reduce((m, p) => (p.kontostand < m.kontostand ? p : m), perioden[0] ?? { kontostand: 0 }); const summeEin = perioden.reduce((s, p) => s + p.einnahmen, 0), summeAus = perioden.reduce((s, p) => s + p.ausgaben, 0); const ende = perioden.at(-1); const kachel = (titel: string, wert: string, unter: string, rot = false) => `

${esc(titel)}

${wert}

${unter}

`; const startsaldo = Number(einst.startsaldo ?? 0); inhalt.insertAdjacentHTML("beforeend", `
${kachel("Kontostand", euro(startsaldo), einst.startsaldoDatum ? `eingetragen am ${dat(einst.startsaldoDatum)} · ändern` : 'unter Daten eintragen')} ${kachel("Tiefster Stand", tief ? euro(tief.kontostand) : "–", tief ? esc(zeitraum(tief)) : "", (tief?.kontostand ?? 0) < 0)} ${kachel("Einnahmen / Ausgaben", `${euro(summeEin)}
${euro(summeAus)}`, `im angezeigten Zeitraum, Saldo ${euro(summeEin + summeAus)}`)} ${kachel(`Stand am ${ende ? dat(ende.bis) : ""}`, ende ? euro(ende.kontostand) : "–", "Ende des angezeigten Zeitraums", (ende?.kontostand ?? 0) < 0)}
`); // Verlauf: Kontostand je Zeitraum als Säulen, unter null rot if (perioden.length) { const werte = perioden.map((p) => p.kontostand as number); const hoch = Math.max(0, ...werte), tiefst = Math.min(0, ...werte), spanne = hoch - tiefst || 1; const nullAb = (hoch / spanne) * 100; const jede = Math.ceil(perioden.length / 13); inhalt.insertAdjacentHTML("beforeend", `

Kontostand am Ende ${ansicht === "woche" ? "der Woche" : "des Monats"}

${perioden.map((p, i) => { const v = p.kontostand as number, h = (Math.abs(v) / spanne) * 100; return `
${i % jede === 0 ? (ansicht === "woche" ? `KW ${kalenderwoche(p.von)}` : MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]!.slice(0, 3)) : ""}
`; }).join("")}
`); } // Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum const heuteD = heute(); const zeile = (x: Zeile) => { const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : ""; return `${dat(x.datum)}${esc(x.bezeichnung)}${esc(x.gruppe)} ${projekt}${euro(x.betrag)}`; }; const tab = document.createElement("table"); tab.className = "liqui-tabelle"; tab.innerHTML = `${ansicht === "woche" ? "Woche" : "Monat"}EinnahmenAusgabenSaldoKontostand ${perioden.map((p) => { const offen = liquiOffen.has(p.von); const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag)); return `${offen ? "▾" : "▸"} ${esc(zeitraum(p))} ${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"} ${p.einnahmen ? euro(p.einnahmen) : "–"}${p.ausgaben ? euro(p.ausgaben) : "–"}${euro(p.saldo)} ${euro(p.kontostand)} ${offen ? `${posten.length ? `${posten.map(zeile).join("")}
Fällig amWasProjektBetrag
` : '

Keine Zahlungen in diesem Zeitraum.

'}` : ""}`; }).join("")}`; tab.addEventListener("click", (ev) => { const tr = (ev.target as HTMLElement).closest("tr.periode"); if (!tr) return; const von = tr.dataset.von!; liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von); liquiditaetSeite(ansicht, anzahl); }); const alleOffen = perioden.every((p) => liquiOffen.has(p.von)); const alleKnopf = leiste.querySelector("#l-alle")!; alleKnopf.textContent = alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen"; alleKnopf.onclick = () => { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); liquiditaetSeite(ansicht, anzahl); }; inhalt.append(tab); } const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]]; const LK_FELDER: Feld[] = [ { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" }, { name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN }, { name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" }, ]; async function laufendeKosten(): Promise { const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten(); seite("Laufende Kosten", { text: "Neue Position", aktion: neu }); const zeilen = await api("laufende-kosten"); const r = Object.fromEntries(RHYTHMEN); inhalt.appendChild(tabelle([ { titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) }, { titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" }, { titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" }, ], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten())); const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0); inhalt.insertAdjacentHTML("beforeend", `

Monatlich: ${euro(monat)}

`); } // G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar const KATEGORIEN_BEARBEITEN = { text: "Kategorien bearbeiten …", aktion: kategorienBearbeiten }; const kategorieOptionen = (liste: Zeile[], leer = "–"): [string, string][] => [["", leer], ...liste.map((k): [string, string] => [k.id, k.name])]; /** Kleiner Editor über allem anderen; liefert danach die Optionen für ein Auswahlfeld. */ function kategorienBearbeiten(): Promise<[string, string][]> { return new Promise((fertig) => { const warSichtbar = !huelle.hidden; huelle.hidden = false; const box = document.createElement("div"); box.className = "dialog kategorien"; box.style.position = "fixed"; huelle.appendChild(box); let liste: Zeile[] = []; const zeichne = async (fehler = "") => { liste = await api("aufgaben-kategorien"); box.innerHTML = `

Kategorien

    ${liste.map((k) => `
  • `).join("")}
${liste.length ? "" : '

Noch keine Kategorien.

'}

${esc(fehler)}

Gelöschte Kategorien verschwinden aus den Aufgaben, die Aufgaben bleiben.

`; (box.querySelector("#kat-neu") as HTMLInputElement).focus(); }; const versuche = async (fn: () => Promise) => { try { await fn(); await zeichne(); } catch (e) { await zeichne((e as Error).message); } }; box.addEventListener("submit", (ev) => { ev.preventDefault(); const name = (box.querySelector("#kat-neu") as HTMLInputElement).value.trim(); if (name) versuche(() => api("aufgaben-kategorien", "POST", { name })); }); box.addEventListener("change", (ev) => { const feld = ev.target as HTMLInputElement; const k = liste.find((x) => x.id === feld.dataset.id); if (k && feld.value.trim() && feld.value.trim() !== k.name) versuche(() => api(`aufgaben-kategorien/${k.id}`, "PATCH", { name: feld.value.trim() })); }); box.addEventListener("click", async (ev) => { const b = ev.target as HTMLElement; if (b.dataset.weg) versuche(() => api(`aufgaben-kategorien/${b.dataset.weg}`, "DELETE")); if (b.dataset.a === "fertig") { box.remove(); huelle.hidden = !warSichtbar; fertig(kategorieOptionen(await api("aufgaben-kategorien"))); } }); zeichne(); }); } interface AufgabenNamen { projekt: Record; kontakt: Record; kategorie: Record } /** Felder für eine Aufgabe und die Namen für die Anzeige, jeweils frisch geladen */ async function aufgabenDaten(): Promise<{ felder: Feld[]; namen: AufgabenNamen; kategorien: Zeile[]; projekte: Zeile[] }> { const [kategorien, projekte, kontakte] = await Promise.all([api("aufgaben-kategorien"), api("projekte"), api("kontakte")]); // Kunden (Bauherren) zuerst, dann alle anderen Kontakte const sortiert = [...kontakte].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de")); return { felder: [ { name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" }, { name: "kategorie_id", titel: "Kategorie", art: "auswahl", optionen: kategorieOptionen(kategorien), bearbeiten: KATEGORIEN_BEARBEITEN }, { name: "projekt_id", titel: "Projekt", art: "auswahl", optionen: [["", "–"], ...projekte.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`])] }, { name: "kontakt_id", titel: "Kunde / Kontakt", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.firma ? `${k.name} (${k.firma})` : k.name])] }, ], namen: { projekt: Object.fromEntries(projekte.map((p) => [p.id, `${p.nummer} ${p.bezeichnung}`])), kontakt: Object.fromEntries(kontakte.map((k) => [k.id, k.name])), kategorie: Object.fromEntries(kategorien.map((k) => [k.id, k.name])), }, kategorien, projekte, }; } async function neueAufgabe(vorgaben: Zeile = {}): Promise { return bearbeiten("aufgaben", "Neue Aufgabe", (await aufgabenDaten()).felder, null, vorgaben); } function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLTableElement { const zuordnung = (z: Zeile) => [ohneProjekt ? "" : namen.projekt[z.projekt_id], namen.kontakt[z.kontakt_id]].filter(Boolean).map(esc).join(" · "); const t = tabelle([ { titel: "", wert: (z) => `` }, { titel: "Aufgabe", wert: (z) => `${z.erledigt_am ? `${esc(z.text)}` : esc(z.text)}${zuordnung(z) ? `${zuordnung(z)}` : ""}` }, { titel: "Kategorie", wert: (z) => (z.kategorie_id ? `${esc(namen.kategorie[z.kategorie_id])}` : "") }, { titel: "Fällig", wert: (z) => `${dat(z.faellig_am)}` }, ], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden()); t.classList.add("aufgaben-tabelle"); t.addEventListener("click", async (ev) => { const box = ev.target as HTMLInputElement; if (box.type !== "checkbox") return; ev.stopPropagation(); await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null }); neuLaden(); }, true); return t; } // Filter der Aufgabenliste bleiben beim Wechsel zwischen den Reitern erhalten const aufgabenFilter = { kategorie: "", projekt: "", erledigte: false }; async function aufgaben(): Promise { const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() }); const [d, alle] = await Promise.all([aufgabenDaten(), api("aufgaben")]); const f = aufgabenFilter; if (f.kategorie && f.kategorie !== "ohne" && !d.namen.kategorie[f.kategorie]) f.kategorie = ""; leiste.innerHTML = ` `; const kat = leiste.querySelector("#a-kategorie") as HTMLSelectElement; bearbeitbareAuswahl(kat, KATEGORIEN_BEARBEITEN, () => { f.kategorie = kat.value; aufgaben(); }); (leiste.querySelector("#a-projekt") as HTMLSelectElement).onchange = (ev) => { f.projekt = (ev.target as HTMLSelectElement).value; aufgaben(); }; (leiste.querySelector("#a-erledigte") as HTMLInputElement).onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; aufgaben(); }; const passt = (wert: string | null, filter: string) => !filter || (filter === "ohne" ? !wert : wert === filter); const zeilen = alle.filter((a) => (f.erledigte || !a.erledigt_am) && passt(a.kategorie_id, f.kategorie) && passt(a.projekt_id, f.projekt)); inhalt.appendChild(aufgabenTabelle(zeilen, d.namen, d.felder, aufgaben)); inhalt.insertAdjacentHTML("beforeend", `

${zeilen.length} von ${alle.length} Aufgaben

`); } const WOCHENTAG = ["", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; const WOCHENTAG_LANG = ["", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]; const wtag = (d: string) => new Date(`${d}T00:00:00Z`).getUTCDay() || 7; // Startseite in der Reihenfolge, die Henning festgelegt hat: Aufgaben und Warnungen gleichrangig // nebeneinander, darunter wer was wann wo macht, dann die Liquidität async function uebersicht(): Promise { const u = await api(`uebersicht?heute=${heute()}`); seite("Übersicht"); inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("beforeend", ` ${WOCHENTAG_LANG[wtag(u.heute)]}, ${dat(u.heute)}`); const aufgabeLi = (a: Zeile) => `
  • ${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}${a.kategorie ? `${esc(a.kategorie)}` : ""}
  • `; const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `

    ${titel} ${liste.length}

    ${liste.length ? `
      ${liste.map(aufgabeLi).join("")}
    ` : `

    ${leer}

    `}
    `; const SYMBOL: Record = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€" }; const raster = document.createElement("div"); raster.className = "start"; raster.innerHTML = `

    Aufgaben

    ${gruppe("Noch nicht abgearbeitet", u.aufgaben.ueberfaellig, "Nichts liegen geblieben.", true)} ${gruppe(`Diese Woche`, u.aufgaben.dieseWoche, "Keine Aufgaben mehr in dieser Woche.")} ${gruppe("Langfristig", u.aufgaben.langfristig, "Keine langfristigen Aufgaben.")}

    Warnungen

    ${u.warnungen.length ? `` : '

    Alles im grünen Bereich.

    '}

    Wer macht was

    Terminplan
    ${einsatzHtml(u.einsatz)}

    Liquidität 4 Wochen

    Details
    ${u.liquiditaet.map((p: Zeile) => `
    ab ${dat(p.von).slice(0, 6)}${euro(p.kontostand)}Saldo ${euro(p.saldo)}
    `).join("")}
    `; inhalt.appendChild(raster); raster.addEventListener("change", async (ev) => { const box = ev.target as HTMLInputElement; if (!box.dataset.erledigt) return; await api(`aufgaben/${box.dataset.erledigt}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null }); uebersicht(); }); raster.querySelector('[data-a="neue-aufgabe"]')!.onclick = async () => { if (await neueAufgabe()) uebersicht(); }; } function einsatzHtml(e: Zeile): string { if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '

    In den nächsten zwei Wochen ist nichts eingeplant.

    '; const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])]; const kopf = e.tage.map((d: string, i: number) => `${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}`).join(""); const zelle = (eintraege: Zeile[], d: string, i: number) => `${eintraege.map((x) => `${esc(x.projekt.split(" ")[0])} ${esc(x.name)}`).join("")}`; const tabelle = `
    ${kopf}${zeilen.map((z: Zeile) => `${z.tage.map((t: Zeile[], i: number) => zelle(t, e.tage[i], i)).join("")}`).join("")}
    Wer
    ${esc(z.anzeige)}
    `; // am Handy: je Tag eine Liste const liste = `
    ${e.tage.map((d: string, i: number) => { const eintraege = zeilen.flatMap((z: Zeile) => z.tage[i].map((x: Zeile) => ({ ...x, wer: z.anzeige }))); return eintraege.length ? `

    ${WOCHENTAG_LANG[wtag(d)]}, ${dat(d)}

      ${eintraege.map((x: Zeile) => `
    • ${esc(x.wer)} ${esc(x.projekt)} · ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}
    • `).join("")}
    ` : ""; }).join("")}
    `; return tabelle + liste; } // T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab) function kalenderLinks(token: string | null): void { const ziel = document.getElementById("kalender")!; const neu = async () => { if (token && !(await bestaetigen("Neue Links erzeugen? Die bisherigen Abos in Outlook funktionieren dann nicht mehr."))) return; kalenderLinks((await api<{ kalenderToken: string }>("kalender/neu", "POST")).kalenderToken); }; if (!token) { ziel.innerHTML = `

    Die Vorgänge aus dem Terminplan und fällige Aufgaben lassen sich als Internetkalender in Outlook einbinden.

    `; ziel.querySelector("button")!.onclick = neu; return; } const link = (name: string) => `${location.origin}/kalender/${token}/${name}`; ziel.innerHTML = `${[["Baustellen", "baustellen.ics"], ["Aufgaben", "aufgaben.ics"]].map(([titel, datei]) => ``).join("")}

    In Outlook: Datei → Kontoeinstellungen → Kontoeinstellungen → Internetkalender → Neu, Link einfügen, Name „Baustellen“ bzw. „Aufgaben“. Outlook holt Änderungen etwa stündlich ab. Wer den Link hat, kann die Termine lesen; gib ihn deshalb nicht weiter.

    `; ziel.onclick = async (ev) => { const b = ev.target as HTMLElement; if (b.dataset.kopie) { try { await navigator.clipboard.writeText(b.dataset.kopie); b.textContent = "Kopiert"; } catch { (b.previousElementSibling as HTMLInputElement).select(); } } if (b.dataset.a === "neu") neu(); }; } /** Testversion im Browser (demo/): speichert anders und kennt keine Kalender-Abos */ const testversion = (globalThis as { betriebTestversion?: { sichern(): Promise } }).betriebTestversion; async function daten(): Promise { seite("Daten und Einstellungen"); const e = await api("einstellungen"); inhalt.insertAdjacentHTML("beforeend", ` ${testversion ? `

    Testversion: Deine Eingaben werden mit diesem Link gespeichert. Mit der Sicherungsdatei ziehen sie später auf den Server um.

    ` : `

    Kompletten Stand als JSON sichern

    Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.

    `}

    Sicherung einspielen

    Sicherungsdatei aus diesem Programm wählen (betrieb-….json), zum Beispiel aus der Testversion. Geht nur, solange noch nichts erfasst ist.

    Übernahme aus dem Projektplaner V70

    Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.

    Kalender in Outlook

    Einstellungen

    `); if (testversion) { document.getElementById("kalender")!.innerHTML = `

    Die Kalender-Abos für Outlook funktionieren erst auf dem Server.

    `; const knopf = document.getElementById("sichern")!, ergebnis = document.getElementById("sichern-ergebnis")!; knopf.onclick = async () => { try { ergebnis.textContent = await testversion.sichern(); } catch (err) { ergebnis.textContent = (err as Error).message; } }; } else kalenderLinks(e.kalenderToken); const stand = document.getElementById("stand-datei") as HTMLInputElement; stand.onchange = async () => { const f = stand.files?.[0]; const ziel = document.getElementById("stand-ergebnis")!; if (!f) return; try { const r = await api<{ anzahl: Record }>("import/stand", "POST", JSON.parse(await f.text())); ziel.innerHTML = `

    Eingespielt: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.aufgaben} Aufgaben, ${r.anzahl.kontakte} Kontakte.

    `; } catch (e) { ziel.innerHTML = `

    ${esc((e as Error).message)}

    `; } stand.value = ""; }; const datei = document.getElementById("v70-datei") as HTMLInputElement; datei.onchange = async () => { const f = datei.files?.[0]; const ziel = document.getElementById("v70-ergebnis")!; if (!f) return; try { const r = await api<{ anzahl: Record; hinweise: string[] }>("import/v70", "POST", JSON.parse(await f.text())); ziel.innerHTML = `

    Übernommen: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.zahlungen} Abschläge, ${r.anzahl.kosten} Kosten, ${r.anzahl.laufendeKosten} laufende Kosten, ${r.anzahl.kontakte} Kontakte.

    ` + (r.hinweise.length ? `

    Bitte prüfen:

      ${r.hinweise.map((h) => `
    • ${esc(h)}
    • `).join("")}
    ` : ""); } catch (e) { ziel.innerHTML = `

    ${esc((e as Error).message)}

    `; } datei.value = ""; }; const felder: Feld[] = [ { name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" }, { name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" }, { name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" }, { name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" }, { name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] }, { name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] }, { name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" }, ]; const knopf = document.createElement("button"); knopf.className = "neben"; knopf.textContent = "Einstellungen bearbeiten"; knopf.onclick = async () => { const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false); if (r?.aktion !== "speichern") return; const d = r.daten; await api("einstellungen", "PUT", { ...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag, // Datum merken, damit die Startseite weiß, dass der Kontostand eingetragen ist startsaldoDatum: (d.startsaldo ?? 0) !== e.startsaldo ? heute() : e.startsaldoDatum, zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 }, ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung }, }); daten(); }; inhalt.appendChild(knopf); } // Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Benutzer und Daten immer zuletzt. // Was jemand sieht, hängt an seiner Rolle (U2); Mitarbeiter bekommen ihre eigene, schlanke Ansicht (E27). type Reiter = [string, string, () => Promise]; function reiterFuer(s: Sitzung): Reiter[] { const rolle = s.benutzer?.rolle; if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]]; const alle: Reiter[] = [ ["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte], ["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten], ]; if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]); return alle; } // Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift const SYMBOLE: Record = { uebersicht: '', aufgaben: '', projekte: '', terminplan: '', kontakte: '', liquiditaet: '', "laufende-kosten": '', benutzer: '', "meine-einsaetze": '', daten: '', }; const symbol = (id: string) => ``; const nav = document.getElementById("reiter")!; let REITER: Reiter[] = []; nav.addEventListener("click", (ev) => { const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r; if (r) location.hash = r; }); async function zeige(): Promise { const id = location.hash.slice(1) || REITER[0]![0]; // Projektseite: #projekt-, gehört zum Reiter Projekte; Mitarbeiter: #ablage- const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id); const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1]; const projekt = treffer?.[1]; if (treffer?.[2]) projektTeil = treffer[2]; const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : id)) ?? REITER[0]!; nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0])); try { await (ablage ? ablageSeite(ablage) : projekt && REITER.some(([r]) => r === "projekte") ? projektSeite(projekt) : reiter[2]()); } catch (e) { inhalt.insertAdjacentHTML("beforeend", `

    ${esc((e as Error).message)}

    `); } } window.addEventListener("unhandledrejection", (ev) => { inhalt.insertAdjacentHTML("afterbegin", `

    ${esc(ev.reason?.message ?? ev.reason)}

    `); }); async function start(): Promise { let s = await api("sitzung"); // Testversion: gewählter Benutzer gelöscht oder gesperrt → wieder als Inhaber if (s.art === "testversion" && lies(TEST_BENUTZER) && s.benutzer?.id !== lies(TEST_BENUTZER)) { merke(TEST_BENUTZER, null); s = await api("sitzung"); } if (!s.benutzer) return anmeldeSeite(s); abgemeldet.melden = () => { location.hash = ""; location.reload(); }; document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter"); REITER = reiterFuer(s); nav.innerHTML = REITER.map(([id, titel]) => ``).join(""); werLeiste(s); window.addEventListener("hashchange", zeige); await zeige(); } start().catch((e) => inhalt.insertAdjacentHTML("beforeend", `

    ${esc((e as Error).message)}

    `)); api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});