Sortieren und Filtern wie in Excel in jeder Tabelle, Ansichten je Benutzer (0.13.0)
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:
213
src/web/app.ts
213
src/web/app.ts
@@ -1,11 +1,12 @@
|
||||
// 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 Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||||
huelle, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||||
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
|
||||
import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js";
|
||||
import { meinUrlaub } from "./urlaub.js";
|
||||
import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, filterMenue, filterText, gespeicherteAnsicht, liste } from "./liste.js";
|
||||
import { mitarbeiterSeite, personalSeite } from "./personal.js";
|
||||
import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
|
||||
@@ -27,13 +28,18 @@ async function kontakte(): Promise<void> {
|
||||
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()));
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "kontakte", einheit: ["Kontakt", "Kontakte"], vorgabe: { sort: [["name", "auf"]] },
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ id: "firma", titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||||
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk), klasse: "optional" },
|
||||
{ id: "telefon", titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||||
{ id: "email", titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte(),
|
||||
}));
|
||||
}
|
||||
|
||||
const STATUS: [string, string][] = [
|
||||
@@ -75,16 +81,22 @@ async function projekte(): Promise<void> {
|
||||
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>`);
|
||||
const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i]));
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "projekte", einheit: ["Projekt", "Projekte"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", text: (z) => z.bezeichnung, wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
|
||||
{ id: "nummer", titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||||
{ id: "kunde", titel: "Kunde", wert: (z) => esc(name[z.bauherr_id] ?? ""), klasse: "optional" },
|
||||
{ id: "ort", titel: "Ort", wert: (z) => esc(z.baustelle_ort ?? ""), klasse: "optional" },
|
||||
{ id: "status", titel: "Status", wert: (z) => etikett(z.status), sortWert: (z) => statusRang[z.status] ?? 99 },
|
||||
{ id: "umsatz", titel: "Umsatz netto", art: "zahl", wert: (z) => euro(z.umsatz_netto), sortWert: (z) => z.umsatz_netto, klasse: "zahl optional" },
|
||||
{ id: "kosten", titel: "Kosten", art: "zahl", wert: (z) => euro(kostenSumme(z)), sortWert: kostenSumme, klasse: "zahl optional" },
|
||||
{ id: "rohertrag", titel: "Rohertrag", art: "zahl", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), sortWert: (z) => z.umsatz_netto - kostenSumme(z), klasse: "zahl optional" },
|
||||
],
|
||||
zeilen, klick: (z) => (location.hash = `projekt-${z.id}`),
|
||||
fuss: (sichtbar) => `<p>Rohertrag ${sichtbar.length === zeilen.length ? "gesamt" : "der gezeigten Projekte"}: <strong>${euro(sichtbar.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0))}</strong></p>`,
|
||||
}));
|
||||
}
|
||||
|
||||
// ---------- Projektseite (P2), aufgebaut wie bei Plancraft ----------
|
||||
@@ -116,7 +128,6 @@ const kachel = (art: string, titel: string, inhaltHtml: string) => `<section cla
|
||||
// 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) => { const m = Math.round(h * 60); return `${Math.floor(m / 60)}:${String(m % 60).padStart(2, "0")} Std.`; };
|
||||
const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
|
||||
@@ -208,12 +219,17 @@ async function projektSeite(id: string): Promise<void> {
|
||||
];
|
||||
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."));
|
||||
ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? liste({
|
||||
schluessel: "projekt-kosten", klein: true, einheit: ["Position", "Positionen"],
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (k) => k.bezeichnung, wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc(kontakt[k.kontakt_id]?.name ?? "")}</span>` },
|
||||
{ id: "art", titel: "Art", wert: (k) => esc(Object.fromEntries(KOSTENARTEN)[k.art] ?? k.art) },
|
||||
{ id: "termin", titel: "Termin", art: "datum", wert: (k) => dat(k.termin), sortWert: (k) => k.termin },
|
||||
{ id: "status", titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (k) => euro(k.netto), sortWert: (k) => k.netto, klasse: "zahl" },
|
||||
],
|
||||
zeilen: eigeneKosten, klick: async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden(),
|
||||
}) : leer("Noch keine Einzelkosten."));
|
||||
}
|
||||
};
|
||||
|
||||
@@ -287,34 +303,26 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}
|
||||
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.append(liste({
|
||||
schluessel: "projekt-zahlungen", klein: true, einheit: ["Rate", "Raten"],
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
|
||||
{ id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
|
||||
{ id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (z) => euro(z.netto), sortWert: (z) => z.netto, klasse: "zahl" },
|
||||
],
|
||||
zeilen: eigeneZahlungen, klick: 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(); };
|
||||
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>`;
|
||||
seite.append(aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true));
|
||||
};
|
||||
|
||||
zeigeOben();
|
||||
@@ -376,7 +384,8 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt, filterMenue, filterText,
|
||||
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] });
|
||||
}
|
||||
|
||||
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
|
||||
@@ -384,14 +393,17 @@ async function terminplan(): Promise<void> {
|
||||
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>
|
||||
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option><option value="liste">Einzelne Zahlungen</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>`;
|
||||
${ansicht === "liste" ? "" : '<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));
|
||||
// „Einzelne Zahlungen“: dieselben Wochen, aber jede Zahlung als Zeile zum Sortieren und Filtern
|
||||
const einzeln = ansicht === "liste";
|
||||
if (einzeln) ansicht = "woche";
|
||||
const [perioden, projekte, einst] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
@@ -426,8 +438,31 @@ async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
}).join("")}</div></section>`);
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
const heuteD = heute();
|
||||
if (einzeln) {
|
||||
// Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung
|
||||
let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : startsaldo;
|
||||
const posten = perioden.flatMap((p) => p.posten as Zeile[])
|
||||
.sort((x, y) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag))
|
||||
.map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.betrag) }));
|
||||
inhalt.append(liste({
|
||||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||||
zeilenKlasse: (x) => (x.datum < heuteD ? "vorbei" : ""),
|
||||
spalten: [
|
||||
{ id: "datum", titel: "Fällig am", art: "datum", wert: (x) => dat(x.datum), sortWert: (x) => x.datum },
|
||||
{ id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
|
||||
{ id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" },
|
||||
{ id: "projekt", titel: "Projekt", wert: (x) => (x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (x) => `<span class="${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</span>`, sortWert: (x) => x.betrag, klasse: "zahl" },
|
||||
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => x.stand, klasse: "zahl optional" },
|
||||
],
|
||||
zeilen: posten,
|
||||
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
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>
|
||||
@@ -470,13 +505,19 @@ async function laufendeKosten(): Promise<void> {
|
||||
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>`);
|
||||
const monatlich = (l: Zeile[]) => l.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "laufende-kosten", einheit: ["Position", "Positionen"],
|
||||
spalten: [
|
||||
{ id: "kategorie", titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { id: "bezeichnung", titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||||
{ id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus) },
|
||||
{ id: "start", titel: "Ab", art: "datum", wert: (z) => dat(z.start), sortWert: (z) => z.start, klasse: "optional" },
|
||||
{ id: "ende", titel: "Endet", art: "datum", wert: (z) => dat(z.ende), sortWert: (z) => z.ende, klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (z) => euro(z.betrag), sortWert: (z) => z.betrag, klasse: "zahl" },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten(),
|
||||
fuss: (sichtbar) => `<p>Monatlich${sichtbar.length === zeilen.length ? "" : " (gezeigte Positionen)"}: <strong>${euro(monatlich(sichtbar))}</strong></p>`,
|
||||
}));
|
||||
}
|
||||
|
||||
// G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar
|
||||
@@ -558,18 +599,38 @@ 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 {
|
||||
// Aufgaben sortieren und filtern wie in Excel (Henning, 20.10.2026); Erledigte sind ein Filter auf der Hakenspalte
|
||||
const AUFGABEN_VORGABE = { sort: [["faellig", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] } };
|
||||
const AUFGABEN_VORLAGEN = [
|
||||
{ name: "Meine Woche", ansicht: { sort: [["faellig", "auf"], ["kategorie", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" } } },
|
||||
{ name: "Erledigte", ansicht: { sort: [["faellig", "ab"]] as [string, "ab"][], filter: { erledigt: ["offen"] } } },
|
||||
];
|
||||
|
||||
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLElement {
|
||||
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");
|
||||
const t = liste({
|
||||
schluessel: ohneProjekt ? "projekt-aufgaben" : "aufgaben", klein: ohneProjekt, einheit: ["Aufgabe", "Aufgaben"], klasse: "aufgaben-tabelle",
|
||||
vorgabe: AUFGABEN_VORGABE, vorlagen: ohneProjekt ? [] : AUFGABEN_VORLAGEN, leer: "Noch keine Aufgaben.",
|
||||
zeilenKlasse: (z) => (z.erledigt_am ? "erledigt" : ""),
|
||||
spalten: [
|
||||
{ id: "erledigt", titel: "Erledigt", kopf: '<span aria-label="Erledigt">✓</span>', text: (z) => (z.erledigt_am ? "erledigt" : "offen"),
|
||||
wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
|
||||
{ id: "text", titel: "Aufgabe", text: (z) => z.text,
|
||||
wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter${ohneProjekt ? "" : " nur-schmal"}">${zuordnung(z)}</span>` : ""}` },
|
||||
...(ohneProjekt ? [] : [
|
||||
{ id: "projekt", titel: "Projekt", wert: (z: Zeile) => esc(namen.projekt[z.projekt_id] ?? ""), klasse: "optional" },
|
||||
{ id: "kontakt", titel: "Kunde / Kontakt", wert: (z: Zeile) => esc(namen.kontakt[z.kontakt_id] ?? ""), klasse: "optional" },
|
||||
]),
|
||||
{ id: "kategorie", titel: "Kategorie", text: (z) => namen.kategorie[z.kategorie_id] ?? "",
|
||||
wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : "") },
|
||||
{ id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig_am,
|
||||
wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden(),
|
||||
});
|
||||
t.addEventListener("click", async (ev) => {
|
||||
const box = ev.target as HTMLInputElement;
|
||||
if (box.type !== "checkbox") return;
|
||||
if (box.type !== "checkbox" || !box.dataset.id) return;
|
||||
ev.stopPropagation();
|
||||
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||||
neuLaden();
|
||||
@@ -577,25 +638,12 @@ function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[],
|
||||
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>`);
|
||||
leiste.innerHTML = '<button class="neben" data-a="kategorien">Kategorien bearbeiten</button>';
|
||||
leiste.querySelector<HTMLElement>('[data-a="kategorien"]')!.onclick = async () => { await kategorienBearbeiten(); void aufgaben(); };
|
||||
inhalt.appendChild(aufgabenTabelle(alle, d.namen, d.felder, aufgaben));
|
||||
}
|
||||
|
||||
const WOCHENTAG = ["", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
|
||||
@@ -851,6 +899,7 @@ async function start(): Promise<void> {
|
||||
REITER = reiterFuer(s);
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
werLeiste(s);
|
||||
await ansichtenLaden();
|
||||
window.addEventListener("hashchange", zeige);
|
||||
await zeige();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user