Files
Betriebsf-hrungssoftware/src/web/app.ts
Claude cfa656e98f
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.49.0: Anschrift mit z. Hd. und Briefanrede in Angeboten, Rechnungsanschrift im Projekt
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-11-08 14:12:56 +00:00

1731 lines
136 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
import type { Empfaenger } from "../domain/brief.js";
import { kalenderwoche, terminplanSeite } from "./gantt.js";
import { terminplanHandy, vorgangImTerminplan } from "./terminhandy.js";
import { type DialogPruefung, type Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
huelle, hinweisHtml, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER, PC_ANSICHT, istHandy, pcAnsichtAnwenden, MODULE, modulAn } from "./ui.js";
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
import { ablageSeite, baustelleSeite, heuteSeite, meineEinsaetze } from "./mitarbeiter.js";
import { meinUrlaub } from "./urlaub.js";
import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, eigenenWertMerken, eigenerWert, filterMenue, filterText, gespeicherteAnsicht, liste, menue, menueSchliessen } from "./liste.js";
import { gesamtFortschritt } from "../domain/fortschritt.js";
import { plusTage } from "../domain/datum.js";
import { naechsteProjektNummer, nummerKern, nummerSchluessel, projektNummer, zerlege } from "../domain/nummer.js";
import { PRIOS, PRIO_TEXT, type PrioErgebnis, TERMINDRUCK, prioErklaerung } from "../domain/prioritaet.js";
import { type Eckdaten, type Reihenfolge, STANDARD_REIHENFOLGE, eckdatenRechnen, kostenSetzen, kostenVon, rohertragVon, vorn } from "../domain/eckdaten.js";
import { formatEuro, parseEuro } from "../domain/geld.js";
import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
import { meineStunden, stundenSeite } from "./stunden.js";
import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite } from "./angebote.js";
import { dokumentMenue } from "./dokument.js";
import { vorlageSeite } from "./mengenblatt.js";
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiditaetSeite, zaehltHaken, zaehltSetzen } from "./liquiditaet.js";
import { laufendeKostenSeite } from "./laufendekosten.js";
import { jahresplanSeite } from "./jahresplan.js";
import { kontaktSeite } from "./kontakt.js";
import { ART_KURZ, ZUSTAENDIG } from "../domain/kontaktdaten.js";
// ---------- Reiter ----------
async function kontakte(): Promise<void> {
// die Liste bleibt wie bisher (Henning, 08.11.2026); ein Klick öffnet die neue Kontaktmaske
seite("Kontakte", { text: "Neuer Kontakt", aktion: () => { location.hash = "kontakt-neu"; } });
const gruppeKnopf = document.createElement("button");
gruppeKnopf.className = "neben";
gruppeKnopf.textContent = "Neue Firma / Familie";
gruppeKnopf.onclick = () => { location.hash = "kontakt-neu-gruppe"; };
inhalt.querySelector(".kopf .haupt")?.before(gruppeKnopf);
const [zeilen, imHandy, rollen, zug] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("kontakte-abgleich/kontakte").catch(() => []), api<Zeile[]>("kontakt-rollen"), api<Zeile[]>("kontakt-zugehoerigkeiten")]);
const namen = new Map(zeilen.map((k) => [k.id, k.name as string]));
// Firma: eingetragene Firma, sonst der erste übergeordnete Kontakt
const firma = (z: Zeile) => (z.art ? "" : z.firma || namen.get(zug.find((x) => x.person_id === z.id)?.gruppe_id) || "");
const handy = new Map(imHandy.map((h) => [h.kontakt_id, h.geloescht]));
const rolle = Object.fromEntries(rollen.map((r) => [r.id, r.name]));
const rollenText = (z: Zeile) => (z.rollen ?? []).map((r: string) => rolle[r] ?? r).join(", ");
inhalt.appendChild(liste({
schluessel: "kontakte", einheit: ["Kontakt", "Kontakte"], vorgabe: { sort: [["name", "auf"]] },
spalten: [
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
{ id: "firma", titel: "Firma", wert: (z) => esc(firma(z)), text: firma, klasse: "optional" },
{ id: "rolle", titel: "Rolle", wert: (z) => esc(rollenText(z)), text: rollenText },
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk), klasse: "optional" },
{ id: "telefon", titel: "Telefon", wert: (z) => (z.telefon ?? z.mobil ? `<a href="tel:${esc(z.telefon ?? z.mobil)}">${esc(z.telefon ?? z.mobil)}</a>` : "") },
{ id: "email", titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
{ id: "ort", titel: "Ort", wert: (z) => esc(z.ort), klasse: "optional" },
...(handy.size ? [{ id: "handy", titel: "Handy", klasse: "optional", wert: (z: Zeile) => !handy.has(z.id) ? "" : handy.get(z.id) ? '<span class="mark-handy weg">im Handy gelöscht</span>' : '<span class="mark-handy">↔ Handy</span>',
sortWert: (z: Zeile) => (!handy.has(z.id) ? "" : handy.get(z.id) ? "im Handy gelöscht" : "im Handy") }] : []),
],
zeilen, klick: (z) => { location.hash = `kontakt-${z.id}`; },
}));
}
const ECK_OFFEN = "betrieb-eckdaten-offen";
const STATUS: [string, string][] = [
["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"],
["abgerechnet", "Abgerechnet"], ["gewaehrleistung", "Gewährleistung"], ["abgeschlossen", "Abgeschlossen"], ["intern", "Intern"],
];
const STATUS_TEXT = Object.fromEntries(STATUS);
const etikett = (status: string) => `<span class="etikett ${esc(status)}">${esc(STATUS_TEXT[status] ?? status)}</span>`;
const VERTRAGSARTEN: [string, string][] = [["", "–"], ["vob", "VOB/B"], ["bgb", "BGB"]];
async function projektFelder(): Promise<Feld[]> {
const kontaktListe = await api<Zeile[]>("kontakte");
// übergeordnete Kontakte (Firma, Familie, Ehepaar …) zuerst, dann Bauherren, dann alle anderen (0.47)
const rang = (k: Zeile) => (k.art ? 0 : (k.rollen ?? []).includes("bauherr") ? 1 : 2);
const sortiert = [...kontaktListe].sort((a, b) => rang(a) - rang(b) || 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 (Rechnung an)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.art ? `${k.name} (${ART_KURZ[k.art] ?? ""})` : k.name])],
neu: { text: "+ Neuer Kunde …", titel: "Neuen Kunden anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" }, { name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }],
anlegen: async (d) => { const k = await api<Zeile>("kontakte", "POST", { ...d, rolle: "bauherr" }); return [k.id, k.name]; } } },
{ name: "baustelle_strasse", titel: "Baustelle: Straße", adresse: { plz: "baustelle_plz", ort: "baustelle_ort" } }, { 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" },
// Priorität A/B/C (Henning, 08.11.2026): leer = Vorschlag aus Ertrag, Kunde und Dringlichkeit
{ name: "prioritaet", titel: "Priorität", art: "auswahl", optionen: [["", "Vorschlag des Programms"], ...PRIOS.map((x): [string, string] => [x, PRIO_TEXT[x]])],
hilfe: "Leer lassen: das Programm schlägt A, B oder C vor (Ertrag je Stunde, Kunde, Dringlichkeit)." },
{ name: "frist", titel: "Fertig bis (Frist)", art: "datum" },
{ name: "termindruck", titel: "Termindruck", art: "auswahl", optionen: TERMINDRUCK },
// Kosten der Baustelle als eine Zeile (Henning, 08.11.2026); intern bleibt die Aufteilung für Liquidität und Nachkalkulation
{ name: "umsatz_netto", titel: "Auftragswert netto", art: "euro" }, { name: "kosten", titel: "Kosten der Baustelle", 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;
/** Projekt für den Dialog: die drei Kostenarten als eine Summe */
const mitKosten = (p: Zeile) => ({ ...p, kosten: kostenSumme(p) });
/** Summe aus dem Dialog zurück auf die drei Kostenarten, im bisherigen Verhältnis (ohne bisherige Kosten: alles Material) */
function kostenAufteilen(d: Zeile, alt?: Zeile): Zeile {
const { kosten, ...rest } = d;
const k = kostenSetzen(alt ? eckVon(alt) : { umsatz: 0, material: 0, fremd: 0, sonstige: 0, personen: null, tage: null, stunden: null }, Number(kosten ?? 0));
return { ...rest, material_kosten: k.material, fremd_kosten: k.fremd, sonstige_kosten: k.sonstige };
}
const eckVon = (p: Zeile): Eckdaten => ({ umsatz: p.umsatz_netto, material: p.material_kosten, fremd: p.fremd_kosten, sonstige: p.sonstige_kosten,
personen: p.personen === null || p.personen === undefined ? null : Number(p.personen), tage: p.soll_tage === null || p.soll_tage === undefined ? null : Number(p.soll_tage),
stunden: p.soll_stunden === null || p.soll_stunden === undefined ? null : Number(p.soll_stunden) });
const ortZeile = (p: Zeile) => [p.baustelle_strasse, [p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
// Projektnummern (Henning, 26.10.2026): doppelte schon im Dialog ablehnen, mit Knopf für die nächste freie
const NUMMER_HILFE = "Vorschlag: die nächste freie Nummer. Den Buchstaben setzt das Programm nach dem Status: A Anfrage/Angebot, P Auftrag, G Gewährleistung, I Intern.";
function nummerPruefung(alle: Zeile[], eigeneId: string | null): DialogPruefung {
return (d) => {
const status = String(d.status ?? "auftrag"), roh = String(d.nummer ?? "");
const x = zerlege(roh);
if (!x) return null;
const nummer = x.buchstabe !== "" && (x.buchstabe === "I") !== (status === "intern") ? "" : projektNummer(roh, status);
const andere = alle.filter((p) => p.id !== eigeneId);
const doppelt = nummer && andere.find((p) => nummerSchluessel(String(p.nummer)) === nummerSchluessel(nummer));
if (!doppelt) return null;
const frei = naechsteProjektNummer(andere.map((p) => String(p.nummer)), 2000 + Number(x.jj), status);
return { fehler: `Die Nummer ${nummerKern(nummer)} hat schon „${doppelt.bezeichnung}“ (${doppelt.nummer}).`, vorschlag: { feld: "nummer", wert: frei, text: `Nächste freie nehmen: ${frei}` } };
};
}
/** Priorität als farbige Marke; selbst gesetzt mit Punkt, der Vorschlag steht im Tooltip */
export const prioMarke = (x: PrioErgebnis | null | undefined) =>
x ? `<span class="prio prio-${x.prioritaet}${x.selbst ? " selbst" : ""}" title="${esc(prioErklaerung(x))}">${x.prioritaet}</span>` : "";
async function projekte(): Promise<void> {
const neu = async () => {
// Vorschlag: nächste freie Nummer im Jahr, A- für Anfrage und Angebot, P- ab Auftrag (Henning, 21.10.2026)
const [felder, alle, angebote] = await Promise.all([projektFelder(), api<Zeile[]>("projekte"), api<Zeile[]>("angebote-liste")]);
const nummern = [...alle, ...angebote].map((x) => String(x.nummer));
// Vorschlag je Status: A, P, G, eigene Reihe I für Intern (Henning, 24. und 26.10.2026)
const vorschlagFuer = (status: string) => naechsteProjektNummer(nummern, new Date().getFullYear(), status);
const vorschlaege = new Set(STATUS.map(([s]) => vorschlagFuer(s)));
const offen = dialog("Neues Projekt", felder.map((f) => (f.name === "nummer" ? { ...f, hilfe: NUMMER_HILFE } : f)), { status: "anfrage", nummer: vorschlagFuer("anfrage") }, false,
nummerPruefung(alle, null));
const nummerFeld = huelle.querySelector<HTMLInputElement>("#f-nummer"), statusFeld = huelle.querySelector<HTMLSelectElement>("#f-status");
statusFeld?.addEventListener("change", () => {
// nur den Vorschlag anpassen, eine selbst eingetragene Nummer bleibt
if (nummerFeld && vorschlaege.has(nummerFeld.value.trim())) nummerFeld.value = vorschlagFuer(statusFeld.value);
});
const e = await offen;
if (e?.aktion !== "speichern") return;
const p = await api<Zeile>("projekte", "POST", ohneNull(kostenAufteilen(e.daten)));
if (p.ordner_fehler) hinweis.text = p.ordner_fehler;
location.hash = `projekt-${p.id}`;
};
seite("Projekte", { text: "Neues Projekt", aktion: neu });
if (modulAn("angebote")) inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#angebote">Angebote</a>');
const [zeilen, kontaktListe, zahlungen, prios] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte"), api<Zeile[]>("zahlungen"), api<PrioErgebnis[]>("prioritaeten")]);
const prio = new Map(prios.map((x) => [x.id, x]));
const prioRang = (z: Zeile) => { const x = prio.get(z.id); return x ? PRIOS.indexOf(x.prioritaet) + 1 : 9; };
// bereits abgerechnet = Raten mit gestellter oder bezahlter Rechnung, netto; offen = Auftragswert minus abgerechnet (Henning, 27.10.2026)
const abgerechnetJe = new Map<string, number>();
for (const r of zahlungen) if (r.status === "gestellt" || r.status === "bezahlt") abgerechnetJe.set(r.projekt_id, (abgerechnetJe.get(r.projekt_id) ?? 0) + Number(r.netto));
const abgerechnet = (z: Zeile) => abgerechnetJe.get(z.id) ?? 0;
const offen = (z: Zeile) => z.umsatz_netto - abgerechnet(z);
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i]));
inhalt.appendChild(liste({
schluessel: "projekte", einheit: ["Projekt", "Projekte"],
spalten: [
{ id: "name", titel: "Name", text: (z) => z.bezeichnung, wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
{ id: "nummer", titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
{ id: "kunde", titel: "Kunde", wert: (z) => esc(name[z.bauherr_id] ?? ""), klasse: "optional" },
{ id: "ort", titel: "Ort", wert: (z) => esc(z.baustelle_ort ?? ""), klasse: "optional" },
{ id: "status", titel: "Status", handy: "rechts", wert: (z) => etikett(z.status), sortWert: (z) => statusRang[z.status] ?? 99 },
// Priorität A/B/C (Henning, 08.11.2026): Vorschlag des Programms, auf der Projektseite änderbar
{ id: "prio", titel: "Priorität", handy: "links", wert: (z) => prioMarke(prio.get(z.id)), text: (z) => prio.get(z.id)?.prioritaet ?? "–", sortWert: prioRang },
{ id: "umsatz", titel: "Auftragswert", art: "zahl", wert: (z) => euro(z.umsatz_netto), sortWert: (z) => z.umsatz_netto, klasse: "zahl optional" },
{ id: "abgerechnet", titel: "Bereits abgerechnet", art: "zahl", wert: (z) => euro(abgerechnet(z)), sortWert: abgerechnet, klasse: "zahl optional" },
{ id: "offen", titel: "Offener Auftragswert", art: "zahl", wert: (z) => euro(offen(z)), sortWert: offen, klasse: "zahl optional" },
{ id: "kosten", titel: "Kosten", art: "zahl", wert: (z) => euro(kostenSumme(z)), sortWert: kostenSumme, klasse: "zahl optional" },
{ id: "rohertrag", titel: "Rohertrag", art: "zahl", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), sortWert: (z) => z.umsatz_netto - kostenSumme(z), klasse: "zahl optional" },
],
zeilen, klick: (z) => (location.hash = `projekt-${z.id}`),
// Summenzeile über alle Zahlenspalten (Henning, 27.10.2026); bei Filter nur die gefilterten Projekte
summenTitel: "Summe",
summen: (l) => {
const s = (f: (z: Zeile) => number) => euro(l.reduce((x, z) => x + f(z), 0));
return { umsatz: s((z) => z.umsatz_netto), abgerechnet: s(abgerechnet), offen: s(offen), kosten: s(kostenSumme), rohertrag: s((z) => z.umsatz_netto - kostenSumme(z)) };
},
}));
}
// ---------- 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", hilfe: "Bei der Schlussrechnung steht hier der Rest aus Auftragswert und allen anderen Raten; unverändert gelassen rechnet er sich weiter mit." },
{ 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<string, string> = {
kunde: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
zeitraum: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
baustelle: '<path d="M12 21s-7-6.2-7-11a7 7 0 0 1 14 0c0 4.8-7 11-7 11z"/><circle cx="12" cy="10" r="2.5"/>',
auftrag: '<path d="M7 3h8l4 4v14H7z"/><path d="M15 3v4h4M10 12h6M10 16h6"/>',
auftragswert: '<circle cx="12" cy="12" r="9"/><path d="M15.5 8.5a4 4 0 1 0 0 7M7 11h6M7 13.5h6"/>',
stunden: '<circle cx="12" cy="13" r="8"/><path d="M12 9v4l3 2M9 2h6"/>',
ordner: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
beschreibung: '<path d="M4 5h16v11H9l-5 4z"/>',
};
const symbolKachel = (art: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${KACHEL_SYMBOL[art]}</svg>`;
const kachel = (art: string, titel: string, inhaltHtml: string) => `<section class="kachel ${art}"><h3>${symbolKachel(art)}${esc(titel)}</h3>${inhaltHtml}</section>`;
// 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";
// Eckdaten ohne Auftrag: welche Werte zuletzt eingegeben wurden, je Projekt (nur für diese Sitzung)
const eckReihe = new Map<string, Reihenfolge & { roProzent: boolean }>();
const zahlText = (x: number | null) => (x === null || x === undefined ? "" : String(Math.round(x * 100) / 100).replace(".", ","));
let projektTeil = "dokumente";
// Handy: Reiter statt langer Seite (Henning „Ok“, 21.10.2026)
let projektHandy = "ueberblick";
const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN);
const stundenText = (h: number) => { const m = Math.round(h * 60); return `${Math.floor(m / 60)}:${String(m % 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<void> {
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt, angebote, einst] = await Promise.all([
api<Zeile>(`projekte/${id}`), api<Zeile[]>("kontakte"), api<Zeile>("terminplan"),
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"), api<Record<string, number>>("zeiten/projekte"),
api<Zeile[]>(`angebote-liste?projekt_id=${id}`), api<Zeile>("einstellungen").catch(() => null),
]);
const [alleAp, zug] = await Promise.all([api<Zeile[]>("projekt-ansprechpartner"), api<Zeile[]>("kontakt-zugehoerigkeiten")]);
const eigeneAp = alleAp.filter((a) => a.projekt_id === id);
const prio = ((plan.projekte as Zeile[]).find((x) => x.id === id)?.prio ?? null) as PrioErgebnis | null;
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);
// Ansprechpartner im Projekt (0.47): Haupt, Rechnungen, Baustelle, Planung
const ZUST = Object.fromEntries(ZUSTAENDIG);
function ansprechpartnerHtml(): string {
return `<div class="pj-ap"><p class="pj-ap-titel">Ansprechpartner</p>${eigeneAp.map((a) => { const k = kontakt[a.kontakt_id]; const z = zug.find((x) => x.person_id === a.kontakt_id && x.gruppe_id === p.bauherr_id);
const nr = k?.mobil ?? k?.telefon;
return `<div class="pj-ap-zeile"><a href="#kontakt-${esc(a.kontakt_id)}"><b>${esc(k?.name ?? "?")}${(a.zustaendig ?? []).includes("haupt") ? " ★" : ""}</b><small>${esc([z?.funktion, nr].filter(Boolean).join(" · "))}</small></a>
${(a.zustaendig ?? []).map((x: string) => `<span class="kt-zust ${esc(x)}">${esc(ZUST[x] ?? x)}</span>`).join("")}<button class="kt-punkte" data-ap="${esc(a.id)}" aria-label="Ansprechpartner bearbeiten">⋯</button></div>`; }).join("")}
<button class="verweis" data-a="ap-neu">+ Ansprechpartner</button>
${p.bauherr_id ? '<button class="verweis" data-a="rechnung-an">Rechnungsanschrift</button><div class="pj-rechnung-an" hidden></div>' : ""}</div>`;
}
inhalt.innerHTML = `${hinweisHtml()}
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
${prio ? `<select id="p-prio" class="prio-wahl prio-${prio.prioritaet}${prio.selbst ? " selbst" : ""}" aria-label="Priorität" title="${esc(prioErklaerung(prio))}">${optionenHtml(
[["", `Priorität ${prio.vorschlag} (Vorschlag)`], ...PRIOS.map((x): [string, string] => [x, `Priorität ${PRIO_TEXT[x]}`])], prio.selbst ? prio.prioritaet : "")}</select>` : ""}
<button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
${prio ? `<p class="prio-grund">${esc(prioErklaerung(prio))}</p>` : ""}
${kunde?.telefon || ortZeile(p) ? `<div class="handy-aktionen nur-handy">${kunde?.telefon ? `<a class="neben" href="tel:${esc(kunde.telefon)}">Anrufen</a>` : ""}${ortZeile(p) ? `<a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ortZeile(p))}" target="_blank" rel="noopener">Navigation</a>` : ""}</div>` : ""}
<nav class="handy-reiter nur-handy" aria-label="Bereiche">${([["ueberblick", "Überblick"], ["ablauf", "Ablauf"], ["geld", "Geld"], ["ablage", "Ablage"]] as const)
.map(([r, titel]) => `<button data-hr="${r}">${titel}</button>`).join("")}</nav>
<div class="projekt-raster">
<div class="projekt-haupt">
<section class="karte p-stand nur-handy"></section>
<section class="karte p-ablauf nur-handy"></section>
<section class="karte projekt-teile" id="p-oben"><div class="teile-kopf"><nav class="teile">
<button data-oben="uebersicht">Übersicht</button><button data-oben="nachkalkulation">Nachkalkulation</button></nav></div><div class="oben-inhalt"></div></section>
<section class="karte projekt-teile" id="p-unten"><div class="teile-kopf"><nav class="teile">${([["dokumente", "Dokumente"], ["berichte", "Berichte"], ["ablage", "Ablage"], ["zahlungen", "Zahlungsplan"]] as const)
.map(([t, titel]) => `<button data-teil="${t}">${titel}${t === "zahlungen" && eigeneZahlungen.length ? ` <small>${eigeneZahlungen.length}</small>` : ""}</button>`).join("")}</nav>
<span id="teil-knopf"></span></div><div id="teil"></div></section>
</div>
<aside class="karte projekt-aufgaben" aria-label="Offene Aufgaben"></aside>
</div>`;
hinweis.text = "";
hinweis.gut = false;
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
const teil = unten.querySelector<HTMLElement>("#teil")!;
// Haken „zählt“ im Zahlungsplan (Henning, 26.10.2026): wie in der Liquidität, dauerhaft gespeichert
teil.addEventListener("change", (ev) => {
const el = ev.target as HTMLInputElement;
if (el.dataset.zaehlt !== undefined) void zaehltSetzen(el.dataset.zaehlt, el.checked, neuLaden);
});
const knopfOrt = unten.querySelector<HTMLElement>("#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<HTMLElement>("[data-oben]").forEach((b) => b.classList.toggle("aktiv", b.dataset.oben === projektOben));
const ziel = oben.querySelector<HTMLElement>(".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 = istJeProjekt[id] ?? 0;
const anteil = soll ? Math.round((ist / soll) * 100) : null;
const adresse = ortZeile(p);
const mitAuftrag = angebote.some((a) => a.status === "angenommen");
const reihe = eckReihe.get(id) ?? { ...structuredClone(STANDARD_REIHENFOLGE), roProzent: false };
// fehlt genau einer von Personen, Tagen und Stunden, rechnet sich dieser
if (!eckReihe.has(id)) {
const fehlt = (["personen", "tage", "stunden"] as const).filter((w) => !Number(eckVon(p)[w]));
if (fehlt.length === 1) reihe.zeit = [...reihe.zeit.filter((w) => w !== fehlt[0]), fehlt[0]!];
}
eckReihe.set(id, reihe);
const ro = rohertragVon(eckVon(p));
const gerechnet = (w: string) => (reihe.geld[2] === w || reihe.zeit[2] === w ? " gerechnet" : "");
const feld = (name: string, titel: string, wert: string, art: "euro" | "zahl", einheit: string, extra = "") =>
`<label class="eck-feld${gerechnet(extra || name)}"><span>${titel}</span><span class="eck-eingabe"><input data-e="${name}" inputmode="decimal" value="${esc(wert)}" aria-label="${esc(titel)}"><small>${einheit}</small></span></label>`;
// Eckdaten ganz unten und einklappbar (Henning, 24.10.2026); zu ist der Normalfall, offen merkt sich der Browser
const eckOffen = lies(ECK_OFFEN) === "1";
const eckKurz = [umsatz ? `Auftragswert ${euro(umsatz)}` : "kein Auftragswert", umsatz ? `Rohertrag ${euro(ro.euro)}${ro.prozent === null ? "" : ` (${zahlText(Math.round(ro.prozent * 10) / 10)} %)`}` : "", p.soll_stunden ? `${zahlText(p.soll_stunden)} Soll-Std.` : ""].filter(Boolean).join(" · ");
const eckdaten = mitAuftrag ? "" : `<section class="kachel eckdaten${eckOffen ? "" : " zu"}"><h3><button class="eck-pfeil" data-a="eck-auf" aria-expanded="${eckOffen}" title="${eckOffen ? "Eckdaten einklappen" : "Eckdaten aufklappen"}">${symbolKachel("auftragswert")}Eckdaten<span class="pfeil" aria-hidden="true">▾</span></button><small class="hinweis eck-lang">ohne Auftrag direkt eintragen, nach zwei Werten rechnet sich der dritte</small><small class="hinweis eck-kurz">${esc(eckKurz)}</small></h3>
<div class="eck-zeile">${feld("umsatz", "Auftragswert netto", formatEuro(p.umsatz_netto, false), "euro", "€")}<span class="eck-op">−</span>
${feld("kosten", "Kosten", formatEuro(kostenSumme(p), false), "euro", "€")}<span class="eck-op">=</span>
${feld("ro-euro", "Rohertrag", formatEuro(ro.euro, false), "euro", "€", "rohertrag")}${feld("ro-prozent", "in %", ro.prozent === null ? "" : zahlText(Math.round(ro.prozent * 10) / 10), "zahl", "%", "rohertrag")}</div>
<div class="eck-zeile">${feld("personen", "Personen", zahlText(p.personen), "zahl", "")}<span class="eck-op">×</span>${feld("tage", "Arbeitstage", zahlText(p.soll_tage), "zahl", "AT")}
<span class="eck-op">× ${zahlText(einst?.stundenProTag ?? 8)} Std. =</span>${feld("stunden", "Soll-Stunden", zahlText(p.soll_stunden), "zahl", "Std.")}</div>
<p class="hinweis">${eigeneZahlungen.length ? `${eigeneZahlungen.length} ${eigeneZahlungen.length === 1 ? "Rate" : "Raten"} im <button class="verweis" data-teil="zahlungen">Zahlungsplan</button>${p.zahlungsplan === "auto" ? ", passen sich an" : ""}` : "Mit dem Auftragswert und Terminen entsteht der Zahlungsplan."}</p></section>`;
ziel.innerHTML = `<div class="uebersicht-kacheln${mitAuftrag ? "" : " mit-eckdaten"}">
${kachel("stunden", "Arbeitsstunden", `<div class="stunden"><div><p class="gross">${stundenText(ist)}</p><p>/ ${soll ? stundenText(soll) : "0:00 Std."}</p></div>
<svg class="ring" viewBox="0 0 36 36" role="img" aria-label="${anteil === null ? "keine Stunden geplant" : `${anteil} Prozent verbraucht`}"><circle cx="18" cy="18" r="15.5"/>${anteil ? `<circle class="wert" cx="18" cy="18" r="15.5" pathLength="100" stroke-dasharray="${Math.min(100, anteil)} 100"/>` : ""}<text x="18" y="21.5">${anteil === null ? "– %" : `${anteil} %`}</text></svg></div>`)}
${!mitAuftrag ? "" : kachel("auftragswert", "Auftragswert", `<p><button class="verweis gross" data-a="auftragswert" title="Auftragswert ändern">${umsatz ? euro(umsatz) : "eintragen"}</button> <small class="hinweis">netto</small></p>
<p class="hinweis">${eigeneZahlungen.length ? `${eigeneZahlungen.length} ${eigeneZahlungen.length === 1 ? "Rate" : "Raten"} im <button class="verweis" data-teil="zahlungen">Zahlungsplan</button>${p.zahlungsplan === "auto" ? ", passen sich an" : ""}` : "Mit dem Auftragswert und Terminen entsteht der Zahlungsplan."}</p>`)}
${kachel("kunde", "Kunde", p.status === "intern" && !kunde
? '<p class="gross">Intern</p><p class="hinweis">Eigener Betrieb, kein Kunde</p>'
: kunde
? `<p><a href="#kontakt-${esc(kunde.id)}" class="gross">${esc(kunde.name)}</a>${kunde.art ? ` <span class="kt-art">${esc(ART_KURZ[kunde.art] ?? "")}</span>` : kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>${ansprechpartnerHtml()}`
: `<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>${ansprechpartnerHtml()}`)}
<section class="kachel beschreibung"><h3>${symbolKachel("beschreibung")}Beschreibung</h3>
<div class="text zelle-text" data-a="beschreibung" title="Klicken zum Bearbeiten">${p.notiz ? esc(p.notiz) : '<span class="hinweis">Keine Beschreibung. Klicken zum Schreiben.</span>'}</div></section>
${kachel("zeitraum", "Zeitraum", anfang
? `<p class="gross">${dat(anfang)} – ${dat(ende)}</p><p class="hinweis">${vorgaenge.length} ${vorgaenge.length === 1 ? "Vorgang" : "Vorgänge"} in ${abschnitte.length} ${abschnitte.length === 1 ? "Abschnitt" : "Abschnitten"} · <a href="#terminplan">Terminplan</a></p>`
: '<p><a href="#terminplan">Abschnitt im Terminplan hinzufügen</a></p>')}
${kachel("baustelle", "Baustelle", adresse
? `<p><a class="gross" href="https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adresse)}" target="_blank" rel="noopener">${esc(p.baustelle_strasse ?? "")}<br>${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}</a></p>`
: '<p><button class="verweis" data-a="bearbeiten">Adresse eintragen</button></p>')}
${eckdaten}
</div>`;
ziel.onchange = async (ev) => {
const e = (ev.target as HTMLElement).closest<HTMLInputElement>("[data-e]");
if (!e) return;
const name = e.dataset.e!;
const alt = eckVon(p);
const text = e.value.trim();
let neu: Eckdaten = { ...alt };
let roh: { euro: number } | { prozent: number } = reihe.roProzent && rohertragVon(alt).prozent !== null ? { prozent: rohertragVon(alt).prozent! } : { euro: rohertragVon(alt).euro };
try {
const euroWert = () => (text ? Math.max(0, parseEuro(text)) : 0);
const zahl = () => { const x = Number(text.replace(/\./g, "").replace(",", ".")); if (text && !(x >= 0)) throw new Error("Bitte eine Zahl eintragen."); return text && x > 0 ? x : null; };
if (name === "umsatz") { neu.umsatz = euroWert(); reihe.geld = vorn(reihe.geld, "umsatz"); }
if (name === "kosten") { neu = kostenSetzen(neu, euroWert()); reihe.geld = vorn(reihe.geld, "kosten"); }
if (["material", "fremd", "sonstige"].includes(name)) { neu = { ...neu, [name]: euroWert() }; reihe.geld = vorn(reihe.geld, "kosten"); }
if (name === "ro-euro") { roh = { euro: text ? parseEuro(text) : 0 }; reihe.roProzent = false; reihe.geld = vorn(reihe.geld, "rohertrag"); }
if (name === "ro-prozent") { const x = zahl() ?? 0; if (x >= 100) throw new Error("Der Rohertrag muss unter 100 % liegen."); roh = { prozent: x }; reihe.roProzent = true; reihe.geld = vorn(reihe.geld, "rohertrag"); }
if (name === "personen") { neu.personen = zahl(); reihe.zeit = vorn(reihe.zeit, "personen"); }
if (name === "tage") { neu.tage = zahl(); reihe.zeit = vorn(reihe.zeit, "tage"); }
if (name === "stunden") { neu.stunden = zahl(); reihe.zeit = vorn(reihe.zeit, "stunden"); }
} catch (err) { hinweis.text = (err as Error).message; return neuLaden(); }
// der Rohertrag ist selbst eingegeben worden, aber gerade nicht der Wert, der neu gerechnet wird
if (reihe.geld[2] === "rohertrag") roh = { euro: neu.umsatz - kostenVon(neu) };
const x = eckdatenRechnen(neu, reihe, einst?.stundenProTag ?? 8, roh);
const daten = { umsatz_netto: x.umsatz, material_kosten: x.material, fremd_kosten: x.fremd, sonstige_kosten: x.sonstige, personen: x.personen, soll_tage: x.tage, soll_stunden: x.stunden };
Object.assign(p, await api<Zeile>(`projekte/${id}`, "PATCH", daten));
// neu zeichnen und im nächsten Feld weitermachen
const weiter = (document.activeElement as HTMLElement | null)?.dataset?.e;
if (!weiter) return neuLaden();
zeigeOben();
oben.querySelector<HTMLInputElement>(`[data-e="${weiter}"]`)?.select();
};
} else {
ziel.onchange = null;
ziel.innerHTML = `<div class="nachkalkulation">
<dl class="werte"><dt>Auftragswert netto</dt><dd>${euro(umsatz)}</dd><dt>Kosten geplant</dt><dd>${euro(kostenGesamt)}</dd>
<dt>Rohertrag</dt><dd><b>${euro(umsatz - kostenGesamt)}</b>${umsatz ? ` <small>(${Math.round(((umsatz - kostenGesamt) / umsatz) * 100)} %)</small>` : ""}</dd>
<dt>Vertrag</dt><dd>${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}</dd></dl>
<p class="hinweis">Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 3c. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.</p>
<div class="kosten-kopf"><h3>Einzelkosten</h3><button class="neben" data-a="kosten-neu">+ Kosten</button></div><div class="kosten-liste"></div></div>`;
const lieferanten = kontaktListe.filter((k) => (k.rollen ?? []).some((r: string) => r === "lieferant" || r === "subunternehmer"));
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<HTMLButtonElement>('[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 ? liste({
schluessel: "projekt-kosten", klein: true, einheit: ["Position", "Positionen"],
spalten: [
{ id: "bezeichnung", titel: "Bezeichnung", text: (k) => k.bezeichnung, wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc(kontakt[k.kontakt_id]?.name ?? "")}</span>` },
{ id: "art", titel: "Art", wert: (k) => esc(Object.fromEntries(KOSTENARTEN)[k.art] ?? k.art) },
{ id: "termin", titel: "Termin", art: "datum", wert: (k) => dat(k.termin), sortWert: (k) => k.termin },
{ id: "status", titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
{ id: "netto", titel: "Netto", art: "zahl", wert: (k) => euro(k.netto), sortWert: (k) => k.netto, klasse: "zahl" },
],
zeilen: eigeneKosten, klick: 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<HTMLElement>("[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);
// Angebote abgeschaltet (erste Serverversion): Angebote kommen weiter aus Plancraft, nur die Rechnungen bleiben
if (modulAn("angebote")) knopf("+ Dokument ▾", () => void dokumentMenue(knopfOrt.querySelector("button")!, p, angebote));
teil.innerHTML = `${modulAn("angebote") ? `<h3 class="gruppe">Angebote und weitere Dokumente</h3>${angeboteHtml(angebote)}` : ""}
<h3 class="gruppe">Rechnungen</h3>${rechnungen.length ? `<ul class="dokumente">${rechnungen.map((z) => {
const ueberfaellig = z.status === "gestellt" && z.termin < heute();
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
<span class="marken"><span class="marke ${z.status === "bezahlt" ? "gut" : ueberfaellig ? "schlecht" : "offen"}">${z.status === "bezahlt" ? `Bezahlt${z.bezahlt_am ? ` ${dat(z.bezahlt_am)}` : ""}` : ueberfaellig ? "Überfällig" : "Offen"}</span>
<span class="marke grau" title="Festgeschrieben, nicht mehr änderbar">Freigegeben</span><span class="marke dunkel">${esc(art(z))}</span></span></button></li>`;
}).join("")}</ul>` : '<p class="hinweis leer">Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.</p>'}`;
} else if (projektTeil === "berichte") {
teil.innerHTML = `<p class="hinweis leer">Noch keine Berichte.</p>
<ul class="kommt"><li><b>Bautagebuch</b> mit Wetter, Personal und Fotos, am Handy (Stufe 4)</li><li><b>Regiebericht</b> für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)</li><li><b>Abnahmeprotokoll</b> mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung</li></ul>`;
} else if (projektTeil === "ablage") {
void zeigeAblage();
} else {
zeigeZahlungsplan();
}
};
async function zeigeAblage(): Promise<void> {
teil.innerHTML = '<p class="hinweis leer">Lade den Projektordner …</p>';
const teile = ablagePfad ? ablagePfad.split("/") : [];
const pfadLeiste = `<nav class="pfad" aria-label="Ordner"><button class="verweis" data-ablage="">${esc(p.nextcloud_link ? p.nextcloud_link.split("/").at(-1) : "Projektordner")}</button>${teile.map((t, i) =>
` / <button class="verweis" data-ablage="${esc(teile.slice(0, i + 1).join("/"))}">${esc(t)}</button>`).join("")}</nav>`;
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 ? `<ul class="ablage">${a.eintraege.map((e) => e.ordner
? `<li><button class="eintrag" data-ablage="${esc(voll(e.name))}"><span class="sym" aria-hidden="true">📁</span><span class="name">${esc(e.name)}</span></button></li>`
: `<li><a class="eintrag" href="/api/projekte/${id}/ablage/datei?pfad=${encodeURIComponent(voll(e.name))}" target="_blank" rel="noopener"><span class="sym" aria-hidden="true">📄</span><span class="name">${esc(e.name)}</span>
<span class="hinweis">${e.geaendert ? dat(e.geaendert.slice(0, 10)) + " · " : ""}${groesseText(e.groesse)}</span></a></li>`).join("")}</ul>` : '<p class="hinweis leer">Der Ordner ist leer.</p>'}`;
} catch (e) {
if (projektTeil !== "ablage") return;
teil.innerHTML = `<p class="hinweis leer">${esc((e as Error).message)}</p>
<p class="hinweis">Im Projektordner liegen die Unterordner „01 Auftrag“ (Angebote, Auftragsbestätigung, Rechnungen, Lieferscheine), „02 Umsetzung“ und „03 Bilder“.</p>`;
}
}
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];
// vor | nach (Henning, 26.10.2026): am Anfang (AA) oder am Ende (EE) des Vorgangs fällig
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])],
umschalter: { name: "bezug_art", optionen: [["AA", "vor"], ["EE", "nach"]], titel: { AA: "Fällig vor Vorgang", EE: "Fällig nach Vorgang" },
hilfe: { AA: "Fällig am Anfang des Vorgangs, wandert mit ihm.", EE: "Fällig am Ende des Vorgangs, wandert mit ihm." } } });
// Zahlungsfrist je Rate für die Liquidität: Geld kommt Rechnungsdatum (sonst Termin) plus Frist; Vorschlag 14 Kalendertage (Henning, 21.10.2026)
const fristVorschlag = Number(einst?.zahlungsziele?.kundenTage ?? 14);
const frist = (z: Zeile) => (z.zahlungsziel_tage == null ? fristVorschlag : Number(z.zahlungsziel_tage));
const zahlungErwartet = (z: Zeile) => z.bezahlt_am ?? plusTage(z.rechnungsdatum ?? z.termin, frist(z));
felder.splice(felder.findIndex((f) => f.name === "rechnungsdatum") + 1, 0, { name: "zahlungsziel_tage", titel: "Zahlungsfrist (Kalendertage)", art: "zahl",
hilfe: `Für die Liquidität: Das Geld kommt am Rechnungsdatum (vorher am Termin) plus Frist. Vorschlag ${fristVorschlag} Tage.` });
// Schlussrechnung ohne Betrag: Rest aus Auftragswert und den anderen Raten (Henning, 20.10.2026)
const zahlungBearbeiten = async (z: Zeile | null) => {
// Schlussrechnung zeigt den Rest gleich als Betrag (Henning, 26.10.2026); unverändert gespeichert bleibt sie „Rest“ und rechnet mit
const restBetrag = Math.max(0, (umsatz || 0) - eigeneZahlungen.filter((x) => x.id !== z?.id).reduce((s, x) => s + x.netto, 0));
const werte = z ? { ...z, netto: z.rest && z.status === "geplant" ? restBetrag : z.netto, zahlungsziel_tage: frist(z), bezug_art: z.vorgang_id ? z.bezug_art ?? "EE" : "EE" }
: { projekt_id: id, art: "abschlag", status: "geplant", termin: heute(), netto: null, zahlungsziel_tage: fristVorschlag, bezug_art: "EE" };
const offen = dialog(z ? "Zahlung bearbeiten" : "Neue Zahlung", felder, werte, !!z);
const artFeld = huelle.querySelector<HTMLSelectElement>("#f-art")!, nettoFeld = huelle.querySelector<HTMLInputElement>("#f-netto")!;
artFeld.addEventListener("change", () => {
if (artFeld.value === "schluss" && (!nettoFeld.value.trim() || parseEuro(nettoFeld.value) === 0)) nettoFeld.value = formatEuro(restBetrag, false);
});
// „Bezahlt am“ und Status gehören zusammen (Henning, 26.10.2026): Datum eingetragen = bezahlt, bezahlt ohne Datum = heute
const st = huelle.querySelector<HTMLSelectElement>("#f-status")!, bz = huelle.querySelector<HTMLInputElement>("#f-bezahlt_am")!;
bz.addEventListener("change", () => { if (bz.value) st.value = "bezahlt"; else if (st.value === "bezahlt") st.value = "gestellt"; });
st.addEventListener("change", () => { bz.value = st.value === "bezahlt" ? bz.value || heute() : ""; });
// Vorgang oder vor/nach gewechselt: Termin gleich auf Anfang bzw. Ende des Vorgangs setzen
const vSel = huelle.querySelector<HTMLSelectElement>("#f-vorgang_id")!, tFeld = huelle.querySelector<HTMLInputElement>("#f-termin")!;
const terminZiehen = () => setTimeout(() => {
const vg = vorgaenge.find((v: Zeile) => v.id === vSel.value);
if (vg) tFeld.value = huelle.querySelector('[data-um="vorgang_id"] .an')?.getAttribute("data-wert") === "AA" ? vg.anfang : vg.ende;
});
vSel.addEventListener("change", terminZiehen);
huelle.querySelector('[data-um="vorgang_id"]')!.addEventListener("click", terminZiehen);
const e = await offen;
if (!e) return;
if (e.aktion === "loeschen") { await api(`zahlungen/${z!.id}`, "DELETE"); return neuLaden(); }
const d = { ...e.daten };
if (d.art === "schluss" && d.netto === restBetrag && (!z || z.rest || z.art !== "schluss")) d.netto = null;
if (d.netto === null) {
if (d.art !== "schluss") { hinweis.text = "Ohne Betrag geht nur die Schlussrechnung (Rest aus dem Auftragswert). Die Zahlung wurde nicht gespeichert."; return neuLaden(); }
Object.assign(d, { netto: 0, rest: true });
} else d.rest = false;
if (d.zahlungsziel_tage === null || d.zahlungsziel_tage === undefined) d.zahlungsziel_tage = fristVorschlag;
// anderer Vorgang oder vor/nach umgestellt: fällig genau am Anfang bzw. Ende des Vorgangs
const vg = d.vorgang_id ? vorgaenge.find((v: Zeile) => v.id === d.vorgang_id) : undefined;
if (!d.vorgang_id) delete d.bezug_art;
else if (vg && (d.vorgang_id !== z?.vorgang_id || d.bezug_art !== (z?.bezug_art ?? "EE"))) Object.assign(d, { bezug_tage: 0, termin: d.bezug_art === "AA" ? vg.anfang : vg.ende });
if (z) await api(`zahlungen/${z.id}`, "PATCH", d);
else await api("zahlungen", "POST", { projekt_id: id, reihenfolge: eigeneZahlungen.length, ...d });
neuLaden();
};
knopf("+ Zahlung", () => void zahlungBearbeiten(null));
const bezugText = (z: Zeile) => {
const n = Number(z.bezug_tage ?? 0), name = esc(vorgangName(z.vorgang_id));
return n === 0 ? `${z.bezug_art === "AA" ? "vor" : "nach"} ${name}` : `${Math.abs(n)} AT ${n < 0 ? "vor" : "nach"} ${z.bezug_art === "AA" ? "Anfang" : "Ende"} ${name}`;
};
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 = `<p>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.</p>
${umsatz ? "" : '<button class="neben" data-a="bearbeiten">Auftragswert eintragen</button>'}`;
} else if (!eigeneZahlungen.length) {
info.innerHTML = `<p>Noch kein Zahlungsplan. Der Standard ist 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung nach Abnahme.</p>
<button class="haupt" data-a="zahlungsplan">Standard-Zahlungsplan anlegen</button> <span class="fehler" role="status"></span>`;
} else {
info.innerHTML = `<p>${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."}</p>`;
}
// E24: Abschläge nach Abarbeitungsstand; der Stand kommt aus „% erledigt“ im Terminplan (nach Stunden gewichtet)
const stand = gesamtFortschritt(vorgaenge.map((v: Zeile) => ({ anfang: v.anfang, ende: v.ende, dauer: Number(v.dauer), stunden: v.stunden == null ? null : Number(v.stunden), fortschritt: Number(v.fortschritt) || 0 })));
if (umsatz && stand) {
const verdient = Math.round((umsatz * stand) / 100);
const abgerechnet = eigeneZahlungen.filter((z) => z.status !== "geplant").reduce((s, z) => s + z.netto, 0);
info.insertAdjacentHTML("beforeend", `<p class="abarbeitung"><b>Abarbeitungsstand ${stand} %</b> laut Terminplan = ${euro(verdient)} von ${euro(umsatz)} netto.
Gestellt oder bezahlt: ${euro(abgerechnet)}.${verdient > abgerechnet ? ` Nach Abarbeitungsstand abrechenbar: <b>${euro(verdient - abgerechnet)}</b>.` : ""}</p>`);
}
teil.append(info);
if (eigeneZahlungen.length) {
teil.append(liste({
schluessel: "projekt-zahlungen", klein: true, einheit: ["Rate", "Raten"],
spalten: [
{ id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
{ id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">${bezugText(z)}</span>` : ""}` },
{ id: "zahlung", titel: "Geld erwartet", art: "datum", sortWert: (z) => zahlungErwartet(z),
wert: (z) => `${dat(zahlungErwartet(z))}<span class="unter">${z.bezahlt_am ? "bezahlt" : `${frist(z)} Tage Frist`}</span>` },
{ id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
{ id: "zaehlt", titel: "Zählt", text: (z) => (z.zaehlt === false ? "zählt nicht" : "zählt"), wert: (z) => `${zaehltHaken([`zahlung:${z.id}`], z.zaehlt !== false, z.bezeichnung)}<span class="nur-schmal"> zählt in der Liquidität</span>`, klasse: "zaehlt" },
{ id: "netto", titel: "Netto", art: "zahl", wert: (z) => `${euro(z.netto)}${z.rest ? '<span class="unter">Rest</span>' : ""}`, sortWert: (z) => z.netto, klasse: "zahl" },
],
zeilenKlasse: (z) => (z.zaehlt === false ? "zaehlt-nicht" : ""),
zeilen: eigeneZahlungen, klick: (z) => void zahlungBearbeiten(z),
loeschen: async (z) => { await api(`zahlungen/${z.id}`, "DELETE"); neuLaden(); },
// Reihenfolge wie im Terminplan unter „Einnahmen“; von Hand verschoben ist der Plan fest
verschieben: async (ids) => {
for (const [i, zid] of ids.entries()) if (eigeneZahlungen.find((x) => x.id === zid)?.reihenfolge !== i) await api(`zahlungen/${zid}`, "PATCH", { reihenfolge: i });
neuLaden();
},
}));
const ohneZ = eigeneZahlungen.filter((z) => z.zaehlt === false);
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}${ohneZ.length
? ` · ${ohneZ.length} ${ohneZ.length === 1 ? "Rate zählt" : "Raten zählen"} nicht in der Liquidität (${euro(ohneZ.reduce((s, z) => s + z.netto, 0))})` : ""}</p>`);
}
zeigeEingangsrechnungen();
}
// Eingangsrechnungen (Kosten) im Zahlungsplan (Henning, 21.10.2026): fällig zu Beginn eines Abschnitts, wandern mit
// dessen erstem Vorgang; Zahlungsziel je Rechnung, Vorschlag aus den Einstellungen (7 Tage)
function zeigeEingangsrechnungen(): void {
const zielTage = (art: string) => Number((einst?.zahlungsziele ?? {})[art === "fremd" ? "fremdTage" : art === "sonstiges" ? "sonstigeTage" : "materialTage"] ?? 7);
const ziel = (k: Zeile) => (k.zahlungsziel_tage == null ? zielTage(k.art) : Number(k.zahlungsziel_tage));
const zahltag = (k: Zeile) => plusTage(k.termin, ziel(k));
const ersterVorgang = (aid: string) => vorgaenge.filter((v: Zeile) => v.abschnitt_id === aid).sort((a: Zeile, b: Zeile) => String(a.anfang).localeCompare(String(b.anfang)))[0];
const letzterVorgang = (aid: string) => vorgaenge.filter((v: Zeile) => v.abschnitt_id === aid).sort((a: Zeile, b: Zeile) => String(b.ende).localeCompare(String(a.ende)))[0];
const abschnittVon = (k: Zeile) => (k.vorgang_id ? abschnitte.find((a: Zeile) => a.id === vorgaenge.find((v: Zeile) => v.id === k.vorgang_id)?.abschnitt_id) : undefined);
const mitVorgang = abschnitte.filter((a: Zeile) => ersterVorgang(a.id));
const lieferanten = kontaktListe.filter((k) => (k.rollen ?? []).some((r: string) => r === "lieferant" || r === "subunternehmer"));
const felder: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN },
{ name: "kontakt_id", titel: "Lieferant / Subunternehmer", art: "auswahl", optionen: [["", "–"], ...lieferanten.map((k): [string, string] => [k.id, k.name])] },
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true },
// vor | nach wie bei den Raten (Henning, 26.10.2026): zu Beginn oder nach dem Ende des Abschnitts
{ name: "abschnitt", titel: "Fällig zu Beginn von", art: "auswahl", optionen: [["", "– Termin von Hand –"], ...mitVorgang.map((a: Zeile): [string, string] => [a.id, a.name])],
umschalter: { name: "bezug_art", optionen: [["AA", "vor"], ["EE", "nach"]], titel: { AA: "Fällig zu Beginn von", EE: "Fällig nach Ende von" },
hilfe: { AA: "Der Termin wandert mit dem Anfang des Abschnitts im Terminplan.", EE: "Der Termin wandert mit dem Ende des Abschnitts im Terminplan." } } },
{ name: "termin", titel: "Termin (Rechnung)", art: "datum", hilfe: "Nur nötig, wenn kein Abschnitt gewählt ist." },
{ name: "zahlungsziel_tage", titel: "Zahlungsziel (Kalendertage)", art: "zahl", hilfe: "Für die Liquidität: Das Geld geht am Termin plus Zahlungsziel raus. Vorschlag 7 Tage." },
{ name: "status", titel: "Status", art: "auswahl", optionen: KOSTENSTATUS },
];
const bearbeitenER = async (k: Zeile | null) => {
const werte = k ? { ...k, abschnitt: abschnittVon(k)?.id ?? "", zahlungsziel_tage: ziel(k), bezug_art: k.vorgang_id ? k.bezug_art ?? "AA" : "AA" }
: { projekt_id: id, art: "material", status: "geplant", abschnitt: mitVorgang[0]?.id ?? "", termin: heute(), zahlungsziel_tage: zielTage("material"), netto: null, bezug_art: "AA" };
const e = await dialog(k ? "Eingangsrechnung bearbeiten" : "Neue Eingangsrechnung", felder, werte, !!k);
if (!e) return;
if (e.aktion === "loeschen") { await api(`kosten/${k!.id}`, "DELETE"); return neuLaden(); }
const { abschnitt, ...d } = e.daten;
if (d.zahlungsziel_tage === null || d.zahlungsziel_tage === undefined) d.zahlungsziel_tage = zielTage(d.art);
const nachEnde = d.bezug_art === "EE";
const v = abschnitt ? (nachEnde ? letzterVorgang(abschnitt) : ersterVorgang(abschnitt)) : undefined;
// Abschnitt und vor/nach unverändert: Termin folgt weiter dem Vorgang
if (k && abschnitt && abschnitt === abschnittVon(k)?.id && d.bezug_art === (k.bezug_art ?? "AA")) { delete d.termin; delete d.bezug_art; }
else if (v) Object.assign(d, { vorgang_id: v.id, bezug_tage: 0, termin: nachEnde ? v.ende : v.anfang });
else {
delete d.bezug_art;
if (!d.termin) { hinweis.text = "Bitte einen Abschnitt oder einen Termin angeben. Die Eingangsrechnung wurde nicht gespeichert."; return neuLaden(); }
// Termin von Hand: ohne Bindung an einen Abschnitt
d.vorgang_id = null;
}
if (k) await api(`kosten/${k.id}`, "PATCH", d);
else await api("kosten", "POST", { ...d, projekt_id: id });
neuLaden();
};
const kopf = document.createElement("div");
kopf.className = "kosten-kopf er-kopf";
kopf.innerHTML = '<h3>Ausgaben: Eingangsrechnungen</h3><button class="neben" data-a="er-neu">+ Eingangsrechnung</button>';
kopf.querySelector("button")!.onclick = () => void bearbeitenER(null);
teil.append(kopf);
if (!eigeneKosten.length) { teil.append(leer("Noch keine Eingangsrechnungen. Material, Subunternehmer und sonstige Kosten mit Termin zu Beginn eines Abschnitts.")); return; }
teil.append(liste({
schluessel: "projekt-eingangsrechnungen", klein: true, einheit: ["Eingangsrechnung", "Eingangsrechnungen"],
spalten: [
{ id: "bezeichnung", titel: "Bezeichnung", text: (k) => k.bezeichnung, wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}</span>` },
{ id: "termin", titel: "Termin", art: "datum", sortWert: (k) => k.termin,
wert: (k) => `${dat(k.termin)}${abschnittVon(k) ? `<span class="unter">${k.bezug_art === "EE" ? "nach" : "vor"} ${esc(abschnittVon(k)!.name)}</span>` : k.vorgang_id ? '<span class="unter">mit Vorgang</span>' : ""}` },
{ id: "zahlung", titel: "Geld geht raus", art: "datum", sortWert: (k) => zahltag(k), wert: (k) => `${dat(zahltag(k))}<span class="unter">${ziel(k)} Tage Ziel</span>` },
{ id: "status", titel: "Status", text: (k) => k.status, wert: (k) => `<span class="etikett kosten-${esc(k.status)}">${esc(k.status)}</span>`, klasse: "optional" },
{ id: "zaehlt", titel: "Zählt", text: (k) => (k.zaehlt === false ? "zählt nicht" : "zählt"), wert: (k) => `${zaehltHaken([`kosten:${k.id}`], k.zaehlt !== false, k.bezeichnung)}<span class="nur-schmal"> zählt in der Liquidität</span>`, klasse: "zaehlt" },
{ id: "netto", titel: "Netto", art: "zahl", wert: (k) => euro(k.netto), sortWert: (k) => k.netto, klasse: "zahl" },
],
zeilenKlasse: (k) => (k.zaehlt === false ? "zaehlt-nicht" : ""),
zeilen: eigeneKosten, klick: (k) => void bearbeitenER(k),
loeschen: async (k) => { await api(`kosten/${k.id}`, "DELETE"); neuLaden(); },
}));
const summeK = eigeneKosten.reduce((s, k) => s + k.netto, 0);
const ohneK = eigeneKosten.filter((k) => k.zaehlt === false);
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe Ausgaben ${euro(summeK)}${eigeneZahlungen.length ? ` · Einnahmen minus Ausgaben ${euro(eigeneZahlungen.reduce((s, z) => s + z.netto, 0) - summeK)}` : ""}${ohneK.length
? ` · ${ohneK.length} ${ohneK.length === 1 ? "Rechnung zählt" : "Rechnungen zählen"} nicht in der Liquidität (${euro(ohneK.reduce((s, k) => s + k.netto, 0))})` : ""}</p>`);
}
// ---------- rechts: offene Aufgaben statt Chat ----------
const zeigeAufgaben = () => {
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length;
const seite = inhalt.querySelector<HTMLElement>(".projekt-aufgaben")!;
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>`;
seite.append(aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true));
};
// ---------- Handy: Stand und Ablauf ----------
const raster = inhalt.querySelector<HTMLElement>(".projekt-raster")!;
const bezahlt = eigeneZahlungen.filter((z) => z.status === "bezahlt").reduce((s, z) => s + z.netto, 0);
inhalt.querySelector<HTMLElement>(".p-stand")!.innerHTML = `<h3>Stand</h3><div class="stand-zahlen">
<div><small>Auftragswert</small><b>${euro(umsatz)}</b></div><div><small>bezahlt</small><b class="gut">${euro(bezahlt)}</b></div><div><small>offen</small><b>${euro(Math.max(0, umsatz - bezahlt))}</b></div></div>`;
const zeitraumText = (a?: string, e?: string) => (!a ? "ohne Termin" : a === e ? dat(a) : `${dat(a)} – ${dat(e)}`);
inhalt.querySelector<HTMLElement>(".p-ablauf")!.innerHTML = `<h3>Abschnitte <a href="#terminplan">Terminplan</a></h3>${abschnitte.length ? `<ul class="ablauf-liste">${abschnitte.map((ab: Zeile) => {
const vs = vorgaenge.filter((v: Zeile) => v.abschnitt_id === ab.id);
const bs = plan.besetzungen.filter((b: Zeile) => vs.some((v: Zeile) => v.id === b.vorgang_id));
const leute = [...new Set(bs.map((b: Zeile) => b.anzeige as string).filter(Boolean))].join(", ");
const stunden = vs.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 1), 0);
const fertig = stunden ? Math.round(vs.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 1) * (Number(v.fortschritt) || 0), 0) / stunden) : 0;
const marke = vs.length && fertig >= 100 ? '<span class="marke gut">erledigt</span>'
: bs.some((b: Zeile) => !b.freigegeben) ? '<span class="marke offen">vorgemerkt</span>'
: vs.length && !bs.length ? '<span class="marke schlecht">niemand eingeteilt</span>' : `<span class="marke">${fertig} %</span>`;
return `<li><span><b>${esc(ab.name)}</b><span class="unter">${zeitraumText(vs.map((v: Zeile) => v.anfang).sort()[0], vs.map((v: Zeile) => v.ende).sort().at(-1))}${leute ? ` · ${esc(leute)}` : ""}</span></span>${marke}</li>`;
}).join("")}</ul>` : '<p class="hinweis leer">Noch keine Abschnitte. Lege sie im Terminplan an.</p>'}
<p class="hinweis">Bautagebuch und Fotos kommen mit Stufe 4.</p>`;
const zeigeHandy = () => {
raster.classList.remove("hr-ueberblick", "hr-ablauf", "hr-geld", "hr-ablage");
raster.classList.add(`hr-${projektHandy}`);
inhalt.querySelectorAll<HTMLElement>("[data-hr]").forEach((b) => b.classList.toggle("aktiv", b.dataset.hr === projektHandy));
if (projektHandy === "ueberblick") projektOben = "uebersicht";
if (projektHandy === "geld") { projektOben = "nachkalkulation"; if (!["dokumente", "zahlungen"].includes(projektTeil)) projektTeil = "dokumente"; }
if (projektHandy === "ablage") projektTeil = "ablage";
};
if (istHandy()) zeigeHandy();
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 hr = ziel.closest<HTMLElement>("[data-hr]")?.dataset.hr;
if (hr) { projektHandy = hr; zeigeHandy(); zeigeOben(); zeigeTeil(); return; }
const o = ziel.closest<HTMLElement>("[data-oben]")?.dataset.oben;
if (o) { projektOben = o; zeigeOben(); return; }
const t = ziel.closest<HTMLElement>("[data-teil]")?.dataset.teil;
if (t) { projektTeil = t; zeigeTeil(); return; }
const ordner = ziel.closest<HTMLElement>("[data-ablage]");
if (ordner) { ablagePfad = ordner.dataset.ablage!; void zeigeAblage(); return; }
const zid = ziel.closest<HTMLElement>("[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<HTMLElement>("[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<HTMLElement>("[data-a]")?.dataset.a;
if (a === "eck-auf") {
const k = ziel.closest<HTMLElement>(".kachel.eckdaten")!;
const offen = k.classList.toggle("zu") === false;
merke(ECK_OFFEN, offen ? "1" : null);
const b = k.querySelector<HTMLButtonElement>(".eck-pfeil")!;
b.setAttribute("aria-expanded", String(offen)); b.title = offen ? "Eckdaten einklappen" : "Eckdaten aufklappen";
return;
}
const apId = ziel.closest<HTMLElement>("[data-ap]")?.dataset.ap;
const zustFeld: Feld = { name: "zustaendig", titel: "Zuständig für", art: "auswahl", optionen: [["", "–"], ...ZUSTAENDIG] };
if (apId) {
const ap = eigeneAp.find((x) => x.id === apId)!;
const r = await dialog(`Ansprechpartner: ${kontakt[ap.kontakt_id]?.name ?? ""}`, [zustFeld], { zustaendig: (ap.zustaendig ?? [])[0] ?? "" }, true);
if (!r) return;
if (r.aktion === "loeschen") await api(`projekt-ansprechpartner/${apId}`, "DELETE");
else await api(`projekt-ansprechpartner/${apId}`, "PATCH", { zustaendig: r.daten.zustaendig ? [r.daten.zustaendig] : [] });
return neuLaden();
}
// Rechnungsanschrift mit z. Hd. und Anrede zum Übernehmen in das Rechnungsprogramm (0.49)
if (a === "rechnung-an") {
const box = inhalt.querySelector<HTMLElement>(".pj-rechnung-an")!;
if (!box.hidden) { box.hidden = true; return; }
const em = await api<Empfaenger>(`projekte/${id}/empfaenger?zweck=rechnung`);
const text = `${em.zeilen.join("\n")}\n\n${em.anrede}`;
box.innerHTML = `<pre>${esc(text)}</pre><button class="neben" data-a="rechnung-an-kopieren">Kopieren</button>`;
box.hidden = false;
box.dataset.text = text;
return;
}
if (a === "rechnung-an-kopieren") {
const box = inhalt.querySelector<HTMLElement>(".pj-rechnung-an")!;
try { await navigator.clipboard.writeText(box.dataset.text ?? ""); box.querySelector("button")!.textContent = "Kopiert ✓"; }
catch { const r = document.createRange(); r.selectNodeContents(box.querySelector("pre")!); getSelection()?.removeAllRanges(); getSelection()?.addRange(r); }
return;
}
if (a === "ap-neu") {
// die Leute vom Kunden zuerst (Henning, 08.11.2026)
const vomKunden = zug.filter((z) => z.gruppe_id === p.bauherr_id).map((z) => z.person_id as string);
const frei = kontaktListe.filter((k) => !eigeneAp.some((x) => x.kontakt_id === k.id) && k.id !== p.bauherr_id);
const sortiert = [...frei].sort((x, y) => Number(vomKunden.includes(y.id)) - Number(vomKunden.includes(x.id)) || x.name.localeCompare(y.name, "de"));
const r = await dialog("Ansprechpartner hinzufügen", [
{ name: "kontakt_id", titel: "Kontakt", art: "auswahl", pflicht: true, optionen: [["", "– wählen –"], ...sortiert.map((k): [string, string] => {
const z = zug.find((x) => x.person_id === k.id && x.gruppe_id === p.bauherr_id);
return [k.id, z ? `${k.name}${z.funktion ? ` · ${z.funktion}` : ""} (beim Kunden)` : k.firma ? `${k.name} · ${k.firma}` : k.name]; })],
neu: { text: "+ Neue Person …", titel: "Neue Person anlegen", felder: [{ name: "name", titel: "Name", pflicht: true }, { name: "telefon", titel: "Telefon" }, { name: "mobil", titel: "Mobil" }, { name: "email", titel: "E-Mail" }],
anlegen: async (d) => {
const k = await api<Zeile>("kontakte", "POST", d);
if (kunde?.art) await api("kontakt-zugehoerigkeiten", "POST", { gruppe_id: kunde.id, person_id: k.id });
return [k.id, k.name];
} } },
zustFeld,
], { zustaendig: eigeneAp.length ? "" : "haupt" }, false);
if (r?.aktion !== "speichern" || !r.daten.kontakt_id) return;
await api("projekt-ansprechpartner", "POST", { projekt_id: id, kontakt_id: r.daten.kontakt_id, zustaendig: r.daten.zustaendig ? [r.daten.zustaendig] : [], reihenfolge: eigeneAp.length });
return neuLaden();
}
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") {
// am Handy lässt sich kein Projekt löschen (Henning, 22.10.2026)
const [felder, alle] = await Promise.all([projektFelder(), api<Zeile[]>("projekte")]);
const e = await dialog("Projekt bearbeiten", felder.map((f) => (f.name === "nummer" ? { ...f, hilfe: NUMMER_HILFE } : f)), mitKosten(p), !istHandy(), nummerPruefung(alle, p.id));
if (!e) return;
if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; }
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(kostenAufteilen(e.daten, p)));
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
return neuLaden();
}
if (a === "auftragswert") {
const e = await dialog("Auftragswert ändern", [{ name: "umsatz_netto", titel: "Auftragswert netto", art: "euro",
hilfe: p.zahlungsplan === "auto" ? "Der automatische Zahlungsplan rechnet die Raten neu." : "Eine Schlussrechnung ohne eigenen Betrag rechnet sich neu; andere Raten änderst du im Zahlungsplan." }], p, false);
if (e?.aktion !== "speichern") return;
await api(`projekte/${id}`, "PATCH", { umsatz_netto: e.daten.umsatz_netto ?? 0 });
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<HTMLElement>("[data-a]")!;
if (feld.querySelector("textarea")) return;
feld.innerHTML = `<textarea rows="5" aria-label="Beschreibung">${esc(p.notiz ?? "")}</textarea><p><button class="haupt" data-a="beschreibung-sichern">Speichern</button> <button class="neben" data-a="beschreibung-weg">Abbrechen</button></p>`;
feld.querySelector("textarea")!.focus();
return;
}
if (a === "beschreibung-sichern") {
const text = inhalt.querySelector<HTMLTextAreaElement>(".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<Zeile>(`projekte/${id}`, "PATCH", { status: (ev.target as HTMLSelectElement).value });
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
neuLaden();
};
const prioWahl = inhalt.querySelector<HTMLSelectElement>("#p-prio");
if (prioWahl) prioWahl.onchange = async () => { await api(`projekte/${id}`, "PATCH", { prioritaet: prioWahl.value || null }); neuLaden(); };
}
async function terminplan(): Promise<void> {
const h = { api, dialog, esc, seite: (t: string) => seite(t), inhalt, filterMenue, filterText,
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] as [string, string], bestaetigen };
await (istHandy() ? terminplanHandy(h) : terminplanSeite(h));
}
// 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<Zeile[]>("aufgaben-kategorien");
box.innerHTML = `<h2>Kategorien</h2>
<ul>${liste.map((k) => `<li><input id="kat-${k.id}" data-id="${k.id}" value="${esc(k.name)}" aria-label="Kategorie"><button type="button" class="neben" data-weg="${k.id}" title="Löschen">✕</button></li>`).join("")}</ul>
${liste.length ? "" : '<p class="hinweis">Noch keine Kategorien.</p>'}
<form class="neu"><input id="kat-neu" placeholder="Neue Kategorie" aria-label="Neue Kategorie"><button class="neben">Hinzufügen</button></form>
<p class="fehler">${esc(fehler)}</p>
<p class="hinweis">Gelöschte Kategorien verschwinden aus den Aufgaben, die Aufgaben bleiben.</p>
<div class="knoepfe"><button type="button" class="haupt" data-a="fertig">Fertig</button></div>`;
(box.querySelector("#kat-neu") as HTMLInputElement).focus();
};
const versuche = async (fn: () => Promise<unknown>) => {
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<Zeile[]>("aufgaben-kategorien")));
}
});
zeichne();
});
}
interface AufgabenNamen { projekt: Record<string, string>; kontakt: Record<string, string>; kategorie: Record<string, string> }
/** 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<Zeile[]>("aufgaben-kategorien"), api<Zeile[]>("projekte"), api<Zeile[]>("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<boolean> {
return bearbeiten("aufgaben", "Neue Aufgabe", (await aufgabenDaten()).felder, null, vorgaben);
}
// Aufgaben sortieren und filtern wie in Excel (Henning, 20.10.2026); Erledigte sind ein Filter auf der Hakenspalte
const AUFGABEN_VORGABE = { sort: [["faellig", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] } };
const AUFGABEN_VORLAGEN = [
{ name: "Meine Woche", ansicht: { sort: [["faellig", "auf"], ["kategorie", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" } } },
{ name: "Erledigte", ansicht: { sort: [["faellig", "ab"]] as [string, "ab"][], filter: { erledigt: ["offen"] } } },
];
// Aufgaben direkt in der Zeile ändern wie bei den laufenden Kosten (Henning, 23.10.2026); Rückgängig bis zum Neuladen der Seite
const aufgabenVerlauf: { id: string; vorher: Zeile }[] = [];
let aufgabeOeffnen: { id: string; spalte: string } | null = null;
let aufgabenZurueck: (() => Promise<void>) | null = null;
document.addEventListener("keydown", (ev) => {
if (!(ev.ctrlKey || ev.metaKey) || ev.key.toLowerCase() !== "z" || ev.shiftKey) return;
if (!document.querySelector(".aufgaben-tabelle") || (ev.target as HTMLElement).closest("input, textarea, select")) return;
ev.preventDefault();
void aufgabenZurueck?.();
});
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLElement {
const optionenVon = (feld: string) => (felder.find((f) => f.name === feld)?.optionen ?? []) as [string, string][];
const patch = async (z: Zeile, daten: Zeile, weiter: { id: string; spalte: string } | null) => {
const vorher = Object.fromEntries(Object.keys(daten).map((k) => [k, z[k] ?? null]));
await api(`aufgaben/${z.id}`, "PATCH", daten);
aufgabenVerlauf.push({ id: z.id, vorher });
aufgabeOeffnen = weiter;
neuLaden();
};
aufgabenZurueck = async () => {
const v = aufgabenVerlauf.pop();
if (!v) return;
await api(`aufgaben/${v.id}`, "PATCH", v.vorher);
neuLaden();
};
const oeffnen = aufgabeOeffnen;
aufgabeOeffnen = null;
const zuordnung = (z: Zeile) => [ohneProjekt ? "" : namen.projekt[z.projekt_id], namen.kontakt[z.kontakt_id]].filter(Boolean).map(esc).join(" · ");
const t = liste({
schluessel: ohneProjekt ? "projekt-aufgaben" : "aufgaben", klein: ohneProjekt, einheit: ["Aufgabe", "Aufgaben"], klasse: "aufgaben-tabelle",
vorgabe: AUFGABEN_VORGABE, vorlagen: ohneProjekt ? [] : AUFGABEN_VORLAGEN, leer: "Noch keine Aufgaben.",
zeilenKlasse: (z) => (z.erledigt_am ? "erledigt" : ""),
spalten: [
{ id: "erledigt", titel: "Erledigt", handy: "links", kopf: '<span aria-label="Erledigt">✓</span>', text: (z) => (z.erledigt_am ? "erledigt" : "offen"),
wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
{ id: "text", titel: "Aufgabe", text: (z) => z.text, bearbeiten: { art: "text", roh: (z) => z.text },
wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter${ohneProjekt ? "" : " nur-schmal"}">${zuordnung(z)}</span>` : ""}` },
...(ohneProjekt ? [] : [
{ id: "projekt", titel: "Projekt", wert: (z: Zeile) => esc(namen.projekt[z.projekt_id] ?? ""), klasse: "optional",
bearbeiten: { art: "auswahl" as const, optionen: optionenVon("projekt_id"), roh: (z: Zeile) => z.projekt_id ?? "" } },
{ id: "kontakt", titel: "Kunde / Kontakt", wert: (z: Zeile) => esc(namen.kontakt[z.kontakt_id] ?? ""), klasse: "optional",
bearbeiten: { art: "auswahl" as const, optionen: optionenVon("kontakt_id"), roh: (z: Zeile) => z.kontakt_id ?? "" } },
]),
{ id: "kategorie", titel: "Kategorie", text: (z) => namen.kategorie[z.kategorie_id] ?? "",
wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : ""),
bearbeiten: { art: "auswahl", optionen: optionenVon("kategorie_id"), roh: (z) => z.kategorie_id ?? "" } },
{ id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig_am, bearbeiten: { art: "datum", roh: (z) => z.faellig_am ?? "" },
wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
],
zeilen, klick: async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden(),
aendern: async (z, spalte, wert, weiter) => {
const w = wert.trim();
if (spalte === "text") { if (!w) throw new Error("Bitte eine Aufgabe eintragen."); return patch(z, { text: w }, weiter); }
const feld = { projekt: "projekt_id", kontakt: "kontakt_id", kategorie: "kategorie_id", faellig: "faellig_am" }[spalte];
if (feld) return patch(z, { [feld]: w || null }, weiter);
},
oeffnen,
leiste: ohneProjekt ? undefined : () => `<button type="button" class="neben" data-auf="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${aufgabenVerlauf.length ? "" : " disabled"}>↶ Rückgängig</button>`,
fuss: ohneProjekt ? undefined : () => '<p class="hinweis lk-hilfe">Zelle anklicken = direkt ändern · Enter speichert, Esc bricht ab, Tab springt weiter · Doppelklick = alle Felder · Strg+Z = Rückgängig</p>',
});
t.addEventListener("click", (ev) => { if ((ev.target as HTMLElement).closest('[data-auf="zurueck"]')) void aufgabenZurueck?.(); });
t.addEventListener("click", async (ev) => {
const box = ev.target as HTMLInputElement;
if (box.type !== "checkbox" || !box.dataset.id) return;
ev.stopPropagation();
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
neuLaden();
}, true);
return t;
}
async function aufgaben(): Promise<void> {
const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() });
const [d, alle] = await Promise.all([aufgabenDaten(), api<Zeile[]>("aufgaben")]);
leiste.innerHTML = '<button class="neben" data-a="kategorien">Kategorien bearbeiten</button>';
leiste.querySelector<HTMLElement>('[data-a="kategorien"]')!.onclick = async () => { await kategorienBearbeiten(); void aufgaben(); };
inhalt.appendChild(aufgabenTabelle(alle, d.namen, d.felder, 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<void> {
const u = await api<Zeile>(`uebersicht?heute=${heute()}`);
const mitKontostand = !!u.mitKontostand;
seite("Übersicht");
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("beforeend", ` <small class="datum">${WOCHENTAG_LANG[wtag(u.heute)]}, ${dat(u.heute)}</small>`);
// zweizeilig wie am Handy (Henning, 23.10.2026): oben die Aufgabe, darunter Projekt und Kunde, rechts das Datum
const aufgabeLi = (a: Zeile) => {
const unter = [a.projekt_nummer ? `${a.projekt_nummer} ${a.projekt_name ?? ""}`.trim() : "", a.kontakt_name ?? ""].filter(Boolean).map(esc).join(" · ");
const ueber = a.faellig_am && a.faellig_am < u.heute;
return `<li class="aufgabe-2"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt: ${esc(a.text)}">
<span class="a-text"><b>${esc(a.text)}</b>${unter ? `<small>${unter}</small>` : ""}${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</span>` : ""}</span>
<span class="a-datum${ueber ? " ueber" : ""}">${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}</span></li>`;
};
const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `<div class="gruppe${warn && liste.length ? " warn" : ""}">
<h3>${titel} <b>${liste.length}</b></h3>${liste.length ? `<ul class="aufgaben">${liste.map(aufgabeLi).join("")}</ul>` : `<p class="hinweis">${leer}</p>`}</div>`;
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§", angebot: "✉" };
// am Handy oben die Aufgaben-Zahlen; Warnungen und Liquidität gibt es am Handy nicht (Henning, 22.10.2026)
const heuteFaellig = u.aufgaben.dieseWoche.filter((a: Zeile) => a.faellig_am === u.heute).length;
const liegen = u.aufgaben.ueberfaellig.length;
inhalt.insertAdjacentHTML("beforeend", `<div class="handy-band nur-handy"><a href="#aufgaben"><b>${heuteFaellig}</b><small>Aufgaben heute</small></a>
<a href="#aufgaben"><b class="${liegen ? "warn" : ""}">${liegen}</b><small>liegen geblieben</small></a></div>`);
const raster = document.createElement("div");
raster.className = "start";
raster.innerHTML = `
<section class="karte start-aufgaben"><div class="karte-kopf"><h2>Aufgaben</h2><button class="neben" data-a="neue-aufgabe">+ Aufgabe</button></div>
${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.")}</section>
<section class="karte start-warnungen nur-pc" id="start-warnungen"><div class="karte-kopf"><h2>Warnungen</h2></div>
${u.warnungen.length ? `<ul class="warnungen">${u.warnungen.map((w: Zeile) => `<li class="${w.art}"><a href="#${w.ziel}"><span class="symbol">${SYMBOL[w.art] ?? "!"}</span>${esc(w.text)}</a></li>`).join("")}</ul>`
: '<p class="hinweis">Alles im grünen Bereich.</p>'}</section>
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz)}<div class="einsatz-liste"></div></section>
<section class="karte breit nur-pc start-liqui"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
${mitKontostand && u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : flussKachelnHtml(u.fluss, "4 Wochen", false)}
<div class="fluss-platz"></div>
${u.jahresplan ? jahresplanZeile(u.jahresplan) : ""}</section>`;
inhalt.appendChild(raster);
werMachtWas(raster.querySelector<HTMLElement>(".einsatz-liste")!, u.einsatzHandy, u.heute);
// vorerst ohne Kontostand (Henning, 23.10.2026): Einnahmen, Projektkosten und laufende Kosten je Woche
const platz = raster.querySelector<HTMLElement>(".fluss-platz")!;
platz.innerHTML = flussSvg(u.fluss, platz.clientWidth || 900, false);
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<HTMLElement>('[data-a="neue-aufgabe"]')!.onclick = async () => {
if (await neueAufgabe()) uebersicht();
};
}
/** Stufe 5: wie viel Umsatz im Planjahr noch verkauft werden muss */
function jahresplanZeile(j: Zeile): string {
const ganz = (c: number) => euro(Math.round(c / 100) * 100).replace(",00 €", " €");
const anteil = j.umsatz ? Math.min(100, Math.round((j.beauftragt / j.umsatz) * 100)) : 0;
return `<div class="start-jahresplan"><a href="#jahresplanung"><b>Jahresplan ${j.jahr}:</b> noch <b>${ganz(j.offen)}</b> Umsatz zu verkaufen</a>
<span class="hinweis">Ziel ${ganz(j.umsatz)}, beauftragt ${ganz(j.beauftragt)} (${anteil} %)</span>
<span class="jp-balken" role="img" aria-label="${anteil} % beauftragt"><i style="width:${anteil}%"></i></span></div>`;
}
function einsatzHtml(e: Zeile): string {
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<p class="hinweis">In den nächsten zwei Wochen ist nichts eingeplant.</p>';
const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
const kopf = e.tage.map((d: string, i: number) => `<th class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}</th>`).join("");
const neueWoche = (i: number) => i > 0 && wtag(e.tage[i]) < wtag(e.tage[i - 1]);
// Balken in der Projektfarbe, zweizeilig: oben klein Projektnummer und Titel, unten der Vorgang (Henning, 23.10.2026)
const balken = (x: Zeile) => `<span class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" style="--pf:${esc(x.farbe ?? "#1d5fa8")}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}">
<small>${esc(x.projekt)}</small><b>${esc(x.name)}</b></span>`;
// derselbe Vorgang an Folgetagen derselben Woche wird ein durchgehender Balken
const allein = (t: Zeile[] | undefined) => (t && t.length === 1 ? t[0]! : null);
const zeileHtml = (z: Zeile) => {
const zellen: string[] = [];
for (let i = 0; i < z.tage.length; i++) {
const x = allein(z.tage[i]);
let n = 1;
while (x && i + n < z.tage.length && !neueWoche(i + n) && allein(z.tage[i + n])?.vorgang === x.vorgang && allein(z.tage[i + n])?.vorgemerkt === x.vorgemerkt) n++;
zellen.push(`<td class="${neueWoche(i) ? "neue-woche" : ""}"${n > 1 ? ` colspan="${n}"` : ""}>${(z.tage[i] as Zeile[]).map(balken).join("")}</td>`);
i += n - 1;
}
return `<tr class="${z.wer ? "" : "ohne"}"><th>${esc(z.anzeige)}</th>${zellen.join("")}</tr>`;
};
const tabelle = `<div class="einsatz-tabelle"><table><thead><tr><th>Wer</th>${kopf}</tr></thead><tbody>${zeilen.map(zeileHtml).join("")}</tbody></table></div>`;
return tabelle;
}
// „Wer macht was“ am Handy (Henning „super, so soll es sein“, 27.10.2026): oben wählbar, wer (alle, ein Mitarbeiter,
// eine Kolonne, ein Subunternehmer), darunter je Tag eine Zeile, gleiche Folgetage zusammengefasst.
// Die Wahl und der Zeitraum bleiben gespeichert. Antippen öffnet den Vorgang im Terminplan.
const WMW_WER = "betrieb-wmw-wer", WMW_WOCHEN = "betrieb-wmw-wochen";
const WMW_GRUPPEN: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonne", "Kolonnen"], ["subunternehmer", "Subunternehmer"]];
function werMachtWas(ziel: HTMLElement, e: Zeile, heuteD: string, offen = false): void {
const auswahl: Zeile[] = e.auswahl ?? [];
let wahl = lies(WMW_WER) ?? "alle";
if (wahl !== "alle" && !auswahl.some((a) => a.wer === wahl)) wahl = "alle";
const wochen = lies(WMW_WOCHEN) === "4" ? 4 : 2;
const gewaehlt = auswahl.find((a) => a.wer === wahl);
const zeilen: Zeile[] = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
// eine Person sieht auch die Einsätze der Kolonnen, zu denen sie gehört
const kolonnenVon = (w: string) => auswahl.filter((a) => a.art === "kolonne" && (a.mitglieder ?? []).some((m: Zeile) => m.wer === w)).map((a) => a.wer);
const quellen = !gewaehlt ? zeilen : zeilen.filter((z) => z.wer === wahl || kolonnenVon(wahl).includes(z.wer));
const bis = plusTage(heuteD, wochen * 7 - 1);
const tage: string[] = e.tage.filter((d: string) => d <= bis);
const eintraege = tage.map((_, i) => quellen.flatMap((z) => (z.tage[i] as Zeile[]).map((x) => ({ ...x, werName: z.anzeige, werArt: z.art, ohne: !z.wer,
ueber: gewaehlt && z.wer !== wahl ? z.anzeige : "" }))));
const schluessel = (l: Zeile[]) => l.map((x) => `${x.vorgang}|${x.vorgemerkt}|${x.werName}`).join(";");
const morgen = tage.find((d) => d > heuteD);
// gleiche Tage hintereinander in derselben Woche werden eine Zeile; heute und morgen bleiben einzeln
const bloecke: { von: string; bis: string; n: number; l: Zeile[] }[] = [];
tage.forEach((d, i) => {
const vorher = bloecke.at(-1);
const einzeln = (x: string) => x === heuteD || x === morgen;
if (vorher && !einzeln(d) && !einzeln(vorher.bis) && kalenderwoche(d) === kalenderwoche(vorher.bis) && schluessel(vorher.l) === schluessel(eintraege[i]!)) {
vorher.bis = d; vorher.n++;
} else bloecke.push({ von: d, bis: d, n: 1, l: eintraege[i]! });
});
const tagText = (d: string) => `${WOCHENTAG[wtag(d)]} ${d.slice(8)}.`;
const kwHeute = kalenderwoche(heuteD);
let kw = -1;
const zeilenHtml = bloecke.map((b) => {
const k = kalenderwoche(b.von);
const kopf = k !== kw ? `<h3 class="wmw-kw">KW ${k}${k === kwHeute ? " · diese Woche" : ""}</h3>` : "";
kw = k;
const marke = b.von === heuteD ? "heute" : b.von === morgen ? "morgen" : "";
const datum = `<div class="wmw-datum${wtag(b.von) === 5 ? " freitag" : ""}">${marke ? `<small>${marke}</small>` : ""}<b>${tagText(b.von)}</b>${b.n > 1 ? `<small>– ${tagText(b.bis)}</small>` : ""}</div>`;
const inhaltHtml = b.l.length ? b.l.map((x) => `<button class="wmw-eintrag${x.vorgemerkt ? " vorgemerkt" : ""}" style="--pf:${esc(x.farbe ?? "#1d5fa8")}" data-wmw-v="${esc(x.vorgang)}" data-wmw-d="${b.von}">
${!gewaehlt ? `<span class="wmw-wer${x.ohne ? " warn" : ""}">${esc(x.werName)}</span>` : ""}
<small>${esc(x.projekt)}${b.n > 1 ? ` · ${b.n} Tage` : ""}${x.vorgemerkt ? " · vorgemerkt" : ""}</small><b>${esc(x.name)}</b>
${x.kunde || x.ueber ? `<small>${[x.ueber ? `mit ${x.ueber}` : "", x.kunde ?? ""].filter(Boolean).map(esc).join(" · ")}</small>` : ""}</button>`).join("")
: '<p class="wmw-frei">noch nicht eingeplant</p>';
return `${kopf}<div class="wmw-tag${b.von === heuteD ? " heute" : ""}">${datum}<div class="wmw-inhalt">${inhaltHtml}</div></div>`;
}).join("");
const kreis = (a: Zeile | undefined) => a ? `<span class="wmw-kreis">${esc(a.anzeige.split(/\s+/).map((w: string) => w[0]).join("").slice(0, 2).toUpperCase())}</span>` : '<span class="wmw-kreis alle">👥</span>';
const option = (a: Zeile) => `<button class="wmw-option${a.wer === wahl ? " an" : ""}" data-wmw-wer="${esc(a.wer)}">${esc(a.anzeige)}${a.wer === wahl ? "<i>✓</i>" : ""}</button>`;
const menueHtml = `<div class="wmw-menue"><button class="wmw-option${wahl === "alle" ? " an" : ""}" data-wmw-wer="alle"><span>👥 Alle</span><small>alle untereinander</small></button>
${WMW_GRUPPEN.map(([art, titel]) => { const l = auswahl.filter((a) => a.art === art); return l.length ? `<h4>${titel}</h4>${l.map(option).join("")}` : ""; }).join("")}</div>`;
const mitglieder = gewaehlt?.art === "kolonne" ? `<p class="hinweis wmw-mitglieder">${(gewaehlt.mitglieder ?? []).length ? (gewaehlt.mitglieder as Zeile[]).map((m) => esc(m.anzeige)).join(", ") : "noch ohne Mitglieder"}</p>` : "";
ziel.innerHTML = `<button class="wmw-wahl${offen ? " offen" : ""}" data-wmw="menue" aria-expanded="${offen}">${kreis(gewaehlt)}<b>${esc(gewaehlt?.anzeige ?? "Alle")}</b><i>${offen ? "▲" : "▼"}</i></button>
${offen ? menueHtml : ""}${mitglieder}
<div class="fb-chips wmw-chips">${[2, 4].map((n) => `<button class="chip-wahl${n === wochen ? " an" : ""}" data-wmw-wochen="${n}">${n} Wochen</button>`).join("")}</div>
${zeilenHtml || '<p class="hinweis">Nichts eingeplant.</p>'}`;
ziel.onclick = (ev) => {
const t = (ev.target as HTMLElement).closest<HTMLElement>("[data-wmw],[data-wmw-wer],[data-wmw-wochen],[data-wmw-v]");
if (!t) return;
if (t.dataset.wmw === "menue") return werMachtWas(ziel, e, heuteD, !offen);
if (t.dataset.wmwWer) { merke(WMW_WER, t.dataset.wmwWer); return werMachtWas(ziel, e, heuteD); }
if (t.dataset.wmwWochen) { merke(WMW_WOCHEN, t.dataset.wmwWochen); return werMachtWas(ziel, e, heuteD, offen); }
if (t.dataset.wmwV) { vorgangImTerminplan(t.dataset.wmwV, t.dataset.wmwD!); location.hash = "#terminplan"; }
};
}
// T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab)
// P10: Zugang zur Nextcloud für die Projektordner (Henning, 23.10.2026). Das App-Passwort kommt nie zurück,
// die Seite zeigt nur, ob eines gespeichert ist.
async function nextcloudZugang(meldung = ""): Promise<void> {
const ziel = document.getElementById("nextcloud");
if (!ziel) return;
const z = await api<Zeile>("nextcloud");
const zeile = (titel: string, wert: string) => `<tr><th>${titel}</th><td>${wert}</td></tr>`;
ziel.innerHTML = `<p class="hinweis">Damit legt das Programm zu jedem Projekt einen Ordner an und verschiebt ihn bei jeder Statusänderung in „01 Angebot“, „02 laufende Projekte“, „03 Gewährl.-Projekte“ oder „04 Archiv“. Die Ablage auf der Projektseite zeigt seinen Inhalt.</p>
${z.fest ? `<p class="hinweis">${z.quelle === "server" ? "Zurzeit gilt der Zugang aus der Server-Datei .env" : "Auf dem Server steht außerdem ein Zugang in der .env"} (${esc(z.festAdresse ?? "")}). ${z.quelle === "server" ? "Sobald hier Adresse, Benutzer und App-Passwort eingetragen sind, gelten diese." : "Er gilt nicht, solange der Zugang hier eingetragen ist."}</p>` : ""}
<table class="nc-zugang"><tbody>
${zeile("Adresse", z.adresse ? esc(z.adresse) : '<span class="leise">noch nicht eingetragen</span>')}
${zeile("Benutzer", z.benutzer ? esc(z.benutzer) : '<span class="leise">–</span>')}
${zeile("Ordner in der Nextcloud", esc(z.ordner || "(oberste Ebene)"))}
${zeile("App-Passwort", z.passwortGesetzt ? `gespeichert${z.passwortGeaendert ? ` am ${dat(String(z.passwortGeaendert).slice(0, 10))}` : ""}` : z.einrichtbar ? '<span class="leise">fehlt</span>' : '<span class="leise">wird auf dem Server eingetragen</span>')}
${z.webdav ? zeile("WebDAV", `<small>${esc(z.webdav)}</small>`) : ""}
</tbody></table>
${meldung}
<p class="knopfzeile"><button class="neben" data-nc="bearbeiten">Zugang eintragen</button>
${z.einrichtbar || z.fest ? `<button class="neben" data-nc="pruefen">Verbindung prüfen</button>
<button class="neben" data-nc="abgleichen">Alle Projektordner abgleichen</button>` : ""}</p>
${z.einrichtbar ? "" : '<p class="hinweis">Testversion: Adresse, Benutzer und Ordner kannst du schon eintragen, sie ziehen mit der Sicherung auf den Server um. Das App-Passwort und die Verbindung gehen erst dort.</p>'}`;
ziel.onclick = async (ev) => {
const a = (ev.target as HTMLElement).closest<HTMLElement>("[data-nc]")?.dataset.nc;
if (a === "bearbeiten") {
const felder: Feld[] = [
{ name: "adresse", titel: "Adresse der Nextcloud", hilfe: "Aus der Nextcloud: Dateien → unten links Dateien-Einstellungen → WebDAV. Es reicht auch die Serveradresse, z. B. https://cloud.beispiel.de." },
{ name: "benutzer", titel: "Benutzername in der Nextcloud" },
{ name: "ordner", titel: "Ordner mit „01 Angebot“ bis „04 Archiv“", hilfe: "So, wie er in der Nextcloud heißt, z. B. 01 Projekte (nicht C:\\Nc\\…)." },
...(z.einrichtbar ? [{ name: "passwort", titel: "App-Passwort", art: "passwort" as const,
hilfe: `${z.passwortGesetzt ? "Leer lassen, um das gespeicherte zu behalten. " : ""}Anlegen in der Nextcloud unter Persönliche Einstellungen → Sicherheit → Neues App-Passwort, Name z. B. „Betrieb“.` }] : []),
];
const r = await dialog("Nextcloud-Zugang", felder, { adresse: z.adresse, benutzer: z.benutzer, ordner: z.ordner, passwort: "" }, false);
if (r?.aktion !== "speichern") return;
try {
await api("nextcloud", "PUT", { adresse: String(r.daten.adresse ?? ""), benutzer: String(r.daten.benutzer ?? ""), ordner: String(r.daten.ordner ?? ""),
...(r.daten.passwort ? { passwort: String(r.daten.passwort) } : {}) });
return nextcloudZugang('<p class="erfolg">Gespeichert.</p>');
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
if (a === "pruefen") {
try {
const p = await api<Zeile>("nextcloud/pruefen", "POST");
return nextcloudZugang(p.ok
? `<p class="erfolg">Verbindung steht.${p.vorhanden.length ? ` Vorhanden: ${p.vorhanden.map(esc).join(", ")}.` : ""}${p.fehlen.length ? ` Noch nicht da (legt das Programm bei Bedarf an): ${p.fehlen.map(esc).join(", ")}.` : ""}</p>`
: `<p class="fehler">${esc(p.fehler)}</p>`);
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
if (a === "abgleichen") {
if (!(await bestaetigen("Alle Projektordner jetzt abgleichen?", { hinweis: "Vorhandene Ordner mit derselben Projektnummer werden übernommen und in den passenden Statusordner verschoben. Fehlende Ordner legt das Programm mit den Unterordnern an.", ja: "Abgleichen" }))) return;
try {
const r = await api<{ ok: number; fehler: string[] }>("nextcloud/abgleichen", "POST");
return nextcloudZugang(`<p class="${r.fehler.length ? "warnung" : "erfolg"}">${r.ok} Projektordner abgeglichen.${r.fehler.length ? ` Nicht geklappt: ${r.fehler.map(esc).join("; ")}` : ""}</p>`);
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
};
}
// Kontakte mit dem Handy abgleichen (Henning „Nextcloud-Abgleich“, 04.11.2026): Adressbuch in der Nextcloud, das auch
// das iPhone als CardDAV-Account abgleicht. Dazu eine .vcf-Datei einlesen (geht auch in der Testversion).
async function kontakteAbgleich(meldung = "", buecher: Zeile[] | null = null): Promise<void> {
const ziel = document.getElementById("kontakte-abgleich");
if (!ziel) return;
const a = await api<Zeile>("kontakte-abgleich");
const zeile = (titel: string, wert: string) => `<tr><th>${titel}</th><td>${wert}</td></tr>`;
const buch = a.adressbuch ? decodeURIComponent(String(a.adressbuch).split("/").filter(Boolean).at(-1) ?? "") : "";
const auswahl = buecher
? `<select data-ka="buch"><option value="">– wählen –</option>${buecher.map((b) => `<option value="${esc(b.href)}"${b.href === a.adressbuch ? " selected" : ""}>${esc(b.name)}</option>`).join("")}</select>`
: `${buch ? esc(buch) : '<span class="leise">noch nicht gewählt</span>'} ${a.moeglich ? '<button class="neben klein" data-ka="buecher">wählen …</button>' : ""}`;
ziel.innerHTML = `<p class="hinweis">Über ein Adressbuch in deiner Nextcloud, das auch das iPhone abgleicht (Einstellungen → Kontakte → Accounts → Account hinzufügen → Andere → CardDAV-Account). Name, Firma, Telefon, Mobil, E-Mail und Adresse gehen in beide Richtungen; Rolle, Gewerk und Notiz bleiben nur im Programm. Geändert auf beiden Seiten: die neuere Änderung gilt. Im Handy gelöscht bleibt der Kontakt hier und wird markiert.</p>
${a.moeglich ? `<table class="nc-zugang"><tbody>
${zeile("Adressbuch", auswahl)}
${zeile("Abgleich", `<label class="schalter"><input type="checkbox" data-ka="an"${a.an ? " checked" : ""}${a.adressbuch ? "" : " disabled"}> alle 5 Minuten, in beide Richtungen</label>`)}
${zeile("Zuletzt", a.stand ? `${new Date(a.stand.zuletzt).toLocaleString("de-DE", { dateStyle: "short", timeStyle: "short" })} · ${a.stand.fehler ? `<span class="rot">${esc(a.stand.fehler)}</span>` : esc(a.stand.meldung ?? "")}` : '<span class="leise">noch nicht</span>')}
${zeile("Im Handy", `${a.verknuepft} Kontakte${a.geloescht ? `, ${a.geloescht} dort gelöscht` : ""}`)}
</tbody></table>` : '<p class="hinweis">Der Abgleich läuft auf dem Server, sobald dort der Nextcloud-Zugang eingetragen ist (wie für die Projektordner). Eine .vcf-Datei kannst du schon jetzt einlesen.</p>'}
${meldung}
<p class="knopfzeile">${a.moeglich ? `<button class="haupt" data-ka="jetzt"${a.adressbuch ? "" : " disabled"}>Jetzt abgleichen</button>` : ""}
<label class="neben datei-knopf">.vcf-Datei einlesen … <input type="file" data-ka="vcf" accept=".vcf,text/vcard,text/x-vcard" hidden></label></p>`;
const speichern = async (adressbuch: string, an: boolean) => {
try { await api("kontakte-abgleich", "PUT", { adressbuch, an }); return kontakteAbgleich('<p class="erfolg">Gespeichert.</p>'); }
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
};
ziel.onclick = async (ev) => {
const k = (ev.target as HTMLElement).closest<HTMLElement>("[data-ka]")?.dataset.ka;
if (k === "buecher") {
try { return kontakteAbgleich("", await api<Zeile[]>("kontakte-abgleich/adressbuecher")); }
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
if (k === "jetzt") {
try { const r = await api<Zeile>("kontakte-abgleich/jetzt", "POST"); return kontakteAbgleich(`<p class="erfolg">Abgeglichen: ${esc(r.meldung)}.</p>`); }
catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
};
ziel.onchange = async (ev) => {
const el = ev.target as HTMLInputElement;
const k = el.dataset.ka;
if (k === "buch") {
if (a.adressbuch && el.value !== a.adressbuch && !(await bestaetigen("Anderes Adressbuch wählen?", { hinweis: "Die Zuordnung wird neu aufgebaut. Beim nächsten Abgleich führt das Programm gleiche Kontakte (E-Mail, Telefon oder Name) zusammen.", ja: "Wählen" }))) return kontakteAbgleich("", buecher);
return speichern(el.value, a.an && !!el.value);
}
if (k === "an") return speichern(String(a.adressbuch), el.checked);
if (k === "vcf") {
const f = el.files?.[0];
if (!f) return;
try {
const r = await api<Zeile>("kontakte/vcf", "POST", { text: await f.text() });
return kontakteAbgleich(`<p class="erfolg">Eingelesen: ${r.neu} neu, ${r.ergaenzt} ergänzt, ${r.gleich} schon vorhanden. Neue Kontakte haben die Rolle „Sonstige“.</p>`);
} catch (err) { return kontakteAbgleich(`<p class="fehler">${esc((err as Error).message)}</p>`); }
}
};
}
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 = `<p class="hinweis">Die Vorgänge aus dem Terminplan und fällige Aufgaben lassen sich als Internetkalender in Outlook einbinden.</p>
<p><button class="haupt">Kalender-Links erzeugen</button></p>`;
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]) =>
`<div class="kalender-link"><b>${titel}</b><input readonly value="${esc(link(datei!))}"><button class="neben" data-kopie="${esc(link(datei!))}">Kopieren</button></div>`).join("")}
<p class="hinweis">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.</p>
<p><button class="neben" data-a="neu">Neue Links erzeugen</button></p>`;
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();
};
}
// Programmteile ein- und ausschalten (Henning, 23.10.2026): ausgeschaltet heißt nur ausgeblendet, die Daten bleiben
const MODUL_TEXT: [string, string, string][] = [
["angebote", "Angebote", "Angebote, Auftragsbestätigungen und weitere Dokumente, Stammdaten, Angebotskalkulation. Aus: Status und P-Nummer setzt du selbst, Angebote schreibst du weiter in Plancraft."],
["zeiterfassung", "Zeiterfassung und Urlaub", "Stunden buchen (auch am Handy), Zeiten, Urlaubsanträge."],
["stundensaetze", "Stundensätze", "Rechentabelle unter Personal."],
["jahresplanung", "Jahresplanung", "Jahresfinanzplan und BWA."],
];
function moduleSchalter(e: Zeile): void {
const ziel = document.getElementById("module")!;
const m = { ...(e.module ?? {}) } as Record<string, boolean>;
ziel.innerHTML = `<p class="hinweis">Immer da: Übersicht, Aufgaben, Projekte, Terminplan, Personal (Mitarbeiter, Kolonnen, Subunternehmer), Kontakte, laufende Kosten, Liquidität.</p>
<ul class="module-liste">${MODUL_TEXT.map(([id, titel, text]) => `<li><label><input type="checkbox" data-modul="${id}" ${m[id] !== false ? "checked" : ""}> <b>${titel}</b></label><br><small class="hinweis">${text}</small></li>`).join("")}</ul>
<p id="module-ergebnis" role="status"></p>`;
ziel.onchange = async (ev) => {
const box = (ev.target as HTMLElement).closest<HTMLInputElement>("[data-modul]");
if (!box) return;
m[box.dataset.modul!] = box.checked;
try {
const aktuell = await api<Zeile>("einstellungen");
await api("einstellungen", "PUT", { ...aktuell, module: { ...aktuell.module, ...m } });
// Leiste und Reiter neu aufbauen
location.reload();
} catch (err) {
document.getElementById("module-ergebnis")!.innerHTML = `<span class="fehler">${esc((err as Error).message)}</span>`;
}
};
}
/** Testversion im Browser (demo/): speichert anders und kennt keine Kalender-Abos */
const testversion = (globalThis as { betriebTestversion?: { sichern(): Promise<string> } }).betriebTestversion;
async function daten(): Promise<void> {
seite("Daten und Einstellungen");
const e = await api<Zeile>("einstellungen");
inhalt.insertAdjacentHTML("beforeend", `
${testversion
? `<p><button class="neben" id="sichern">Kompletten Stand als Datei sichern</button> <span id="sichern-ergebnis"></span></p>
<p class="hinweis">Testversion: Deine Eingaben werden mit diesem Link gespeichert. Mit der Sicherungsdatei ziehen sie später auf den Server um.</p>`
: `<p><a class="neben" href="/api/export" download>Kompletten Stand als JSON sichern</a></p>
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.</p>`}
<h2>Sicherung einspielen</h2>
<p class="hinweis">Sicherungsdatei aus diesem Programm wählen (betrieb-….json), zum Beispiel aus der Testversion. Geht nur, solange noch nichts erfasst ist.</p>
<p><input type="file" id="stand-datei" accept=".json,application/json"></p>
<div id="stand-ergebnis"></div>
<h2>Übernahme aus dem Projektplaner V70</h2>
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
<div id="v70-ergebnis"></div>
<h2>Programmteile</h2>
<div id="module"></div>
<h2>Nextcloud (Projektordner)</h2>
<div id="nextcloud"></div>
<h2>Kontakte mit dem Handy abgleichen</h2>
<div id="kontakte-abgleich"></div>
<h2>Kalender in Outlook</h2>
<div id="kalender"></div>
<h2>Einstellungen</h2>`);
if (testversion) {
document.getElementById("kalender")!.innerHTML = `<p class="hinweis">Die Kalender-Abos für Outlook funktionieren erst auf dem Server.</p>`;
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);
moduleSchalter(e);
void nextcloudZugang();
void kontakteAbgleich();
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<string, number> }>("import/stand", "POST", JSON.parse(await f.text()));
ziel.innerHTML = `<p>Eingespielt: ${r.anzahl.projekte} Projekte, ${r.anzahl.vorgaenge} Vorgänge, ${r.anzahl.aufgaben} Aufgaben, ${r.anzahl.kontakte} Kontakte.</p>`;
} catch (e) {
ziel.innerHTML = `<p class="fehler">${esc((e as Error).message)}</p>`;
}
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<string, number>; hinweise: string[] }>("import/v70", "POST", JSON.parse(await f.text()));
ziel.innerHTML = `<p>Ü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.</p>`
+ (r.hinweise.length ? `<p>Bitte prüfen:</p><ul>${r.hinweise.map((h) => `<li>${esc(h)}</li>`).join("")}</ul>` : "");
} catch (e) {
ziel.innerHTML = `<p class="fehler">${esc((e as Error).message)}</p>`;
}
datei.value = "";
};
const felder: Feld[] = [
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
{ name: "kundenTage", titel: "Zahlungsfrist Kunden (Kalendertage)", art: "zahl", hilfe: "Vorschlag für jede neue Rate im Zahlungsplan; je Rate änderbar." },
{ 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" },
{ name: "pausenabzug", titel: "Pausenabzug knapp über einer Grenze", art: "auswahl", optionen: [["voll", "Immer ganz abziehen (6:10 → 5:40)"], ["bis_grenze", "Nur bis zur Grenze (6:10 → 6:00)"]] },
];
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, pausenabzug: d.pausenabzug ?? e.pausenabzug,
// 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);
// Stufe 3a: Vorgaben für neue Angebote; ein angelegtes Angebot behält seine Sätze (A36)
const k = e.kalkulation;
const kalkFelder: Feld[] = [
{ name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" },
{ name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" },
{ name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Nur solange unter Personal → Stundensätze keine Version gilt; dann kommen die Sätze von dort und der Lohnzuschlag neuer Angebote ist 0 %." },
{ name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" },
{ name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_subunternehmer", titel: "Zuschlag Subunternehmer (%)", art: "zahl" },
{ name: "z_fahrt", titel: "Zuschlag Fahrt (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" },
{ name: "kilometersatz", titel: "Fahrtkosten je km (EK)", art: "euro", hilfe: "Vorschlag für die Kostenart Fahrt: 2 × Strecke × Einsatztage × Fahrzeuge × Satz je km." },
{ name: "wagnis", titel: "Wagnis (%)", art: "zahl" }, { name: "gewinn", titel: "Gewinn (%)", art: "zahl" }, { name: "ausfall", titel: "Zahlungsausfall (%)", art: "zahl" },
{ name: "verschnitt", titel: "Verschnitt in Mengenblättern (%)", art: "zahl" },
{ name: "oeffnungAb", titel: "Öffnungen abziehen ab (m²)", art: "zahl", hilfe: "E28: kleinere Öffnungen werden übermessen." },
{ name: "bindefristWochen", titel: "Bindefrist (Wochen)", art: "zahl" },
{ name: "erinnerungTage", titel: "Erinnerung vor Ablauf der Bindefrist (Tage)", art: "zahl" },
{ name: "kopftext", titel: "Einleitung", art: "langtext" },
{ name: "schlusstext", titel: "Schlusstext", art: "langtext", hilfe: "{bindefrist} wird durch das Datum ersetzt." },
];
const kalkKnopf = document.createElement("button");
kalkKnopf.className = "neben";
kalkKnopf.textContent = "Angebotskalkulation bearbeiten";
kalkKnopf.onclick = async () => {
const r = await dialog("Angebotskalkulation", kalkFelder, { ...k, ...k.stundensaetze, ...Object.fromEntries(Object.entries(k.zuschlaege).map(([x, v]) => [`z_${x}`, v])) }, false);
if (r?.aktion !== "speichern") return;
const d = r.daten, z = (n: string, alt: number) => (d[n] ?? alt) as number;
await api("einstellungen", "PUT", { ...e, kalkulation: {
stundensaetze: { planer: z("planer", 0), geselle: z("geselle", 0), helfer: z("helfer", 0) },
zuschlaege: { lohn: z("z_lohn", 0), material: z("z_material", 0), geraet: z("z_geraet", 0), fahrt: z("z_fahrt", 0), subunternehmer: z("z_subunternehmer", 0), sonstiges: z("z_sonstiges", 0) },
wagnis: z("wagnis", 0), gewinn: z("gewinn", 0), ausfall: z("ausfall", 0), kilometersatz: Math.round(z("kilometersatz", k.kilometersatz)),
verschnitt: z("verschnitt", k.verschnitt), oeffnungAb: z("oeffnungAb", k.oeffnungAb),
bindefristWochen: Math.round(z("bindefristWochen", k.bindefristWochen)), erinnerungTage: Math.round(z("erinnerungTage", k.erinnerungTage)),
kopftext: d.kopftext ?? "", schlusstext: d.schlusstext ?? "",
} });
daten();
};
const vorlagenLink = document.createElement("a");
vorlagenLink.className = "neben";
vorlagenLink.href = "#stammdaten";
vorlagenLink.textContent = "Leistungen, Material und Mengenvorlagen: Stammdaten";
if (modulAn("angebote")) inhalt.append(" ", kalkKnopf, " ", vorlagenLink);
await vorlageEditor(e);
}
// Aufgaben, die jedes beauftragte Projekt bekommt (Henning, 20.10.2026), z. B. „Material bestellen, 7 Arbeitstage vor Abbund“
async function vorlageEditor(e: Zeile): Promise<void> {
const kategorien = await api<Zeile[]>("aufgaben-kategorien");
const bereich = document.createElement("section");
bereich.className = "vorlage";
inhalt.appendChild(bereich);
let zeilen: Zeile[] = (e.aufgabenVorlage ?? []).map((v: Zeile) => ({ ...v }));
const zeichne = (meldung = "") => {
bereich.innerHTML = `<h2>Aufgaben für jedes Projekt</h2>
<p class="hinweis">Jedes beauftragte Projekt bekommt diese Aufgaben. Sie hängen am ersten Vorgang, dessen Name das Stichwort enthält (ohne Stichwort: am ersten Vorgang des Projekts), wandern mit ihm und stehen in den Aufgaben, der Übersicht und im Terminplan unter „Aufgaben“. Gibt es den Vorgang noch nicht, kommt die Aufgabe, sobald er angelegt ist. Hat er schon angefangen oder wäre die Aufgabe schon überfällig, kommt sie nicht mehr.</p>
<div class="tabelle-rolle"><table class="vorlage-tabelle"><thead><tr><th>Aufgabe</th><th class="zahl">Arbeitstage</th><th></th><th></th><th>Vorgang mit Stichwort</th><th>Kategorie</th><th></th></tr></thead><tbody>
${zeilen.map((v, i) => `<tr data-i="${i}">
<td><input data-f="text" value="${esc(v.text)}" aria-label="Aufgabe" placeholder="z. B. Kran bestellen"></td>
<td><input data-f="tage" class="zahl" inputmode="numeric" value="${Math.abs(Number(v.tage ?? 0))}" aria-label="Arbeitstage"></td>
<td><select data-f="richtung" aria-label="vor oder nach">${optionenHtml([["vor", "vor"], ["nach", "nach"]], Number(v.tage) < 0 ? "vor" : "nach")}</select></td>
<td><select data-f="art" aria-label="Anfang oder Ende">${optionenHtml([["AA", "dem Anfang von"], ["EE", "dem Ende von"]], v.art ?? "AA")}</select></td>
<td><input data-f="bezug" value="${esc(v.bezug ?? "")}" aria-label="Vorgang mit Stichwort" placeholder="erster Vorgang"></td>
<td><select data-f="kategorie_id" aria-label="Kategorie">${optionenHtml([["", "–"], ...kategorien.map((k): [string, string] => [k.id, k.name])], v.kategorie_id ?? "")}</select></td>
<td><button type="button" class="neben" data-weg="${i}" aria-label="Zeile entfernen">✕</button></td></tr>`).join("")}
</tbody></table></div>
<p><button type="button" class="neben" data-a="dazu">+ Zeile</button> <button type="button" class="haupt" data-a="sichern">Speichern</button> <span class="${meldung.startsWith("Gespeichert") ? "hinweis" : "fehler"}" role="status">${esc(meldung)}</span></p>`;
};
const lies = () => {
bereich.querySelectorAll<HTMLElement>("tbody tr").forEach((tr) => {
const v = zeilen[Number(tr.dataset.i)]!;
const feld = (f: string) => tr.querySelector<HTMLInputElement>(`[data-f="${f}"]`)!.value.trim();
const tage = Math.abs(Math.round(Number(feld("tage").replace(",", ".")) || 0));
Object.assign(v, { text: feld("text"), bezug: feld("bezug"), art: feld("art"), tage: feld("richtung") === "vor" ? -tage : tage, kategorie_id: feld("kategorie_id") || null });
});
};
bereich.addEventListener("click", async (ev) => {
const t = ev.target as HTMLElement;
if (t.dataset.weg) { lies(); zeilen.splice(Number(t.dataset.weg), 1); return zeichne(); }
if (t.dataset.a === "dazu") { lies(); zeilen.push({ id: "", text: "", bezug: "", art: "AA", tage: -5, kategorie_id: null }); zeichne(); bereich.querySelector<HTMLInputElement>("tbody tr:last-child input")?.focus(); return; }
if (t.dataset.a === "sichern") {
lies();
zeilen = zeilen.filter((v) => v.text);
// neue Einträge bekommen eine feste Kennung; damit weiß jedes Projekt, was es schon bekommen hat
const vergeben = new Set(zeilen.map((v) => v.id).filter(Boolean));
for (const v of zeilen) if (!v.id) {
const basis = v.text.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30) || "aufgabe";
let id = basis, n = 2;
while (vergeben.has(id)) id = `${basis}-${n++}`;
vergeben.add(id);
v.id = id;
}
try {
const vorher = (await api<Zeile[]>("aufgaben")).length;
Object.assign(e, await api<Zeile>("einstellungen", "PUT", { ...e, aufgabenVorlage: zeilen }));
const neu = (await api<Zeile[]>("aufgaben")).length - vorher;
zeichne(`Gespeichert.${neu > 0 ? ` ${neu} neue ${neu === 1 ? "Aufgabe" : "Aufgaben"} in laufenden Projekten.` : ""}`);
} catch (err) { zeichne((err as Error).message); }
}
});
zeichne();
}
// 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<void>];
function reiterFuer(s: Sitzung): Reiter[] {
const rolle = s.benutzer?.rolle;
// kurze Namen, damit am Handy alle drei nebeneinander passen
const zeit = modulAn("zeiterfassung");
if (rolle === "mitarbeiter") return ([["heute", "Heute", heuteSeite], ["stunden", "Stunden", () => meineStunden()], ["meine-einsaetze", "Einsätze", meineEinsaetze],
["baustelle", "Baustelle", baustelleSeite], ["urlaub", "Urlaub", meinUrlaub]] as Reiter[]).filter(([id]) => zeit || (id !== "stunden" && id !== "urlaub"));
const alle: Reiter[] = [
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", () => laufendeKostenSeite()],
];
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
// abgeschaltete Programmteile (Einstellungen → Daten)
const aus = new Set([...(zeit ? [] : ["stunden"]), ...(modulAn("angebote") ? [] : ["stammdaten"]), ...(modulAn("jahresplanung") ? [] : ["jahresplanung"])]);
return alle.filter(([id]) => !aus.has(id));
}
// Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift
const SYMBOLE: Record<string, string> = {
uebersicht: '<path d="M3 11l9-7 9 7"/><path d="M5 10v10h14V10"/>',
aufgaben: '<path d="M9 11l3 3 8-8"/><path d="M20 12v7a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h11"/>',
projekte: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
terminplan: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
kontakte: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
stammdaten: '<rect x="4" y="3" width="16" height="18" rx="1"/><path d="M8 7h8M8 11h8M8 15h5"/>',
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
jahresplanung: '<path d="M4 20V10M10 20V4M16 20v-7M22 20H2"/>',
benutzer: '<circle cx="9" cy="8" r="3.5"/><path d="M2.5 20c.8-3.6 3.3-5.5 6.5-5.5s5.7 1.9 6.5 5.5"/><circle cx="17" cy="9" r="2.5"/><path d="M16 14.6c2.8.1 4.8 1.9 5.5 5.4"/>',
stunden: '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
urlaub: '<circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/>',
personal: '<circle cx="12" cy="7" r="3.5"/><path d="M5 21v-2a5 5 0 0 1 5-5h4a5 5 0 0 1 5 5v2"/><path d="M9 14l3 4 3-4"/>',
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
heute: '<path d="M3 11l9-7 9 7"/><path d="M5 10v10h14V10"/><path d="M10 20v-5h4v5"/>',
baustelle: '<path d="M4 8h3l2-3h6l2 3h3v11H4z"/><circle cx="12" cy="13" r="3.5"/>',
mehr: '<path d="M4 6h16M4 12h16M4 18h16"/>',
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
};
const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${SYMBOLE[id] ?? ""}</svg>`;
const nav = document.getElementById("reiter")!;
// Handy (Henning, 21.10.2026, Entwurf handy/entwurf): unten eine feste Leiste mit den wichtigsten Bereichen,
// beim Chef dazu „Mehr“ mit allen übrigen; die vier Plätze kann er selbst wählen. Mitarbeiter haben vier feste Bereiche.
const UNTEN_CHEF = ["uebersicht", "aufgaben", "projekte", "terminplan"];
const UNTEN_MITARBEITER = ["heute", "stunden", "meine-einsaetze", "baustelle"];
const LEISTE = "handy-leiste";
/** „Mehr“ in Gruppen wie im Entwurf; was nicht genannt ist, kommt unter „Weitere“ */
const MEHR_GRUPPEN: [string, string[]][] = [["Personal", ["personal", "stunden"]], ["Betrieb", ["laufende-kosten"]], ["Weitere", []]];
/** Bereiche, die es nur am PC gibt (Henning, 22.10.2026) */
const NUR_PC = new Set(["liquiditaet", "jahresplanung"]);
const amHandy = (r: Reiter[]) => r.filter(([id]) => !NUR_PC.has(id));
const MEHR_TITEL: Record<string, string> = { personal: "Mitarbeiter und Einsatz", stunden: "Zeiterfassung", jahresplanung: "Jahresplanung und BWA", stammdaten: "Stammdaten <small>(nur lesen)</small>" };
const unten = document.createElement("nav");
unten.id = "unten";
unten.setAttribute("aria-label", "Bereiche");
document.body.append(unten);
// erzwungene PC-Ansicht am Handy: ein Knopf zurück
const handyZurueck = Object.assign(document.createElement("button"), { id: "handy-zurueck", textContent: "Handy-Ansicht" });
handyZurueck.onclick = () => { merke(PC_ANSICHT, null); pcAnsichtAnwenden(); void zeige(); };
document.body.append(handyZurueck);
function untenIds(s: Sitzung): string[] {
if (s.benutzer?.rolle === "mitarbeiter") return UNTEN_MITARBEITER;
const eigen = (eigenerWert<string[]>(LEISTE) ?? []).filter((id) => amHandy(REITER).some(([r]) => r === id));
return eigen.length === 4 ? eigen : UNTEN_CHEF.filter((id) => amHandy(REITER).some(([r]) => r === id));
}
function untenLeiste(s: Sitzung): void {
const ids = untenIds(s);
const da = ids.map((id) => amHandy(REITER).find(([r]) => r === id)!).filter(Boolean);
const mehr = amHandy(REITER).some(([id]) => !ids.includes(id)) && s.benutzer?.rolle !== "mitarbeiter";
unten.innerHTML = da.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("")
+ (mehr ? `<button data-r="mehr" aria-haspopup="true">${symbol("mehr")}<span>Mehr</span></button>` : "");
unten.onclick = (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("button[data-r]");
if (!b) return;
if (b.dataset.r !== "mehr") { location.hash = b.dataset.r!; return; }
mehrBlatt(s, b, ids);
};
}
function mehrBlatt(s: Sitzung, anker: HTMLElement, ids: string[]): void {
const uebrig = amHandy(REITER).filter(([id]) => !ids.includes(id));
const genannt = MEHR_GRUPPEN.flatMap(([, l]) => l);
const gruppen = MEHR_GRUPPEN.map(([titel, l]) => [titel, uebrig.filter(([id]) => (l.length ? l.includes(id) : !genannt.includes(id)))] as const).filter(([, l]) => l.length);
const testversion = s.art === "testversion";
const m = menue(anker, `<div class="fm-kopf"><b>Mehr</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
<div class="mehr-liste">${gruppen.map(([titel, l]) => `<h4>${titel}</h4>${l.map(([id, t]) => `<button type="button" data-r="${id}">${symbol(id)}<span>${MEHR_TITEL[id] ?? esc(t)}</span><i aria-hidden="true">›</i></button>`).join("")}`).join("")}
<p class="mehr-anpassen"><b>Leiste anpassen:</b> du kannst festlegen, welche 4 Bereiche unten stehen. <button type="button" class="verweis" data-m="leiste">Leiste anpassen</button></p>
${testversion ? `<button type="button" data-m="als">${AUGE}<span>Ansicht als Mitarbeiter prüfen</span><i aria-hidden="true">›</i></button>` : ""}
<button type="button" data-m="pc">${symbol("daten")}<span>PC-Ansicht erzwingen</span><i aria-hidden="true">›</i></button></div>`, "mehr-menue");
m.onclick = async (e2) => {
const z = (e2.target as HTMLElement).closest<HTMLElement>("[data-r],[data-m]");
if (!z) return;
menueSchliessen();
if (z.dataset.r) { location.hash = z.dataset.r; return; }
if (z.dataset.m === "pc") { merke(PC_ANSICHT, "1"); pcAnsichtAnwenden(); return void zeige(); }
if (z.dataset.m === "als") {
// Testversion: als anderer Benutzer arbeiten (wie „Arbeiten als“ am PC)
const leute = (s.auswahl ?? []).filter((x) => x.id !== s.benutzer?.id);
if (!leute.length) {
hinweis.text = "Lege unter Benutzer einen Mitarbeiter an (Rolle Mitarbeiter, mit seinem Kontakt). Dann kannst du hier als er arbeiten.";
location.hash = "benutzer";
return;
}
const r = await dialog("Ansicht prüfen als", [{ name: "wer", titel: "Arbeiten als", art: "auswahl", optionen: leute.map((x): [string, string] => [x.id, `${x.name} (${x.rolle})`]) }],
{ wer: leute.find((x) => x.rolle === "mitarbeiter")?.id ?? leute[0]!.id }, false);
if (r?.aktion !== "speichern" || !r.daten.wer) return;
merke(TEST_BENUTZER, String(r.daten.wer));
location.hash = "";
location.reload();
return;
}
if (z.dataset.m === "leiste") {
const optionen = amHandy(REITER).map(([id, t]): [string, string] => [id, t]);
const r = await dialog("Leiste unten anpassen", [1, 2, 3, 4].map((n): Feld => ({ name: `p${n}`, titel: `Platz ${n}`, art: "auswahl", optionen })),
Object.fromEntries(ids.map((id, i) => [`p${i + 1}`, id])), false);
if (r?.aktion !== "speichern") return;
const neu = [1, 2, 3, 4].map((n) => String(r.daten[`p${n}`] ?? "")).filter(Boolean);
if (new Set(neu).size !== 4) { hinweis.text = "Bitte vier verschiedene Bereiche wählen. Die Leiste bleibt, wie sie war."; return void zeige(); }
eigenenWertMerken(LEISTE, neu);
untenLeiste(s);
void zeige();
}
};
}
let REITER: Reiter[] = [];
let sitzung: Sitzung | undefined;
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<void> {
const id = location.hash.slice(1) || REITER[0]![0];
// Liquidität und Jahresplanung gibt es nur am PC; ein Link dorthin führt am Handy zur Übersicht
if (istHandy() && NUR_PC.has(id)) {
hinweis.text = "Liquidität und Jahresplanung gibt es nur am PC.";
location.hash = "uebersicht";
return;
}
// Kontaktmaske (0.47): #kontakt-<id>, #kontakt-neu, #kontakt-neu-gruppe
const kontaktWahl = /^kontakt-(neu|neu-gruppe|[0-9a-f-]{36})$/.exec(id)?.[1];
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte; Mitarbeiter: #ablage-<id>
const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id);
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
const mitarbeiter = /^mitarbeiter-([0-9a-f-]{36})$/.exec(id)?.[1];
// Personal mit Reitern, Kolonne und Subunternehmer (0.15)
const personalTeil = /^personal-(kolonnen|subunternehmer|urlaub|zeiten|stundensaetze)$/.exec(id)?.[1];
const kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1];
const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1];
const zuPersonal = mitarbeiter || personalTeil || kolonne || sub;
// Angebote (Stufe 3a) gehören zum Reiter Projekte
const angebot = /^angebot-([0-9a-f-]{36})$/.exec(id)?.[1];
const mengenblatt = /^mengenblatt-([0-9a-f-]{36})$/.exec(id)?.[1];
const zuProjekte = treffer || ((angebot || mengenblatt || id === "angebote") && modulAn("angebote"));
// Stammdaten (0.18): Leistungen, Material, Mengenvorlagen, Import
const vorlage = /^vorlage-([\w-]{1,80})$/.exec(id)?.[1];
const leistung = /^leistung-([\w-]{1,80})$/.exec(id)?.[1];
const sdTeil = /^stammdaten-(material|mengen|import)$/.exec(id)?.[1] ?? (id === "vorlagen" ? "mengen" : undefined);
const zuStamm = vorlage || leistung || sdTeil;
const projekt = treffer?.[1];
if (treffer?.[2]) projektTeil = treffer[2];
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : kontaktWahl ? "kontakte" : id)) ?? REITER[0]!;
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
inhalt.dataset.reiter = reiter[0];
const imUnten = !!unten.querySelector(`[data-r="${reiter[0]}"]`);
unten.querySelectorAll<HTMLElement>("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0] || (!imUnten && b.dataset.r === "mehr")));
try {
await (kontaktWahl && reiter[0] === "kontakte" ? kontaktSeite(kontaktWahl)
: ablage ? ablageSeite(ablage)
: mitarbeiter && reiter[0] === "personal" ? mitarbeiterSeite(mitarbeiter, sitzung?.benutzer?.rolle === "inhaber")
: kolonne && reiter[0] === "personal" ? kolonneSeite(kolonne)
: sub && reiter[0] === "personal" ? subunternehmerSeite(sub)
: personalTeil && reiter[0] === "personal" ? personalSeite(personalTeil)
: projekt && reiter[0] === "projekte" ? projektSeite(projekt)
: angebot && reiter[0] === "projekte" ? angebotSeite(angebot)
: mengenblatt && reiter[0] === "projekte" ? mengenblattSeite(mengenblatt)
: vorlage && reiter[0] === "stammdaten" ? vorlageSeite(vorlage)
: leistung && reiter[0] === "stammdaten" ? leistungSeite(leistung)
: sdTeil && reiter[0] === "stammdaten" ? stammdatenSeite(sdTeil)
: id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]());
} catch (e) {
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
}
}
window.addEventListener("unhandledrejection", (ev) => {
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
});
async function start(): Promise<void> {
let s = await api<Sitzung>("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>("sitzung");
}
if (!s.benutzer) return anmeldeSeite(s);
sitzung = s;
Object.assign(MODULE, s.module ?? {});
abgemeldet.melden = () => { location.hash = ""; location.reload(); };
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
document.body.classList.toggle("rolle-inhaber", s.benutzer.rolle === "inhaber");
REITER = reiterFuer(s);
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
werLeiste(s);
pcAnsichtAnwenden();
await ansichtenLaden();
untenLeiste(s);
window.addEventListener("hashchange", zeige);
await zeige();
}
start().catch((e) => inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`));
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});