Projektseite, Aufgaben-Kategorien und Terminplan wie MS Project (0.3.0)
- Projekt-Detailseite mit Kacheln und Reitern, Baustellenadresse und Notiz (Migration 005) - Aufgaben mit Projekt, Kunde und Kategorie; Kategorien im Auswahlmenü bearbeiten - Terminplan: Bearbeitung direkt in der Tabelle, Spalten ausblendbar Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
370
src/web/app.ts
370
src/web/app.ts
@@ -1,5 +1,4 @@
|
||||
// Oberfläche Stufe 0. Die Reiter folgen V70; Terminplan und Projektdetails
|
||||
// kommen mit der Übernahme der V70-Oberfläche.
|
||||
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
@@ -39,6 +38,25 @@ interface Feld {
|
||||
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
|
||||
optionen?: [string, string][];
|
||||
pflicht?: boolean;
|
||||
/** Auswahl mit letztem Eintrag „… bearbeiten“: öffnet einen Editor und liefert die neuen Optionen */
|
||||
bearbeiten?: { text: string; aktion: () => Promise<[string, string][]> };
|
||||
}
|
||||
|
||||
const BEARBEITEN = "__bearbeiten";
|
||||
const optionenHtml = (optionen: [string, string][], wert: string, bearbeiten?: Feld["bearbeiten"]) =>
|
||||
optionen.map(([w, t]) => `<option value="${esc(w)}"${w === wert ? " selected" : ""}>${esc(t)}</option>`).join("")
|
||||
+ (bearbeiten ? `<option value="${BEARBEITEN}">${esc(bearbeiten.text)}</option>` : "");
|
||||
|
||||
/** Ein Auswahlfeld mit Eintrag „… bearbeiten“ verdrahten: nach dem Bearbeiten neue Optionen, alte Wahl bleibt. */
|
||||
function bearbeitbareAuswahl(sel: HTMLSelectElement, b: NonNullable<Feld["bearbeiten"]>, geaendert?: () => void): void {
|
||||
let vorher = sel.value;
|
||||
sel.addEventListener("change", async () => {
|
||||
if (sel.value !== BEARBEITEN) { vorher = sel.value; geaendert?.(); return; }
|
||||
const neu = await b.aktion();
|
||||
sel.innerHTML = optionenHtml(neu, neu.some(([w]) => w === vorher) ? vorher : "", b);
|
||||
vorher = sel.value;
|
||||
geaendert?.();
|
||||
});
|
||||
}
|
||||
|
||||
function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
|
||||
@@ -49,7 +67,7 @@ function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolea
|
||||
const id = `f-${f.name}`;
|
||||
let eingabe: string;
|
||||
if (f.art === "auswahl") {
|
||||
eingabe = `<select id="${id}">${f.optionen!.map(([w, t]) => `<option value="${esc(w)}"${w === (v ?? "") ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
|
||||
eingabe = `<select id="${id}">${optionenHtml(f.optionen!, v ?? "", f.bearbeiten)}</select>`;
|
||||
} else if (f.art === "langtext") {
|
||||
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
|
||||
} else {
|
||||
@@ -74,6 +92,7 @@ function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolea
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
||||
document.addEventListener("keydown", taste);
|
||||
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
||||
for (const f of felder) if (f.bearbeiten) bearbeitbareAuswahl(form.querySelector(`#f-${f.name}`)!, f.bearbeiten);
|
||||
form.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (a === "abbrechen") schliessen(null);
|
||||
@@ -190,34 +209,228 @@ const STATUS: [string, string][] = [
|
||||
const STATUS_TEXT = Object.fromEntries(STATUS);
|
||||
const etikett = (status: string) => `<span class="etikett ${esc(status)}">${esc(STATUS_TEXT[status] ?? status)}</span>`;
|
||||
|
||||
async function projekte(): Promise<void> {
|
||||
const VERTRAGSARTEN: [string, string][] = [["", "–"], ["vob", "VOB/B"], ["bgb", "BGB"]];
|
||||
|
||||
async function projektFelder(): Promise<Feld[]> {
|
||||
const kontaktListe = await api<Zeile[]>("kontakte");
|
||||
const felder: Feld[] = [
|
||||
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
|
||||
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: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
|
||||
{ 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: "Notiz", art: "langtext" },
|
||||
];
|
||||
const ohneNull = (z: Zeile | null) => z && { ...z, ...Object.fromEntries(["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"].map((k) => [k, z[k] ?? 0])) };
|
||||
const speichern = async (z: Zeile | null) => {
|
||||
if (await bearbeiten("projekte", z ? "Projekt bearbeiten" : "Neues Projekt", felder, z)) projekte();
|
||||
}
|
||||
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) hinweisNachLaden = p.ordner_fehler;
|
||||
location.hash = `projekt-${p.id}`;
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: () => speichern(null) });
|
||||
const zeilen = await api<Zeile[]>("projekte");
|
||||
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]));
|
||||
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc(name[z.bauherr_id] ?? "–")}</span>` },
|
||||
{ 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) => speichern(ohneNull(z))));
|
||||
], 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>
|
||||
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
|
||||
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"/>',
|
||||
};
|
||||
const kachel = (art: string, titel: string, inhaltHtml: string) => `<section class="kachel"><h3><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>${esc(titel)}</h3>${inhaltHtml}</section>`;
|
||||
|
||||
let projektTeil = "zahlungen";
|
||||
|
||||
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);
|
||||
|
||||
inhalt.innerHTML = `${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</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>`;
|
||||
hinweisNachLaden = "";
|
||||
|
||||
// Kacheln
|
||||
const anfang = vorgaenge.map((v: Zeile) => v.anfang).sort()[0];
|
||||
const ende = vorgaenge.map((v: Zeile) => v.ende).sort().at(-1);
|
||||
const sollStunden = vorgaenge.reduce((s: number, v: Zeile) => s + (Number(v.stunden) || 0), 0) || p.soll_stunden;
|
||||
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
|
||||
const adresse = ortZeile(p);
|
||||
const kacheln = document.createElement("div");
|
||||
kacheln.className = "kacheln";
|
||||
kacheln.innerHTML = [
|
||||
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>'),
|
||||
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} Abschnitten · <a href="#terminplan">Terminplan</a></p>`
|
||||
: '<p><a href="#terminplan">Abschnitt im Terminplan hinzufügen</a></p>'),
|
||||
kachel("baustelle", "Baustelle", adresse
|
||||
? `<p class="gross">${esc(p.baustelle_strasse ?? "")}<br>${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}</p>
|
||||
<p><a href="https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adresse)}" target="_blank" rel="noopener">In Karte öffnen</a></p>`
|
||||
: '<p><button class="verweis" data-a="bearbeiten">Adresse eintragen</button></p>'),
|
||||
kachel("auftrag", "Auftrag", `<dl class="werte"><dt>Umsatz netto</dt><dd>${euro(umsatz)}</dd><dt>Kosten</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>`),
|
||||
kachel("stunden", "Arbeitsstunden", `<p class="gross">${sollStunden ? `${String(sollStunden).replace(".", ",")} Std. geplant` : "Keine Stunden geplant"}</p>
|
||||
<p class="hinweis">${p.soll_tage ? `${String(p.soll_tage).replace(".", ",")} Arbeitstage · ` : ""}Ist-Stunden kommen mit der Zeiterfassung.</p>`),
|
||||
kachel("ordner", "Projektordner", p.nextcloud_link
|
||||
? `<p>${esc(p.nextcloud_link)}</p><p class="hinweis">in der Nextcloud</p>`
|
||||
: '<p class="hinweis">Wird in der Nextcloud angelegt, sobald das Programm auf dem Server läuft.</p>'),
|
||||
].join("");
|
||||
inhalt.appendChild(kacheln);
|
||||
|
||||
// Teile darunter mit Reitern wie „Dokumente / Berichte / Ablage“ bei Plancraft
|
||||
const TEILE: [string, string, number][] = [
|
||||
["zahlungen", "Zahlungsplan", eigeneZahlungen.length], ["kosten", "Kosten", eigeneKosten.length],
|
||||
["aufgaben", "Aufgaben", eigeneAufgaben.filter((a) => !a.erledigt_am).length], ["termine", "Termine", vorgaenge.length], ["notiz", "Notiz", p.notiz ? 1 : 0],
|
||||
];
|
||||
const karte = document.createElement("section");
|
||||
karte.className = "karte projekt-teile";
|
||||
karte.innerHTML = `<div class="teile-kopf"><nav class="teile">${TEILE.map(([t, titel, n]) =>
|
||||
`<button data-teil="${t}" class="${t === projektTeil ? "aktiv" : ""}">${titel}${n && t !== "notiz" ? ` <small>${n}</small>` : ""}</button>`).join("")}</nav><span id="teil-knopf"></span></div><div id="teil"></div>`;
|
||||
inhalt.appendChild(karte);
|
||||
const teil = karte.querySelector("#teil")!;
|
||||
const knopfOrt = karte.querySelector("#teil-knopf")!;
|
||||
const knopf = (text: string, aktion: () => void) => {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
b.textContent = text;
|
||||
b.onclick = aktion;
|
||||
knopfOrt.replaceChildren(b);
|
||||
};
|
||||
|
||||
const zeigeTeil = () => {
|
||||
karte.querySelectorAll<HTMLElement>("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === projektTeil));
|
||||
teil.replaceChildren();
|
||||
knopfOrt.replaceChildren();
|
||||
if (projektTeil === "zahlungen") {
|
||||
knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", ZAHLUNG_FELDER, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden());
|
||||
const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0);
|
||||
teil.append(eigeneZahlungen.length ? tabelle([
|
||||
{ titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(Object.fromEntries(ZAHLUNGSARTEN)[z.art] ?? "")}</span>` },
|
||||
{ titel: "Termin", wert: (z) => dat(z.termin) },
|
||||
{ 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", ZAHLUNG_FELDER, z)) && neuLaden()) : leer("Noch kein Zahlungsplan."));
|
||||
if (eigeneZahlungen.length) teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Umsatz netto ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
|
||||
} else if (projektTeil === "kosten") {
|
||||
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 },
|
||||
];
|
||||
knopf("+ Kosten", async () => (await bearbeiten("kosten", "Neue Kosten", felder, null, { projekt_id: id, art: "material", status: "geplant", termin: heute() })) && neuLaden());
|
||||
teil.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. Die Pauschalen stehen unter „Bearbeiten“."));
|
||||
} else if (projektTeil === "aufgaben") {
|
||||
knopf("+ Aufgabe", async () => (await bearbeiten("aufgaben", "Neue Aufgabe", aufgabenDat.felder, null, { projekt_id: id, kontakt_id: p.bauherr_id ?? null })) && neuLaden());
|
||||
teil.append(eigeneAufgaben.length ? aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true) : leer("Keine Aufgaben zu diesem Projekt."));
|
||||
} else if (projektTeil === "termine") {
|
||||
const a = document.createElement("a");
|
||||
a.className = "neben";
|
||||
a.href = "#terminplan";
|
||||
a.textContent = "Im Terminplan bearbeiten";
|
||||
knopfOrt.replaceChildren(a);
|
||||
const zeilen = abschnitte.flatMap((ab: Zeile) => [{ ...ab, ist_abschnitt: true }, ...vorgaenge.filter((v: Zeile) => v.abschnitt_id === ab.id)]);
|
||||
const leute = (v: Zeile) => plan.besetzungen.filter((b: Zeile) => b.vorgang_id === v.id).map((b: Zeile) => esc(b.kurz) + (b.personen > 1 ? ` ×${b.personen}` : "")).join(", ");
|
||||
teil.append(zeilen.length ? tabelle([
|
||||
{ titel: "Nr.", wert: (v) => (v.ist_abschnitt ? "" : esc(v.nummer)), klasse: "optional" },
|
||||
{ titel: "Vorgang", wert: (v) => (v.ist_abschnitt ? `<strong>${esc(v.name)}</strong>` : esc(v.name)) },
|
||||
{ titel: "Start", wert: (v) => (v.ist_abschnitt ? "" : dat(v.anfang)) },
|
||||
{ titel: "Ende", wert: (v) => (v.ist_abschnitt ? "" : dat(v.ende)), klasse: "optional" },
|
||||
{ titel: "AT", wert: (v) => (v.ist_abschnitt ? "" : String(v.dauer).replace(".", ",")), klasse: "zahl" },
|
||||
{ titel: "Personal", wert: (v) => (v.ist_abschnitt ? "" : leute(v)) },
|
||||
], zeilen) : leer("Noch keine Termine."));
|
||||
} else {
|
||||
teil.innerHTML = `<label for="p-notiz" class="unsichtbar">Notiz</label><textarea id="p-notiz" rows="6" placeholder="Notizen zum Projekt">${esc(p.notiz ?? "")}</textarea>
|
||||
<p><button class="haupt" data-a="notiz">Notiz speichern</button> <span id="notiz-ok" class="hinweis"></span></p>`;
|
||||
}
|
||||
};
|
||||
const leer = (text: string) => Object.assign(document.createElement("p"), { className: "hinweis leer", textContent: text });
|
||||
zeigeTeil();
|
||||
|
||||
inhalt.addEventListener("click", async function klick(ev) {
|
||||
if (!document.body.contains(karte)) return inhalt.removeEventListener("click", klick);
|
||||
const ziel = ev.target as HTMLElement;
|
||||
const t = ziel.closest<HTMLElement>("[data-teil]")?.dataset.teil;
|
||||
if (t) { projektTeil = t; zeigeTeil(); return; }
|
||||
const a = ziel.dataset.a;
|
||||
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) hinweisNachLaden = r.ordner_fehler;
|
||||
neuLaden();
|
||||
}
|
||||
if (a === "notiz") {
|
||||
await api(`projekte/${id}`, "PATCH", { notiz: (inhalt.querySelector("#p-notiz") as HTMLTextAreaElement).value.trim() || null });
|
||||
p.notiz = (inhalt.querySelector("#p-notiz") as HTMLTextAreaElement).value.trim() || null;
|
||||
inhalt.querySelector("#notiz-ok")!.textContent = "Gespeichert";
|
||||
}
|
||||
});
|
||||
(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) hinweisNachLaden = r.ordner_fehler;
|
||||
neuLaden();
|
||||
};
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
@@ -267,16 +480,94 @@ async function laufendeKosten(): Promise<void> {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
|
||||
}
|
||||
|
||||
const AUFGABE_FELDER: Feld[] = [
|
||||
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
|
||||
];
|
||||
// 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])];
|
||||
|
||||
function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElement {
|
||||
/** 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}"${z.erledigt_am ? " checked" : ""}>` },
|
||||
{ titel: "Aufgabe", wert: (z) => (z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)) },
|
||||
{ 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", AUFGABE_FELDER, z)) && neuLaden());
|
||||
], 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;
|
||||
@@ -287,10 +578,25 @@ function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElemen
|
||||
return t;
|
||||
}
|
||||
|
||||
// Filter der Aufgabenliste bleiben beim Wechsel zwischen den Reitern erhalten
|
||||
const aufgabenFilter = { kategorie: "", projekt: "", erledigte: false };
|
||||
|
||||
async function aufgaben(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) && aufgaben();
|
||||
seite("Aufgaben", { text: "Neue Aufgabe", aktion: neu });
|
||||
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
|
||||
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"];
|
||||
@@ -305,7 +611,7 @@ async function uebersicht(): Promise<void> {
|
||||
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)}` : ""}</small></li>`;
|
||||
<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: "€" };
|
||||
@@ -332,7 +638,7 @@ async function uebersicht(): Promise<void> {
|
||||
uebersicht();
|
||||
});
|
||||
raster.querySelector<HTMLElement>('[data-a="neue-aufgabe"]')!.onclick = async () => {
|
||||
if (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) uebersicht();
|
||||
if (await neueAufgabe()) uebersicht();
|
||||
};
|
||||
}
|
||||
|
||||
@@ -496,10 +802,12 @@ nav.addEventListener("click", (ev) => {
|
||||
|
||||
async function zeige(): Promise<void> {
|
||||
const id = location.hash.slice(1) || "uebersicht";
|
||||
const reiter = REITER.find(([r]) => r === id) ?? REITER[0]!;
|
||||
// Projektseite: #projekt-<id>, gehört zum Reiter Projekte
|
||||
const projekt = /^projekt-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
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 reiter[2]();
|
||||
await (projekt ? projektSeite(projekt) : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user