Stufe 2, Schritt 1 (U1, U2, E27, P13). Passwörter mit scrypt, Sitzung als HttpOnly-Cookie (90 Tage, gleitend), in der Datenbank nur der SHA-256. Rollen Inhaber, Büro, Mitarbeiter; Mitarbeiter sehen nur eigene Einsätze und die Ablage ihrer Projekte. Testversion ohne Passwörter mit Auswahl, als wer gearbeitet wird. Anmeldung am Proxy entfällt. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
847 lines
62 KiB
TypeScript
847 lines
62 KiB
TypeScript
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
|
||
|
||
import { kalenderwoche, terminplanSeite } from "./gantt.js";
|
||
import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||
huelle, inhalt, optionenHtml, seite, tabelle, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
|
||
import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js";
|
||
|
||
|
||
// ---------- Reiter ----------
|
||
|
||
const ROLLEN: [string, string][] = [
|
||
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
|
||
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
|
||
];
|
||
const KONTAKT_FELDER: Feld[] = [
|
||
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
|
||
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
|
||
{ name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" },
|
||
];
|
||
|
||
async function kontakte(): Promise<void> {
|
||
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
|
||
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
|
||
const zeilen = await api<Zeile[]>("kontakte");
|
||
const rolle = Object.fromEntries(ROLLEN);
|
||
inhalt.appendChild(tabelle([
|
||
{ titel: "Name", wert: (z) => esc(z.name) },
|
||
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
|
||
}
|
||
|
||
const STATUS: [string, string][] = [
|
||
["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"],
|
||
["abgerechnet", "Abgerechnet"], ["gewaehrleistung", "Gewährleistung"], ["abgeschlossen", "Abgeschlossen"],
|
||
];
|
||
const STATUS_TEXT = Object.fromEntries(STATUS);
|
||
const etikett = (status: string) => `<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");
|
||
const sortiert = [...kontaktListe].sort((a, b) => Number(b.rolle === "bauherr") - Number(a.rolle === "bauherr") || a.name.localeCompare(b.name, "de"));
|
||
return [
|
||
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Bezeichnung", pflicht: true },
|
||
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
|
||
{ name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])] },
|
||
{ name: "baustelle_strasse", titel: "Baustelle: Straße" }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" },
|
||
{ name: "vertragsart", titel: "Vertragsart", art: "auswahl", optionen: VERTRAGSARTEN }, { name: "abnahme_am", titel: "Abnahme am", art: "datum" },
|
||
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
|
||
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
|
||
{ name: "notiz", titel: "Beschreibung", art: "langtext" },
|
||
];
|
||
}
|
||
const BETRAEGE = ["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"];
|
||
const ohneNull = (d: Zeile) => ({ ...d, ...Object.fromEntries(BETRAEGE.map((k) => [k, d[k] ?? 0])) });
|
||
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
|
||
const ortZeile = (p: Zeile) => [p.baustelle_strasse, [p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||
|
||
async function projekte(): Promise<void> {
|
||
const neu = async () => {
|
||
const e = await dialog("Neues Projekt", await projektFelder(), { status: "anfrage" }, false);
|
||
if (e?.aktion !== "speichern") return;
|
||
const p = await api<Zeile>("projekte", "POST", ohneNull(e.daten));
|
||
if (p.ordner_fehler) hinweis.text = p.ordner_fehler;
|
||
location.hash = `projekt-${p.id}`;
|
||
};
|
||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||
const [zeilen, kontaktListe] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte")]);
|
||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||
inhalt.appendChild(tabelle([
|
||
{ titel: "Name", 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>` },
|
||
{ titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||
{ titel: "Status", wert: (z) => etikett(z.status) },
|
||
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" },
|
||
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
|
||
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" },
|
||
], zeilen, (z) => (location.hash = `projekt-${z.id}`)));
|
||
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
|
||
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} Projekte</p><p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>`);
|
||
}
|
||
|
||
// ---------- Projektseite (P2), aufgebaut wie bei Plancraft ----------
|
||
|
||
const ZAHLUNGSARTEN: [string, string][] = [["anzahlung", "Anzahlung"], ["abschlag", "Abschlag"], ["nachtrag", "Nachtrag"], ["schluss", "Schlussrechnung"], ["einbehalt", "Einbehalt"]];
|
||
const ZAHLUNGSSTATUS: [string, string][] = [["geplant", "geplant"], ["gestellt", "gestellt"], ["bezahlt", "bezahlt"]];
|
||
const KOSTENARTEN: [string, string][] = [["material", "Material"], ["fremd", "Fremdleistung"], ["sonstiges", "Sonstiges"]];
|
||
const KOSTENSTATUS: [string, string][] = [["geplant", "geplant"], ["bestellt", "bestellt"], ["bezahlt", "bezahlt"]];
|
||
const ZAHLUNG_FELDER: Feld[] = [
|
||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: ZAHLUNGSARTEN },
|
||
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true },
|
||
{ name: "status", titel: "Status", art: "auswahl", optionen: ZAHLUNGSSTATUS },
|
||
{ name: "rechnungsdatum", titel: "Rechnungsdatum", art: "datum" }, { name: "bezahlt_am", titel: "Bezahlt am", art: "datum" },
|
||
];
|
||
|
||
const KACHEL_SYMBOL: Record<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"/>',
|
||
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";
|
||
let projektTeil = "dokumente";
|
||
const projektAufgabenFilter = { kategorie: "", erledigte: false };
|
||
const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN);
|
||
const stundenText = (h: number) => `${Math.floor(h)}:${String(Math.round((h % 1) * 60)).padStart(2, "0")} Std.`;
|
||
const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
|
||
|
||
async function projektSeite(id: string): Promise<void> {
|
||
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben] = await Promise.all([
|
||
api<Zeile>(`projekte/${id}`), api<Zeile[]>("kontakte"), api<Zeile>("terminplan"),
|
||
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"),
|
||
]);
|
||
const neuLaden = () => projektSeite(id);
|
||
const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k]));
|
||
const kunde = kontakt[p.bauherr_id];
|
||
const abschnitte = plan.abschnitte.filter((a: Zeile) => a.projekt_id === id);
|
||
const vorgaenge = plan.vorgaenge.filter((v: Zeile) => abschnitte.some((a: Zeile) => a.id === v.abschnitt_id));
|
||
const eigeneZahlungen = zahlungen.filter((z) => z.projekt_id === id);
|
||
const eigeneKosten = kosten.filter((k) => k.projekt_id === id);
|
||
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
|
||
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
|
||
|
||
inhalt.innerHTML = `${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}
|
||
<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>
|
||
<button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
|
||
<div class="projekt-raster">
|
||
<div class="projekt-haupt">
|
||
<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 = "";
|
||
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
|
||
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
|
||
const teil = unten.querySelector<HTMLElement>("#teil")!;
|
||
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 = 0; // kommt mit der Zeiterfassung (Stufe 2)
|
||
const anteil = soll ? Math.round((ist / soll) * 100) : null;
|
||
const adresse = ortZeile(p);
|
||
ziel.innerHTML = `<div class="uebersicht-kacheln">
|
||
${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>
|
||
<p class="hinweis">Ist-Stunden kommen mit der Zeiterfassung.</p>`)}
|
||
${kachel("kunde", "Kunde", kunde
|
||
? `<p><a href="#kontakte" class="gross">${esc(kunde.name)}</a>${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>`
|
||
: '<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>')}
|
||
<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>')}
|
||
</div>`;
|
||
} else {
|
||
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 5. 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) => ["lieferant", "subunternehmer"].includes(k.rolle));
|
||
const felder: Feld[] = [
|
||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: KOSTENARTEN },
|
||
{ name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true },
|
||
{ name: "kontakt_id", titel: "Lieferant / Subunternehmer", art: "auswahl", optionen: [["", "–"], ...lieferanten.map((k): [string, string] => [k.id, k.name])] },
|
||
{ name: "status", titel: "Status", art: "auswahl", optionen: KOSTENSTATUS },
|
||
];
|
||
ziel.querySelector<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 ? tabelle([
|
||
{ titel: "Bezeichnung", wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}</span>` },
|
||
{ titel: "Termin", wert: (k) => dat(k.termin) },
|
||
{ titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
|
||
{ titel: "Netto", wert: (k) => euro(k.netto), klasse: "zahl" },
|
||
], eigeneKosten, async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden()) : leer("Noch keine Einzelkosten."));
|
||
}
|
||
};
|
||
|
||
// ---------- unten: Dokumente, Berichte, Ablage, Zahlungsplan ----------
|
||
let ablagePfad = "";
|
||
const zeigeTeil = () => {
|
||
unten.querySelectorAll<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);
|
||
teil.innerHTML = `<h3 class="gruppe">Angebote</h3><p class="hinweis leer">Angebote, Kostenvoranschläge und Auftragsbestätigungen schreibst du bis Stufe 5 noch in Plancraft; die PDFs liegen in der Ablage unter „01 Auftrag“.</p>
|
||
<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 (Stufe 5)</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];
|
||
felder.splice(4, 0, { name: "vorgang_id", titel: "Fällig nach Vorgang", art: "auswahl", optionen: [["", "– Termin von Hand –"], ...vorgaenge.map((v: Zeile): [string, string] => [v.id, v.name])] });
|
||
knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", felder, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden());
|
||
const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0);
|
||
const info = document.createElement("div");
|
||
info.className = "vorschlag";
|
||
if (!eigeneZahlungen.length && p.zahlungsplan !== "fest") {
|
||
info.innerHTML = `<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>`;
|
||
}
|
||
teil.append(info);
|
||
if (eigeneZahlungen.length) {
|
||
teil.append(tabelle([
|
||
{ titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
|
||
{ titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
|
||
{ titel: "Status", wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
|
||
{ titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" },
|
||
], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden()));
|
||
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
|
||
}
|
||
}
|
||
|
||
// ---------- rechts: offene Aufgaben statt Chat ----------
|
||
const zeigeAufgaben = () => {
|
||
const f = projektAufgabenFilter;
|
||
const liste = eigeneAufgaben
|
||
.filter((a) => (f.erledigte || !a.erledigt_am) && (!f.kategorie || (f.kategorie === "ohne" ? !a.kategorie_id : a.kategorie_id === f.kategorie)))
|
||
.sort((a, b) => Number(!!a.erledigt_am) - Number(!!b.erledigt_am) || (a.faellig_am ?? "9999").localeCompare(b.faellig_am ?? "9999"));
|
||
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length;
|
||
const seite = inhalt.querySelector<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>
|
||
<div class="aufgaben-filter"><select id="pa-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(aufgabenDat.kategorien).slice(1)], f.kategorie)}</select>
|
||
<label class="schalter"><input type="checkbox" id="pa-erledigte"${f.erledigte ? " checked" : ""}> Erledigte</label></div>
|
||
${liste.length ? `<ul class="aufgaben-liste">${liste.map((a) => {
|
||
const ueber = !a.erledigt_am && a.faellig_am && a.faellig_am < heute();
|
||
return `<li class="${a.erledigt_am ? "erledigt" : ""}"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt"${a.erledigt_am ? " checked" : ""}>
|
||
<button class="aufgabe" data-aufgabe="${a.id}"><span class="text">${esc(a.text)}</span><span class="meta">${a.kategorie_id ? `<span class="kategorie">${esc(aufgabenDat.namen.kategorie[a.kategorie_id] ?? "")}</span>` : ""}${a.faellig_am ? `<span class="${ueber ? "fehler" : ""}">${ueber ? "überfällig seit " : "fällig "}${dat(a.faellig_am)}</span>` : ""}</span></button></li>`;
|
||
}).join("")}</ul>` : `<p class="hinweis leer">${offen ? "Keine Aufgabe in dieser Auswahl." : "Keine offenen Aufgaben zu diesem Projekt."}</p>`}`;
|
||
seite.querySelector<HTMLSelectElement>("#pa-kategorie")!.onchange = (ev) => { f.kategorie = (ev.target as HTMLSelectElement).value; zeigeAufgaben(); };
|
||
seite.querySelector<HTMLInputElement>("#pa-erledigte")!.onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; zeigeAufgaben(); };
|
||
};
|
||
|
||
zeigeOben();
|
||
zeigeTeil();
|
||
zeigeAufgaben();
|
||
|
||
inhalt.addEventListener("click", async function klick(ev) {
|
||
if (!document.body.contains(unten)) return inhalt.removeEventListener("click", klick);
|
||
const ziel = ev.target as HTMLElement;
|
||
const o = ziel.closest<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 === "aufgabe-neu") return (await bearbeiten("aufgaben", "Neue Aufgabe", aufgabenDat.felder, null, { projekt_id: id, kontakt_id: p.bauherr_id ?? null })) && neuLaden();
|
||
if (a === "bearbeiten") {
|
||
const e = await dialog("Projekt bearbeiten", await projektFelder(), p, true);
|
||
if (!e) return;
|
||
if (e.aktion === "loeschen") { await api(`projekte/${id}`, "DELETE"); location.hash = "projekte"; return; }
|
||
const r = await api<Zeile>(`projekte/${id}`, "PATCH", ohneNull(e.daten));
|
||
if (r.ordner_fehler) hinweis.text = r.ordner_fehler;
|
||
return neuLaden();
|
||
}
|
||
if (a === "zahlungsplan") {
|
||
try { await api(`projekte/${id}/zahlungsplan`, "POST"); neuLaden(); } catch (err) { teil.querySelector(".fehler")!.textContent = (err as Error).message; }
|
||
return;
|
||
}
|
||
if (a === "beschreibung") {
|
||
const feld = ziel.closest<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();
|
||
};
|
||
}
|
||
|
||
async function terminplan(): Promise<void> {
|
||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||
}
|
||
|
||
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
|
||
// oder Monat jede einzelne Zahlung mit Datum, Projekt und Betrag zum Aufklappen
|
||
let liquiOffen = new Set<string>();
|
||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||
const leiste = seite("Liquidität");
|
||
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
|
||
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
|
||
<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>`;
|
||
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
|
||
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
|
||
a.value = ansicht;
|
||
n.value = String(anzahl);
|
||
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
|
||
const [perioden, projekte, einst] = await Promise.all([
|
||
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||
]);
|
||
const projektName = new Map(projekte.map((p) => [p.nummer, p.bezeichnung]));
|
||
const zeitraum = (p: Zeile) => (ansicht === "woche" ? `KW ${kalenderwoche(p.von)} · ${dat(p.von).slice(0, 6)} – ${dat(p.bis).slice(0, 6)}` : `${MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]} ${p.von.slice(0, 4)}`);
|
||
|
||
// Kennzahlen
|
||
const tief = perioden.reduce((m, p) => (p.kontostand < m.kontostand ? p : m), perioden[0] ?? { kontostand: 0 });
|
||
const summeEin = perioden.reduce((s, p) => s + p.einnahmen, 0), summeAus = perioden.reduce((s, p) => s + p.ausgaben, 0);
|
||
const ende = perioden.at(-1);
|
||
const kachel = (titel: string, wert: string, unter: string, rot = false) =>
|
||
`<div class="kachel liqui-zahl"><h3>${esc(titel)}</h3><p class="gross${rot ? " fehler" : ""}">${wert}</p><p class="hinweis">${unter}</p></div>`;
|
||
const startsaldo = Number(einst.startsaldo ?? 0);
|
||
inhalt.insertAdjacentHTML("beforeend", `<div class="kacheln liqui-kacheln">
|
||
${kachel("Kontostand", euro(startsaldo), einst.startsaldoDatum ? `eingetragen am ${dat(einst.startsaldoDatum)} · <a href="#daten">ändern</a>` : '<a href="#daten">unter Daten eintragen</a>')}
|
||
${kachel("Tiefster Stand", tief ? euro(tief.kontostand) : "–", tief ? esc(zeitraum(tief)) : "", (tief?.kontostand ?? 0) < 0)}
|
||
${kachel("Einnahmen / Ausgaben", `<span class="ein">${euro(summeEin)}</span><br>${euro(summeAus)}`, `im angezeigten Zeitraum, Saldo ${euro(summeEin + summeAus)}`)}
|
||
${kachel(`Stand am ${ende ? dat(ende.bis) : ""}`, ende ? euro(ende.kontostand) : "–", "Ende des angezeigten Zeitraums", (ende?.kontostand ?? 0) < 0)}
|
||
</div>`);
|
||
|
||
// Verlauf: Kontostand je Zeitraum als Säulen, unter null rot
|
||
if (perioden.length) {
|
||
const werte = perioden.map((p) => p.kontostand as number);
|
||
const hoch = Math.max(0, ...werte), tiefst = Math.min(0, ...werte), spanne = hoch - tiefst || 1;
|
||
const nullAb = (hoch / spanne) * 100;
|
||
const jede = Math.ceil(perioden.length / 13);
|
||
inhalt.insertAdjacentHTML("beforeend", `<section class="karte liqui-verlauf"><h2>Kontostand am Ende ${ansicht === "woche" ? "der Woche" : "des Monats"}</h2>
|
||
<div class="saeulen" style="--null:${nullAb}%">${perioden.map((p, i) => {
|
||
const v = p.kontostand as number, h = (Math.abs(v) / spanne) * 100;
|
||
return `<div class="saeule" title="${esc(zeitraum(p))}: ${euro(v)}"><div class="flaeche"><i class="${v < 0 ? "minus" : "plus"}" style="height:${h}%"></i></div>
|
||
<small>${i % jede === 0 ? (ansicht === "woche" ? `KW ${kalenderwoche(p.von)}` : MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]!.slice(0, 3)) : ""}</small></div>`;
|
||
}).join("")}</div></section>`);
|
||
}
|
||
|
||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||
const heuteD = heute();
|
||
const zeile = (x: Zeile) => {
|
||
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
|
||
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
|
||
<td class="optional">${projekt}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
|
||
};
|
||
const tab = document.createElement("table");
|
||
tab.className = "liqui-tabelle";
|
||
tab.innerHTML = `<thead><tr><th>${ansicht === "woche" ? "Woche" : "Monat"}</th><th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th></tr></thead>
|
||
${perioden.map((p) => {
|
||
const offen = liquiOffen.has(p.von);
|
||
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
|
||
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitraum(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
|
||
<td class="zahl ein">${p.einnahmen ? euro(p.einnahmen) : "–"}</td><td class="zahl aus">${p.ausgaben ? euro(p.ausgaben) : "–"}</td><td class="zahl optional">${euro(p.saldo)}</td>
|
||
<td class="zahl"><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b></td></tr>
|
||
${offen ? `<tr class="details"><td colspan="5">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
|
||
}).join("")}`;
|
||
tab.addEventListener("click", (ev) => {
|
||
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr.periode");
|
||
if (!tr) return;
|
||
const von = tr.dataset.von!;
|
||
liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von);
|
||
liquiditaetSeite(ansicht, anzahl);
|
||
});
|
||
const alleOffen = perioden.every((p) => liquiOffen.has(p.von));
|
||
const alleKnopf = leiste.querySelector<HTMLButtonElement>("#l-alle")!;
|
||
alleKnopf.textContent = alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen";
|
||
alleKnopf.onclick = () => { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); liquiditaetSeite(ansicht, anzahl); };
|
||
inhalt.append(tab);
|
||
}
|
||
|
||
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
|
||
const LK_FELDER: Feld[] = [
|
||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
|
||
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
|
||
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
|
||
];
|
||
|
||
async function laufendeKosten(): Promise<void> {
|
||
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
|
||
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
|
||
const zeilen = await api<Zeile[]>("laufende-kosten");
|
||
const r = Object.fromEntries(RHYTHMEN);
|
||
inhalt.appendChild(tabelle([
|
||
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
|
||
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
|
||
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
|
||
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
|
||
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLTableElement {
|
||
const zuordnung = (z: Zeile) => [ohneProjekt ? "" : namen.projekt[z.projekt_id], namen.kontakt[z.kontakt_id]].filter(Boolean).map(esc).join(" · ");
|
||
const t = tabelle([
|
||
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
|
||
{ titel: "Aufgabe", wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter">${zuordnung(z)}</span>` : ""}` },
|
||
{ titel: "Kategorie", wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : "") },
|
||
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
|
||
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden());
|
||
t.classList.add("aufgaben-tabelle");
|
||
t.addEventListener("click", async (ev) => {
|
||
const box = ev.target as HTMLInputElement;
|
||
if (box.type !== "checkbox") return;
|
||
ev.stopPropagation();
|
||
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||
neuLaden();
|
||
}, true);
|
||
return t;
|
||
}
|
||
|
||
// Filter der Aufgabenliste bleiben beim Wechsel zwischen den Reitern erhalten
|
||
const aufgabenFilter = { kategorie: "", projekt: "", erledigte: false };
|
||
|
||
async function aufgaben(): Promise<void> {
|
||
const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() });
|
||
const [d, alle] = await Promise.all([aufgabenDaten(), api<Zeile[]>("aufgaben")]);
|
||
const f = aufgabenFilter;
|
||
if (f.kategorie && f.kategorie !== "ohne" && !d.namen.kategorie[f.kategorie]) f.kategorie = "";
|
||
leiste.innerHTML = `<select id="a-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(d.kategorien).slice(1)], f.kategorie, KATEGORIEN_BEARBEITEN)}</select>
|
||
<select id="a-projekt" aria-label="Projekt">${optionenHtml([["", "Alle Projekte"], ["ohne", "Ohne Projekt"], ...d.projekte.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`])], f.projekt)}</select>
|
||
<label class="schalter"><input type="checkbox" id="a-erledigte"${f.erledigte ? " checked" : ""}> Erledigte zeigen</label>`;
|
||
const kat = leiste.querySelector("#a-kategorie") as HTMLSelectElement;
|
||
bearbeitbareAuswahl(kat, KATEGORIEN_BEARBEITEN, () => { f.kategorie = kat.value; aufgaben(); });
|
||
(leiste.querySelector("#a-projekt") as HTMLSelectElement).onchange = (ev) => { f.projekt = (ev.target as HTMLSelectElement).value; aufgaben(); };
|
||
(leiste.querySelector("#a-erledigte") as HTMLInputElement).onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; aufgaben(); };
|
||
const passt = (wert: string | null, filter: string) => !filter || (filter === "ohne" ? !wert : wert === filter);
|
||
const zeilen = alle.filter((a) => (f.erledigte || !a.erledigt_am) && passt(a.kategorie_id, f.kategorie) && passt(a.projekt_id, f.projekt));
|
||
inhalt.appendChild(aufgabenTabelle(zeilen, d.namen, d.felder, aufgaben));
|
||
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} von ${alle.length} Aufgaben</p>`);
|
||
}
|
||
|
||
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()}`);
|
||
seite("Übersicht");
|
||
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("beforeend", ` <small class="datum">${WOCHENTAG_LANG[wtag(u.heute)]}, ${dat(u.heute)}</small>`);
|
||
|
||
const aufgabeLi = (a: Zeile) => `<li><label><input type="checkbox" data-erledigt="${a.id}"> <span>${esc(a.text)}</span></label>
|
||
<small>${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}</small>${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</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: "€" };
|
||
|
||
const raster = document.createElement("div");
|
||
raster.className = "start";
|
||
raster.innerHTML = `
|
||
<section class="karte"><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"><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)}</section>
|
||
<section class="karte breit"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
|
||
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div></section>`;
|
||
inhalt.appendChild(raster);
|
||
|
||
raster.addEventListener("change", async (ev) => {
|
||
const box = ev.target as HTMLInputElement;
|
||
if (!box.dataset.erledigt) return;
|
||
await api(`aufgaben/${box.dataset.erledigt}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||
uebersicht();
|
||
});
|
||
raster.querySelector<HTMLElement>('[data-a="neue-aufgabe"]')!.onclick = async () => {
|
||
if (await neueAufgabe()) uebersicht();
|
||
};
|
||
}
|
||
|
||
function einsatzHtml(e: Zeile): string {
|
||
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<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 zelle = (eintraege: Zeile[], d: string, i: number) => `<td class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${eintraege.map((x) =>
|
||
`<span class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}">${esc(x.projekt.split(" ")[0])} ${esc(x.name)}</span>`).join("")}</td>`;
|
||
const tabelle = `<div class="einsatz-tabelle"><table><thead><tr><th>Wer</th>${kopf}</tr></thead><tbody>${zeilen.map((z: Zeile) =>
|
||
`<tr class="${z.wer ? "" : "ohne"}"><th>${esc(z.anzeige)}</th>${z.tage.map((t: Zeile[], i: number) => zelle(t, e.tage[i], i)).join("")}</tr>`).join("")}</tbody></table></div>`;
|
||
// am Handy: je Tag eine Liste
|
||
const liste = `<div class="einsatz-liste">${e.tage.map((d: string, i: number) => {
|
||
const eintraege = zeilen.flatMap((z: Zeile) => z.tage[i].map((x: Zeile) => ({ ...x, wer: z.anzeige })));
|
||
return eintraege.length ? `<h3>${WOCHENTAG_LANG[wtag(d)]}, ${dat(d)}</h3><ul>${eintraege.map((x: Zeile) =>
|
||
`<li><b>${esc(x.wer)}</b> ${esc(x.projekt)} · ${esc(x.name)}${x.vorgemerkt ? " <i>(vorgemerkt)</i>" : ""}</li>`).join("")}</ul>` : "";
|
||
}).join("")}</div>`;
|
||
return tabelle + liste;
|
||
}
|
||
|
||
// T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab)
|
||
function kalenderLinks(token: string | null): void {
|
||
const ziel = document.getElementById("kalender")!;
|
||
const neu = async () => {
|
||
if (token && !(await bestaetigen("Neue Links erzeugen? Die bisherigen Abos in Outlook funktionieren dann nicht mehr."))) return;
|
||
kalenderLinks((await api<{ kalenderToken: string }>("kalender/neu", "POST")).kalenderToken);
|
||
};
|
||
if (!token) {
|
||
ziel.innerHTML = `<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();
|
||
};
|
||
}
|
||
|
||
/** 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>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);
|
||
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: "Zahlungsziel Kunden (Tage)", art: "zahl" },
|
||
{ name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" },
|
||
{ name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" },
|
||
{ name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] },
|
||
{ name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] },
|
||
{ name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" },
|
||
];
|
||
const knopf = document.createElement("button");
|
||
knopf.className = "neben";
|
||
knopf.textContent = "Einstellungen bearbeiten";
|
||
knopf.onclick = async () => {
|
||
const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false);
|
||
if (r?.aktion !== "speichern") return;
|
||
const d = r.daten;
|
||
await api("einstellungen", "PUT", {
|
||
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
|
||
// Datum merken, damit die Startseite weiß, dass der Kontostand eingetragen ist
|
||
startsaldoDatum: (d.startsaldo ?? 0) !== e.startsaldo ? heute() : e.startsaldoDatum,
|
||
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
|
||
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
|
||
});
|
||
daten();
|
||
};
|
||
inhalt.appendChild(knopf);
|
||
}
|
||
|
||
// Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Benutzer und Daten immer zuletzt.
|
||
// Was jemand sieht, hängt an seiner Rolle (U2); Mitarbeiter bekommen ihre eigene, schlanke Ansicht (E27).
|
||
type Reiter = [string, string, () => Promise<void>];
|
||
function reiterFuer(s: Sitzung): Reiter[] {
|
||
const rolle = s.benutzer?.rolle;
|
||
if (rolle === "mitarbeiter") return [["meine-einsaetze", "Meine Einsätze", meineEinsaetze]];
|
||
const alle: Reiter[] = [
|
||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||
["terminplan", "Terminplan", terminplan], ["kontakte", "Kontakte", kontakte],
|
||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||
];
|
||
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||
return alle;
|
||
}
|
||
|
||
// Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift
|
||
const SYMBOLE: Record<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"/>',
|
||
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"/>',
|
||
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"/>',
|
||
"meine-einsaetze": '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4M8 15l2.5 2.5L16 13"/>',
|
||
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")!;
|
||
let REITER: Reiter[] = [];
|
||
nav.addEventListener("click", (ev) => {
|
||
const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r;
|
||
if (r) location.hash = r;
|
||
});
|
||
|
||
async function zeige(): Promise<void> {
|
||
const id = location.hash.slice(1) || REITER[0]![0];
|
||
// 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 projekt = treffer?.[1];
|
||
if (treffer?.[2]) projektTeil = treffer[2];
|
||
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : id)) ?? REITER[0]!;
|
||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||
try {
|
||
await (ablage ? ablageSeite(ablage) : projekt && REITER.some(([r]) => r === "projekte") ? projektSeite(projekt) : reiter[2]());
|
||
} catch (e) {
|
||
inhalt.insertAdjacentHTML("beforeend", `<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);
|
||
abgemeldet.melden = () => { location.hash = ""; location.reload(); };
|
||
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
|
||
REITER = reiterFuer(s);
|
||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||
werLeiste(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(() => {});
|