diff --git a/CHANGELOG.md b/CHANGELOG.md index af0b1b2..f039b44 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,16 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.13.0 + +- Sortieren und Filtern wie in Excel in jeder Tabelle: Aufgaben, Projekte, Kontakte, Personal, Stunden, laufende Kosten, Benutzer, Kosten und Zahlungsplan auf der Projektseite, Abwesenheiten und Arbeitszeitmodelle. Spaltenkopf anklicken: auf- oder absteigend sortieren, „+ als weitere Sortierung“ (z. B. erst Fällig, dann Kategorie), suchen und Werte abhaken. Datumsspalten haben zusätzlich Zeiträume wie „Heute“, „Diese Woche“ oder „Bis Ende dieser Woche“. +- Oben stehen Sortierung und Filter als Chips, ✕ nimmt einen Filter weg, „Zurücksetzen“ alle. +- Das Auge am Zeilenende blendet eine Zeile aus; „n ausgeblendet · einblenden“ unter der Tabelle holt sie zurück. +- Ansichten speichern: „Ansicht ▾“ merkt sich Sortierung, Filter und ausgeblendete Zeilen unter einem Namen. Bei den Aufgaben gibt es fertig „Meine Woche“ (offen, fällig bis Sonntag) und „Erledigte“. Das Programm merkt sich die Ansicht je Benutzer, am Handy und im Büro gleich. +- Aufgaben: Projekt und Kunde haben eigene Spalten; „Erledigte zeigen“ ist jetzt der Filter auf der Hakenspalte. Auf der Projektseite stehen die Aufgaben rechts als Tabelle mit denselben Möglichkeiten. +- Liquidität: neue Ansicht „Einzelne Zahlungen“, jede Zahlung als Zeile mit Kontostand danach, zum Sortieren und Filtern (z. B. nur ein Projekt). +- Terminplan: Filter für Projekte und Personal mit Haken (mehrere Personen auf einmal), Auge zum Ausblenden einzelner Projekte, Abschnitte und Vorgänge. Die Reihenfolge bleibt die gezogene. Die Knöpfe − und + oben sind weg; gezoomt wird mit Tag/Woche/Monat und durch Ziehen an der Zeitskala. + ## 0.12.0 - Dauer aus Stunden und Besetzung (T15): Im Besetzungsfenster eines Vorgangs trägst du die Arbeitsstunden ein. Mit „Dauer aus Stunden und Besetzung berechnen“ rechnet das Programm die Dauer aus der Zeit, die die Eingeteilten wirklich haben: Arbeitszeitmodell, genehmigter Urlaub, Krankheit und Feiertage zählen mit, der Freitag bleibt Reserve. Mehr Leute machen den Vorgang kürzer, Teilzeit oder Urlaub länger; Nachfolger rücken mit. Berechnete Dauern tragen ein ⚙ in der Spalte Dauer. diff --git a/demo/kern.ts b/demo/kern.ts index 95142c4..db15546 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -12,6 +12,7 @@ import m007 from "../src/server/migrations/007_anmeldung.sql"; import m008 from "../src/server/migrations/008_personal.sql"; import m009 from "../src/server/migrations/009_zeiterfassung.sql"; import m010 from "../src/server/migrations/010_dauer_aus_besetzung.sql"; +import m011 from "../src/server/migrations/011_ansichten.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -19,6 +20,7 @@ const MIGRATIONEN: [string, string][] = [ ["007_anmeldung.sql", m007], ["008_personal.sql", m008], ["009_zeiterfassung.sql", m009], ["010_dauer_aus_besetzung.sql", m010], + ["011_ansichten.sql", m011], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/demo/main.ts b/demo/main.ts index 765d35c..2f20e0a 100644 --- a/demo/main.ts +++ b/demo/main.ts @@ -62,7 +62,7 @@ async function main() { if (speicher) { melde("Deine Daten werden geladen …"); const daten: Record[]> = {}; - for (const pfad of [...TABELLEN, ...NUR_SICHERUNG].map((t) => t.pfad).concat("benutzer")) daten[pfad] = await nochmal(() => alle(speicher, pfad)); + for (const pfad of [...TABELLEN, ...NUR_SICHERUNG].map((t) => t.pfad).concat("benutzer", "ansichten")) daten[pfad] = await nochmal(() => alle(speicher, pfad)); const e = await nochmal(() => speicher.doc("meta/einstellungen").get()); if (Object.values(daten).some((z) => z.length) || e.exists) { const r = await app.verarbeite("POST", "/api/import/stand", { programm: "betrieb", einstellungen: e.data()?.daten, daten }); diff --git a/package.json b/package.json index b8ef0a6..ba63113 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.12.0", + "version": "0.13.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/ansicht.ts b/src/domain/ansicht.ts new file mode 100644 index 0000000..ad22327 --- /dev/null +++ b/src/domain/ansicht.ts @@ -0,0 +1,115 @@ +// Sortieren und Filtern wie in Excel (Henning, 20.10.2026), für jede Tabelle und Liste gleich: +// Filter je Spalte über eine Werteliste mit Haken, bei Datumsspalten zusätzlich Zeiträume wie „Diese Woche“, +// Sortierung über mehrere Spalten nacheinander, einzelne Zeilen ausblenden. + +import { type Datum, montagDerWoche, plusMonate, plusTage } from "./datum.js"; + +export type Richtung = "auf" | "ab"; + +export interface Ansicht { + /** in dieser Reihenfolge: erst nach der ersten Spalte, bei Gleichstand nach der zweiten … */ + sort: [string, Richtung][]; + /** je Spalte die abgewählten Werte; neue Werte sind also sichtbar */ + filter: Record; + /** je Datumsspalte ein Zeitraum aus ZEITRAEUME */ + zeit: Record; + /** ausgeblendete Zeilen (IDs) */ + aus: string[]; +} + +export const leereAnsicht = (): Ansicht => ({ sort: [], filter: {}, zeit: {}, aus: [] }); + +/** Aus Gespeichertem eine vollständige Ansicht machen; Unbrauchbares fällt weg */ +export function ansichtAus(x: unknown): Ansicht { + const a = (x && typeof x === "object" ? x : {}) as Partial; + const strings = (l: unknown) => (Array.isArray(l) ? l.filter((s): s is string => typeof s === "string") : []); + const obj = (o: unknown) => (o && typeof o === "object" && !Array.isArray(o) ? (o as Record) : {}); + return { + sort: (Array.isArray(a.sort) ? a.sort : []).filter((s): s is [string, Richtung] => Array.isArray(s) && typeof s[0] === "string" && (s[1] === "auf" || s[1] === "ab")), + filter: Object.fromEntries(Object.entries(obj(a.filter)).map(([k, v]) => [k, strings(v)]).filter(([, v]) => (v as string[]).length)), + zeit: Object.fromEntries(Object.entries(obj(a.zeit)).filter(([, v]) => typeof v === "string" && ZEITRAUM_TEXT[v])) as Record, + aus: strings(a.aus), + }; +} + +export const gleich = (a: Ansicht, b: Ansicht) => JSON.stringify(ansichtAus(a)) === JSON.stringify(ansichtAus(b)); + +export const LEER = "(Leer)"; + +/** Zeiträume wie Excels Datumsfilter */ +export const ZEITRAEUME: [string, string][] = [ + ["vor-heute", "Vor heute"], ["bis-heute", "Bis heute"], ["heute", "Heute"], ["ab-heute", "Ab heute"], + ["diese-woche", "Diese Woche"], ["bis-wochenende", "Bis Ende dieser Woche"], ["naechste-woche", "Nächste Woche"], ["letzte-woche", "Letzte Woche"], + ["dieser-monat", "Dieser Monat"], ["naechster-monat", "Nächster Monat"], ["letzter-monat", "Letzter Monat"], ["dieses-jahr", "Dieses Jahr"], +]; +export const ZEITRAUM_TEXT: Record = Object.fromEntries(ZEITRAEUME); + +/** Liegt ein Datum im Zeitraum? Ohne Datum nie. Wochen laufen von Montag bis Sonntag. */ +export function imZeitraum(art: string, d: Datum | null | undefined, heute: Datum): boolean { + if (!d) return false; + const mo = montagDerWoche(heute), so = plusTage(mo, 6); + const monat = heute.slice(0, 7); + switch (art) { + case "vor-heute": return d < heute; + case "bis-heute": return d <= heute; + case "heute": return d === heute; + case "ab-heute": return d >= heute; + case "diese-woche": return d >= mo && d <= so; + case "bis-wochenende": return d <= so; + case "naechste-woche": return d >= plusTage(mo, 7) && d <= plusTage(so, 7); + case "letzte-woche": return d >= plusTage(mo, -7) && d <= plusTage(so, -7); + case "dieser-monat": return d.slice(0, 7) === monat; + case "naechster-monat": return d.slice(0, 7) === plusMonate(`${monat}-01`, 1).slice(0, 7); + case "letzter-monat": return d.slice(0, 7) === plusMonate(`${monat}-01`, -1).slice(0, 7); + case "dieses-jahr": return d.slice(0, 4) === heute.slice(0, 4); + default: return true; + } +} + +const MONATE = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]; +/** Datumsspalten filtern in der Werteliste nach Monaten */ +export const monatVon = (d: Datum | null | undefined) => (d ? d.slice(0, 7) : LEER); +export const monatText = (m: string) => (m === LEER ? LEER : `${MONATE[Number(m.slice(5, 7)) - 1]} ${m.slice(0, 4)}`); + +export interface SpaltenWerte { + id: string; + art?: "text" | "zahl" | "datum"; + /** Wert in der Filterliste (bei Datum der Monat) */ + wert: (i: number) => string; + /** Wert zum Sortieren (bei Datum das ISO-Datum) */ + sort: (i: number) => string | number | null | undefined; +} + +/** Erfüllt Zeile i alle Filter (außer denen der Spalte `ausser`, für die Werteliste dieser Spalte)? */ +export function passt(i: number, a: Ansicht, spalten: SpaltenWerte[], heute: Datum, ausser?: string): boolean { + for (const s of spalten) { + if (s.id === ausser) continue; + const ab = a.filter[s.id]; + if (ab?.length && ab.includes(s.wert(i))) return false; + const z = a.zeit[s.id]; + if (z && !imZeitraum(z, s.sort(i) as Datum | null, heute)) return false; + } + return true; +} + +const leer = (v: unknown) => v === null || v === undefined || v === ""; + +/** Zwei Werte vergleichen; Leeres steht immer hinten, egal in welcher Richtung */ +export function vergleiche(x: unknown, y: unknown, r: Richtung): number { + if (leer(x) || leer(y)) return leer(x) === leer(y) ? 0 : leer(x) ? 1 : -1; + const n = typeof x === "number" && typeof y === "number" ? x - y : String(x).localeCompare(String(y), "de", { numeric: true, sensitivity: "base" }); + return r === "auf" ? n : -n; +} + +/** Indizes in sortierter Reihenfolge; bei Gleichstand bleibt die ursprüngliche Reihenfolge */ +export function sortiere(indizes: number[], sort: Ansicht["sort"], spalten: SpaltenWerte[]): number[] { + const nach = sort.map(([id, r]) => [spalten.find((s) => s.id === id), r] as const).filter((x): x is [SpaltenWerte, Richtung] => !!x[0]); + if (!nach.length) return indizes; + return [...indizes].sort((a, b) => { + for (const [s, r] of nach) { + const c = vergleiche(s.sort(a), s.sort(b), r); + if (c) return c; + } + return a - b; + }); +} diff --git a/src/server/app.ts b/src/server/app.ts index 1379a18..702f216 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -364,6 +364,7 @@ export async function baueApp(o: Optionen): Promise { const daten: Record = {}; for (const t of [...TABELLEN, ...NUR_SICHERUNG]) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows; daten.benutzer = await benutzerFuerSicherung(pool); + daten.ansichten = (await pool.query("select id, anmeldename, tabelle, daten from ansicht order by anmeldename, tabelle")).rows; const stand = new Date().toISOString(); reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`); return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten }; diff --git a/src/server/ich.ts b/src/server/ich.ts index 6b3d865..992dd74 100644 --- a/src/server/ich.ts +++ b/src/server/ich.ts @@ -36,4 +36,18 @@ export function registriereIch(app: FastifyInstance, pool: Pool, einstellungen: .map(({ start: _s, dauer: _d, ...v }) => v); return { heute, bis, arbeitstage: woche.tage, einsaetze }; }); + + // Ansichten der Tabellen (Sortierung, Filter, ausgeblendete Zeilen, gespeicherte Ansichten), je Benutzer + app.get("/api/ich/ansichten", async (req) => { + const r = await pool.query("select tabelle, daten from ansicht where anmeldename = $1", [req.wer!.anmeldename]); + return Object.fromEntries(r.rows.map((z) => [z.tabelle, z.daten])); + }); + app.put("/api/ich/ansichten/:tabelle", async (req, reply) => { + const { tabelle } = z.object({ tabelle: z.string().regex(/^[a-z0-9-]{1,40}$/) }).parse(req.params); + const daten = z.record(z.string(), z.unknown()).parse(req.body); + if (JSON.stringify(daten).length > 100_000) return reply.status(413).send({ fehler: "Die Ansicht ist zu groß." }); + await pool.query(`insert into ansicht (anmeldename, tabelle, daten) values ($1, $2, $3) + on conflict (anmeldename, tabelle) do update set daten = excluded.daten, geaendert_am = now()`, [req.wer!.anmeldename, tabelle, daten]); + return reply.status(204).send(); + }); } diff --git a/src/server/migrations/011_ansichten.sql b/src/server/migrations/011_ansichten.sql new file mode 100644 index 0000000..3810148 --- /dev/null +++ b/src/server/migrations/011_ansichten.sql @@ -0,0 +1,11 @@ +-- Sortieren und Filtern wie in Excel in jeder Tabelle (Henning, 20.10.2026): je Benutzer und Tabelle die aktuelle +-- Ansicht (Sortierung, Filter, ausgeblendete Zeilen) und gespeicherte Ansichten wie „Meine Woche“. +-- Über den Anmeldenamen, damit es auch in der Testversion ohne Benutzer und nach dem Umzug auf den Server passt. +create table ansicht ( + id uuid primary key default gen_random_uuid(), + anmeldename text not null, + tabelle text not null check (tabelle ~ '^[a-z0-9-]{1,40}$'), + daten jsonb not null, + geaendert_am timestamptz not null default now(), + unique (anmeldename, tabelle) +); diff --git a/src/server/stand.ts b/src/server/stand.ts index 158d897..128441a 100644 --- a/src/server/stand.ts +++ b/src/server/stand.ts @@ -42,6 +42,7 @@ export async function speichereStand(c: Client, s: Stand): Promise[]): return zeilen.length; } +/** Ansichten der Tabellen; die zählen nicht als Daten, wer schon eine hat (Server nach der Einrichtung), bekommt die aus der Sicherung */ +async function speichereAnsichten(c: Client, zeilen: Record[]): Promise { + for (const z of zeilen) { + await c.query(`insert into ansicht (id, anmeldename, tabelle, daten) values ($1, $2, $3, $4) + on conflict (anmeldename, tabelle) do update set daten = excluded.daten`, [z.id, z.anmeldename, z.tabelle, z.daten]); + } + return zeilen.length; +} + /** Für die Sicherung: Benutzer ohne Passwort-Hash */ export async function benutzerFuerSicherung(c: { query: Client["query"] }): Promise[]> { return (await c.query("select id, anmeldename, name, rolle, kontakt_id, aktiv, angelegt_am from benutzer order by angelegt_am")).rows; diff --git a/src/web/anmeldung.ts b/src/web/anmeldung.ts index 842aab5..c234250 100644 --- a/src/web/anmeldung.ts +++ b/src/web/anmeldung.ts @@ -1,6 +1,7 @@ // U1/U2 in der Oberfläche: Anmeldeseite, Einrichtung, wer angemeldet ist, Benutzerverwaltung. -import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite, tabelle } from "./ui.js"; +import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite } from "./ui.js"; +import { liste as tabelle } from "./liste.js"; export type Rolle = "inhaber" | "buero" | "mitarbeiter"; export interface Sitzung { @@ -153,14 +154,18 @@ export async function benutzerSeite(s: Sitzung): Promise { } }; seite("Benutzer", { text: "Neuer Benutzer", aktion: () => void oeffnen(null) }); - inhalt.appendChild(tabelle([ - { titel: "Name", wert: (z) => esc(z.name) }, - { titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" }, - { titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) }, - { titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" }, - ...(testversion ? [] : [{ titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : 'fehlt') }]), - { titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : 'gesperrt') }, - ], liste, (z) => void oeffnen(z))); + inhalt.appendChild(tabelle({ + schluessel: "benutzer", einheit: ["Benutzer", "Benutzer"], + spalten: [ + { id: "name", titel: "Name", wert: (z) => esc(z.name) }, + { id: "anmeldename", titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" }, + { id: "rolle", titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) }, + { id: "kontakt", titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" }, + ...(testversion ? [] : [{ id: "passwort", titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : 'fehlt') }]), + { id: "zugang", titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : 'gesperrt') }, + ], + zeilen: liste, klick: (z) => void oeffnen(z), + })); inhalt.insertAdjacentHTML("beforeend", testversion ? `

Testversion: Passwörter gibt es erst auf dem Server. Unten links wählst du, als wer du arbeitest, und siehst so z. B. die Mitarbeiter-Ansicht.

` : `

Mitarbeiter sehen am Handy nur ihre eigenen Einsätze mit Adresse, ihre Stunden und die Ablage ihrer Projekte, keine Beträge. Das Büro sieht alles außer Löhnen, Jahresplan, BWA und dieser Seite.

`); diff --git a/src/web/app.ts b/src/web/app.ts index af3d9aa..acac2f7 100644 --- a/src/web/app.ts +++ b/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 { seite("Kontakte", { text: "Neuer Kontakt", aktion: neu }); const zeilen = await api("kontakte"); const rolle = Object.fromEntries(ROLLEN); - inhalt.appendChild(tabelle([ - { titel: "Name", wert: (z) => esc(z.name) }, - { titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" }, - { titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) }, - { titel: "Telefon", wert: (z) => (z.telefon ? `${esc(z.telefon)}` : "") }, - { titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" }, - ], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte())); + 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 ? `${esc(z.telefon)}` : "") }, + { 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 { seite("Projekte", { text: "Neues Projekt", aktion: neu }); const [zeilen, kontaktListe] = await Promise.all([api("projekte"), api("kontakte")]); const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name])); - inhalt.appendChild(tabelle([ - { titel: "Name", wert: (z) => `${esc(z.bezeichnung)}${esc(z.nummer)} · ${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}` }, - { titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" }, - { titel: "Status", wert: (z) => etikett(z.status) }, - { titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" }, - { titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" }, - { titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" }, - ], zeilen, (z) => (location.hash = `projekt-${z.id}`))); - const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0); - inhalt.insertAdjacentHTML("beforeend", `

${zeilen.length} Projekte

Rohertrag gesamt: ${euro(gesamt)}

`); + 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) => `${esc(z.bezeichnung)}${esc(z.nummer)} · ${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}` }, + { 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) => `

Rohertrag ${sichtbar.length === zeilen.length ? "gesamt" : "der gezeigten Projekte"}: ${euro(sichtbar.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0))}

`, + })); } // ---------- Projektseite (P2), aufgebaut wie bei Plancraft ---------- @@ -116,7 +128,6 @@ const kachel = (art: string, titel: string, inhaltHtml: string) => `
{ 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 { ]; ziel.querySelector('[data-a="kosten-neu"]')!.onclick = async () => (await bearbeiten("kosten", "Neue Kosten", felder, null, { projekt_id: id, art: "material", status: "geplant", termin: heute() })) && neuLaden(); - ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? tabelle([ - { titel: "Bezeichnung", wert: (k) => `${esc(k.bezeichnung)}${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}` }, - { titel: "Termin", wert: (k) => dat(k.termin) }, - { titel: "Status", wert: (k) => esc(k.status), klasse: "optional" }, - { titel: "Netto", wert: (k) => euro(k.netto), klasse: "zahl" }, - ], eigeneKosten, async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden()) : leer("Noch keine Einzelkosten.")); + 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)}${esc(kontakt[k.kontakt_id]?.name ?? "")}` }, + { 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 { } teil.append(info); if (eigeneZahlungen.length) { - teil.append(tabelle([ - { titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}` }, - { titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `nach ${esc(vorgangName(z.vorgang_id))}` : ""}` }, - { titel: "Status", wert: (z) => `${esc(z.status)}`, klasse: "optional" }, - { titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" }, - ], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden())); + teil.append(liste({ + schluessel: "projekt-zahlungen", klein: true, einheit: ["Rate", "Raten"], + spalten: [ + { id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}` }, + { id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `nach ${esc(vorgangName(z.vorgang_id))}` : ""}` }, + { id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `${esc(z.status)}`, 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", `

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

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

Offene Aufgaben ${offen}

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

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

`}`; - seite.querySelector("#pa-kategorie")!.onchange = (ev) => { f.kategorie = (ev.target as HTMLSelectElement).value; zeigeAufgaben(); }; - seite.querySelector("#pa-erledigte")!.onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; zeigeAufgaben(); }; + seite.innerHTML = `

Offene Aufgaben ${offen}

`; + seite.append(aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true)); }; zeigeOben(); @@ -376,7 +384,8 @@ async function projektSeite(id: string): Promise { } async function terminplan(): Promise { - 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 { let liquiOffen = new Set(); async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise { const leiste = seite("Liquidität"); - leiste.innerHTML = ` + leiste.innerHTML = ` - `; + ${ansicht === "liste" ? "" : ''}`; 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(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api("projekte"), api("einstellungen"), ]); @@ -426,8 +438,31 @@ async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise { }).join("")}
`); } - // 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)}${esc(x.gruppe)}` }, + { 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) => `${euro(x.betrag)}`, sortWert: (x) => x.betrag, klasse: "zahl" }, + { id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `${euro(x.stand)}`, sortWert: (x) => x.stand, klasse: "zahl optional" }, + ], + zeilen: posten, + fuss: (l) => (l.length === posten.length ? "" : `

Summe der gezeigten Zahlungen: ${euro(l.reduce((s, x) => s + x.betrag, 0))}

`), + })); + 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 `${dat(x.datum)}${esc(x.bezeichnung)}${esc(x.gruppe)} @@ -470,13 +505,19 @@ async function laufendeKosten(): Promise { seite("Laufende Kosten", { text: "Neue Position", aktion: neu }); const zeilen = await api("laufende-kosten"); const r = Object.fromEntries(RHYTHMEN); - inhalt.appendChild(tabelle([ - { titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) }, - { titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" }, - { titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" }, - ], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten())); - const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0); - inhalt.insertAdjacentHTML("beforeend", `

Monatlich: ${euro(monat)}

`); + 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) => `

Monatlich${sichtbar.length === zeilen.length ? "" : " (gezeigte Positionen)"}: ${euro(monatlich(sichtbar))}

`, + })); } // G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar @@ -558,18 +599,38 @@ async function neueAufgabe(vorgaben: Zeile = {}): Promise { return bearbeiten("aufgaben", "Neue Aufgabe", (await aufgabenDaten()).felder, null, vorgaben); } -function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLTableElement { +// 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) => `` }, - { titel: "Aufgabe", wert: (z) => `${z.erledigt_am ? `${esc(z.text)}` : esc(z.text)}${zuordnung(z) ? `${zuordnung(z)}` : ""}` }, - { titel: "Kategorie", wert: (z) => (z.kategorie_id ? `${esc(namen.kategorie[z.kategorie_id])}` : "") }, - { titel: "Fällig", wert: (z) => `${dat(z.faellig_am)}` }, - ], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden()); - t.classList.add("aufgaben-tabelle"); + 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: '✓', text: (z) => (z.erledigt_am ? "erledigt" : "offen"), + wert: (z) => `` }, + { id: "text", titel: "Aufgabe", text: (z) => z.text, + wert: (z) => `${z.erledigt_am ? `${esc(z.text)}` : esc(z.text)}${zuordnung(z) ? `${zuordnung(z)}` : ""}` }, + ...(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 ? `${esc(namen.kategorie[z.kategorie_id])}` : "") }, + { id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig_am, + wert: (z) => `${dat(z.faellig_am)}` }, + ], + 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 { const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() }); const [d, alle] = await Promise.all([aufgabenDaten(), api("aufgaben")]); - const f = aufgabenFilter; - if (f.kategorie && f.kategorie !== "ohne" && !d.namen.kategorie[f.kategorie]) f.kategorie = ""; - leiste.innerHTML = ` - - `; - const kat = leiste.querySelector("#a-kategorie") as HTMLSelectElement; - bearbeitbareAuswahl(kat, KATEGORIEN_BEARBEITEN, () => { f.kategorie = kat.value; aufgaben(); }); - (leiste.querySelector("#a-projekt") as HTMLSelectElement).onchange = (ev) => { f.projekt = (ev.target as HTMLSelectElement).value; aufgaben(); }; - (leiste.querySelector("#a-erledigte") as HTMLInputElement).onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; aufgaben(); }; - const passt = (wert: string | null, filter: string) => !filter || (filter === "ohne" ? !wert : wert === filter); - const zeilen = alle.filter((a) => (f.erledigte || !a.erledigt_am) && passt(a.kategorie_id, f.kategorie) && passt(a.projekt_id, f.projekt)); - inhalt.appendChild(aufgabenTabelle(zeilen, d.namen, d.felder, aufgaben)); - inhalt.insertAdjacentHTML("beforeend", `

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

`); + leiste.innerHTML = ''; + leiste.querySelector('[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 { REITER = reiterFuer(s); nav.innerHTML = REITER.map(([id, titel]) => ``).join(""); werLeiste(s); + await ansichtenLaden(); window.addEventListener("hashchange", zeige); await zeige(); } diff --git a/src/web/gantt.ts b/src/web/gantt.ts index cc3ef0d..655b0db 100644 --- a/src/web/gantt.ts +++ b/src/web/gantt.ts @@ -18,7 +18,17 @@ export interface Hilfen { esc(v: unknown): string; seite(titel: string): HTMLElement; inhalt: HTMLElement; + /** Filtermenü und gespeicherte Ansicht wie in den Tabellen (liste.ts) */ + filterMenue(anker: HTMLElement, o: { titel: string; werte: FilterWert[]; aus: string[]; fertig: (aus: string[]) => void }): void; + filterText(werte: FilterWert[], aus: string[]): string; + ansicht: { lies(schluessel: string): GanttAnsicht; setze(schluessel: string, a: GanttAnsicht): void }; + auge: [string, string]; } +interface FilterWert { wert: string; text: string; anzahl: number } +interface GanttAnsicht { sort: [string, "auf" | "ab"][]; filter: Record; zeit: Record; aus: string[] } +/** Ausgeblendete Zeilen gerade zeigen (bis zum Neuladen der Seite) */ +let ausZeigen = false; +const OHNE = "(ohne Besetzung)"; interface Plan { projekte: Zeile[]; @@ -35,7 +45,7 @@ interface Plan { } const ZOOM: Record = { tag: 24, woche: 10, monat: 4 }; -// Zoom wie in MS Project: − und + oder Ziehen an der Zeitskala (Regler auf Hennings Wunsch entfernt) (Henning, 20.10.2026), Pixel je Tag +// Zoom wie in MS Project: Ziehen an der Zeitskala; Regler und −/+ auf Hennings Wunsch entfernt (Henning, 20.10.2026), Pixel je Tag const ZOOM_MIN = 2, ZOOM_MAX = 48; const zoomGrenzen = (w: number) => Math.round(Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, w)) * 10) / 10; /** Welcher Tag beim Zoomen an welcher Stelle (Pixel ab dem Zeitbereich) stehen bleibt */ @@ -116,27 +126,47 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise(); for (const k of plan.leute) personen.set(k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name); for (const b of plan.besetzungen) { const w = wer(b); if (w && !personen.has(w)) personen.set(w, b.anzeige); } - let filter = merke("gantt-person") ?? ""; - if (filter && !personen.has(filter)) filter = ""; - const passt = (v: Zeile) => !filter || plan.besetzungen.some((b) => b.vorgang_id === v.id && wer(b) === filter); + // Filtern und Ausblenden wie in den Tabellen; die Reihenfolge bleibt die gezogene (Henning, 20.10.2026) + const ansicht = h.ansicht.lies("terminplan"); + const personAus = ansicht.filter.person ?? [], projektAus = ansicht.filter.projekt ?? []; + const ausgeblendet = new Set(ansicht.aus); + const filter = personAus.length > 0; + const passt = (v: Zeile) => { + if (!filter) return true; + const leute = plan.besetzungen.filter((b) => b.vorgang_id === v.id).map(wer); + return leute.length ? leute.some((p) => p && !personAus.includes(p)) : !personAus.includes(OHNE); + }; + const sichtbarZeile = (id: string) => ausZeigen || !ausgeblendet.has(id); + const setzeAnsicht = (neu: Partial) => { h.ansicht.setze("terminplan", { ...ansicht, ...neu }); void terminplanSeite(h, plan); }; + + const projekteAlle = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen"); + const personWerte: FilterWert[] = [...[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => ({ wert: id, text: name, anzahl: new Set(plan.besetzungen.filter((b) => wer(b) === id).map((b) => b.vorgang_id)).size })), + { wert: OHNE, text: OHNE, anzahl: plan.vorgaenge.filter((v) => !plan.besetzungen.some((b) => b.vorgang_id === v.id)).length }]; + const projektWerte: FilterWert[] = projekteAlle.map((p) => ({ wert: p.id, text: `${p.nummer} ${p.bezeichnung}`, anzahl: 0 })); + const filterWerte: Record = { person: personWerte, projekt: projektWerte }; + const filterKnopf = (id: string, titel: string, aus: string[]) => aus.length + ? `` + : ``; + const alleIds = new Set([...plan.projekte, ...plan.abschnitte, ...plan.vorgaenge].map((x) => x.id as string)); + const anzahlAus = ansicht.aus.filter((id) => alleIds.has(id)).length; leiste.innerHTML = `${Object.keys(ZOOM).map((z) => ``).join("")} - - + ${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("person", "Personal", personAus)} + ${anzahlAus ? `${anzahlAus} ausgeblendet · ${ausZeigen ? ' · ' : ""}` : ""} In eine Zelle klicken zum Bearbeiten: Enter speichert und geht eine Zeile tiefer, Tab eine Spalte weiter, Esc bricht ab. Zeile an der Nummer anfassen und verschieben. Spaltenbreite am Spaltenkopf ziehen, die Trennleiste blendet Spalten aus, an der Zeitskala ziehen zoomt. Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve. `; - const projekte = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen"); + const projekte = projekteAlle.filter((p) => !projektAus.includes(p.id)); const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]); // Zeilennummern wie die Nr. in MS Project (Henning, 20.10.2026): fortlaufend über Projekte, Abschnitte - // und Vorgänge; Zuklappen und der Personenfilter ändern sie nicht, Verschieben schon. + // und Vorgänge; Zuklappen, Filter und Ausblenden ändern sie nicht, Verschieben schon. // Ausgeblendete abgeschlossene Projekte zählen hinten weiter, damit Verknüpfungen dorthin lesbar bleiben. const zeilenNr = new Map(); let zaehler = 0; - for (const p of [...projekte, ...plan.projekte.filter((p) => !projekte.includes(p))]) { + for (const p of [...projekteAlle, ...plan.projekte.filter((p) => !projekteAlle.includes(p))]) { zeilenNr.set(p.id, ++zaehler); for (const a of plan.abschnitte.filter((a) => a.projekt_id === p.id)) { zeilenNr.set(a.id, ++zaehler); @@ -185,15 +215,17 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise a.projekt_id === p.id); const vs = plan.vorgaenge.filter((v) => abs.some((a) => a.id === v.abschnitt_id) && passt(v)); if (filter && !vs.length) return; + if (!sichtbarZeile(p.id)) return; const spanne = (l: Zeile[]) => (l.length ? { von: l.reduce((m, v) => (v.anfang < m ? v.anfang : m), l[0]!.anfang), bis: l.reduce((m, v) => (v.ende > m ? v.ende : m), l[0]!.ende) } : {}); reihen.push({ art: "p", obj: p, projekt: p, farbe: f, ...spanne(vs) }); if (zu.has(p.id)) return; for (const a of abs) { const av = vs.filter((v) => v.abschnitt_id === a.id); if (filter && !av.length) continue; + if (!sichtbarZeile(a.id)) continue; reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) }); if (zu.has(a.id)) continue; - for (const v of av) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende }); + for (const v of av) if (sichtbarZeile(v.id)) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende }); } }); const zeileVon = new Map(); @@ -258,7 +290,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise z.projekt_id === o.id); links = `${nr}${klapp}${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` ${esc(o.bauherr)}` : ""} - + ${dauerZelle()}${datumZelle(r.von)}${datumZelle(r.bis)} ${raten.length ? `` : Number(o.umsatz_netto) > 0 && o.zahlungsplan === "fest" @@ -269,7 +301,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise `
€
`).join(""); } else if (r.art === "a") { links = `${nr}${klapp}${esc(o.name)} - +
${dauerZelle()}${datumZelle(r.von)}${datumZelle(r.bis)}`; if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, esc(o.name), r.von, r.bis); } else { @@ -277,7 +309,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise `${inhaltHtml}`; links = `${nr}${zelle("name", "text", esc(o.name), "Bezeichnung")} - + ${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)) + dauerHinweis(o), dauerTitel(o))} ${zelle("vg", "vg", esc(vorgaengerText(linksVon(o.id), zeilenNr)), "Vorgänger: Zeilennummer, z. B. 5 oder 5AA+2")} ${zelle("start", "zahl", tabellenDatum(o.anfang), "Anfang")}${zelle("ende", "zahl", tabellenDatum(o.ende), "Ende")} @@ -290,14 +322,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise${reduziertHtml(o, links0)}` + beschriftung(links0, links0 + breite, esc(o.name), o.anfang, o.ende, leute); } - return `
+ return `
${balken}
`; }).join(""); // T16: Auslastung des eigenen Teams je Woche unter dem Plan; mit Personenfilter nur diese Person const team = plan.team ?? []; const nameVon = new Map(plan.leute.map((k) => [k.id, k.name])); - const nurPerson = filter && team.includes(filter) ? filter : ""; + const gezeigtePersonen = [...personen.keys()].filter((p) => !personAus.includes(p)); + const nurPerson = filter && gezeigtePersonen.length === 1 && team.includes(gezeigtePersonen[0]!) ? gezeigtePersonen[0]! : ""; const auslastungHtml = team.length && reihen.length ? (() => { const std = (n: number) => zahlText(Math.round(n * 10) / 10); const bloecke = (plan.auslastung ?? []).filter((w) => w.ab >= von && w.ab <= bis).map((w) => { @@ -342,7 +375,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise${pfeile} ${zeilenHtml}${auslastungHtml} - ${reihen.length ? "" : '

Noch keine Projekte im Terminplan.

'} + ${reihen.length ? "" : `

${filter || projektAus.length || anzahlAus ? "Nichts passt zu den Filtern. Oben unter Projekte und Personal lassen sie sich wieder entfernen." : "Noch keine Projekte im Terminplan."}

`} `; const box = rahmen.querySelector(".gantt")!; if (plan.ueberschneidungen.length) { @@ -440,9 +473,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise { const b = (ev.target as HTMLElement).closest("button"); if (b?.dataset.zoom) zoome(ZOOM[b.dataset.zoom]!); - if (b?.dataset.a === "kleiner") zoome(W / 1.4); - if (b?.dataset.a === "groesser") zoome(W * 1.4); if (b?.dataset.a === "heute") nachHeute(); + if (b?.dataset.filter) { + const id = b.dataset.filter; + h.filterMenue(b, { titel: id === "person" ? "Personal" : "Projekte", werte: filterWerte[id]!, aus: ansicht.filter[id] ?? [], + fertig: (aus) => setzeAnsicht({ filter: { ...ansicht.filter, [id]: aus } }) }); + } + if (b?.dataset.filterWeg) setzeAnsicht({ filter: { ...ansicht.filter, [b.dataset.filterWeg]: [] } }); + if (b?.dataset.a === "aus-zeigen") { ausZeigen = !ausZeigen; void terminplanSeite(h, plan); } + if (b?.dataset.a === "alle-ein") { ausZeigen = false; setzeAnsicht({ aus: ansicht.aus.filter((id) => !alleIds.has(id)) }); } }); // an der Zeitskala ziehen: nach rechts größer, nach links kleiner box.querySelector(".g-zeit")!.addEventListener("pointerdown", (ev) => { @@ -465,12 +504,16 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise('[data-a="person"]')!.onchange = (ev) => { merke("gantt-person", (ev.target as HTMLSelectElement).value); neuLaden(); }; leiste.querySelector('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); }; // Klicks in der linken Spalte box.addEventListener("click", async (ev) => { const t = ev.target as HTMLElement; + const auge = t.closest("[data-ausblenden]"); + if (auge) { + const id = auge.dataset.ausblenden!; + return setzeAnsicht({ aus: ausgeblendet.has(id) ? ansicht.aus.filter((x) => x !== id) : [...ansicht.aus, id] }); + } if (t.dataset.klapp) { zu.has(t.dataset.klapp) ? zu.delete(t.dataset.klapp) : zu.add(t.dataset.klapp); merke("gantt-zu", [...zu]); diff --git a/src/web/liste.ts b/src/web/liste.ts new file mode 100644 index 0000000..39e9381 --- /dev/null +++ b/src/web/liste.ts @@ -0,0 +1,393 @@ +// Tabellen mit Sortieren und Filtern wie in Excel (Henning, 20.10.2026), überall gleich: +// Spaltenkopf anklicken öffnet das Menü (sortieren, als weitere Sortierung, suchen, Werte abhaken, bei Datum Zeiträume), +// oben stehen Sortierung und Filter als Chips, das Auge blendet einzelne Zeilen aus, Ansichten lassen sich speichern. +// Die Ansicht merkt sich das Programm je Benutzer auf dem Server, damit sie am Handy und im Büro gleich ist. + +import { type Ansicht, type Richtung, type SpaltenWerte, LEER, ZEITRAEUME, ZEITRAUM_TEXT, ansichtAus, gleich, leereAnsicht, monatText, monatVon, passt, sortiere } from "../domain/ansicht.js"; +import { type Zeile, api, dialog, esc, heute } from "./ui.js"; + +export interface Spalte { + /** fester Schlüssel, unter dem Filter und Sortierung gespeichert werden */ + id: string; + titel: string; + wert: (z: Zeile) => string; + klasse?: string; + art?: "text" | "zahl" | "datum"; + /** Wert für Filterliste und Suche; Standard ist der angezeigte Text */ + text?: (z: Zeile) => string; + /** Wert zum Sortieren; bei Datum das ISO-Datum, bei Zahlen die Zahl */ + sortWert?: (z: Zeile) => string | number | null | undefined; + /** Kopf statt des Titels, z. B. ein Haken */ + kopf?: string; + /** ohne Sortieren und Filtern */ + fest?: boolean; +} + +export interface ListenOptionen { + /** Name der Tabelle für die gespeicherte Ansicht, z. B. „aufgaben“ */ + schluessel: string; + spalten: Spalte[]; + zeilen: Zeile[]; + klick?: (z: Zeile) => void; + /** Ansicht, solange der Benutzer nichts geändert hat (und nach „Zurücksetzen“) */ + vorgabe?: Partial; + /** fertige Ansichten, z. B. „Meine Woche“ */ + vorlagen?: { name: string; ansicht: Partial }[]; + /** für die Zeile unter der Tabelle: [Einzahl, Mehrzahl] */ + einheit?: [string, string]; + /** zusätzlicher Text unter der Tabelle, aus den sichtbaren Zeilen (z. B. eine Summe) */ + fuss?: (sichtbar: Zeile[]) => string; + /** eingebettete Tabelle: Leiste nur bei aktiven Filtern, ohne gespeicherte Ansichten */ + klein?: boolean; + zeilenKlasse?: (z: Zeile) => string; + /** Text, wenn es gar keine Zeilen gibt */ + leer?: string; + klasse?: string; +} + +interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[] } + +let speicher: Record = {}; +const warten = new Map>(); + +/** Beim Start und nach einem Benutzerwechsel: die Ansichten des Benutzers holen */ +export async function ansichtenLaden(): Promise { + try { speicher = await api>("ich/ansichten"); } catch { speicher = {}; } +} + +function merken(schluessel: string): void { + clearTimeout(warten.get(schluessel)); + warten.set(schluessel, setTimeout(() => { + warten.delete(schluessel); + api(`ich/ansichten/${schluessel}`, "PUT", speicher[schluessel]).catch(() => { /* bleibt bis zum Neuladen erhalten */ }); + }, 500)); +} + +/** Für Seiten ohne Tabelle (Terminplan): die aktuelle Ansicht lesen und merken */ +export function gespeicherteAnsicht(schluessel: string): Ansicht { + const g = speicher[schluessel]; + return g?.aktuell ? ansichtAus(g.aktuell) : leereAnsicht(); +} +export function ansichtMerken(schluessel: string, a: Ansicht): void { + (speicher[schluessel] ??= {}).aktuell = { ...a, aus: a.aus.slice(-1000) }; + merken(schluessel); +} + +export const AUGE = ''; +export const AUGE_ZU = ''; +const TRICHTER = ''; + +const SORT_TEXT: Record = { + text: ["Von A bis Z sortieren", "Von Z bis A sortieren"], + zahl: ["Nach Größe sortieren (aufsteigend)", "Nach Größe sortieren (absteigend)"], + datum: ["Vom ältesten zum neuesten sortieren", "Vom neuesten zum ältesten sortieren"], +}; + +/** Offenes Menü (Spaltenfilter oder Ansichten); es gibt immer höchstens eins */ +let offenesMenue: { schliessen: () => void } | null = null; +addEventListener("hashchange", () => offenesMenue?.schliessen()); + +/** Ein schwebendes Menü an einem Knopf; am Handy als Blatt von unten */ +export function menue(anker: HTMLElement, html: string, klasse = ""): HTMLElement { + offenesMenue?.schliessen(); + const m = document.createElement("div"); + m.className = `filter-menue ${klasse}`; + m.setAttribute("role", "dialog"); + m.innerHTML = html; + document.body.appendChild(m); + const r = anker.getBoundingClientRect(); + if (innerWidth > 640) { + const breite = m.offsetWidth; + m.style.left = `${Math.max(8, Math.min(r.left, innerWidth - breite - 8))}px`; + const unten = r.bottom + 4; + m.style.top = `${unten + m.offsetHeight > innerHeight - 8 ? Math.max(8, r.top - m.offsetHeight - 4) : unten}px`; + } else m.classList.add("blatt"); + const aussen = (ev: PointerEvent) => { if (!m.contains(ev.target as Node) && !anker.contains(ev.target as Node)) schliessen(); }; + const taste = (ev: KeyboardEvent) => { if (ev.key === "Escape") schliessen(); }; + const schliessen = () => { + m.remove(); + removeEventListener("pointerdown", aussen, true); + removeEventListener("keydown", taste); + if (offenesMenue?.schliessen === schliessen) offenesMenue = null; + }; + addEventListener("pointerdown", aussen, true); + addEventListener("keydown", taste); + offenesMenue = { schliessen }; + return m; +} +export const menueSchliessen = () => offenesMenue?.schliessen(); + +export interface FilterWert { wert: string; text: string; anzahl: number } + +/** + * Das Filtermenü einer Spalte wie in Excel: Sortieren (wenn `sortieren`), Zeitraum (wenn `zeit`), Suche und Werte mit Haken. + * Meldet über `fertig` die abgewählten Werte und den Zeitraum. + */ +export function filterMenue(anker: HTMLElement, o: { + titel: string; art?: Spalte["art"]; werte: FilterWert[]; aus: string[]; zeit?: string | null; + sortiert?: Richtung | null; weitereSortierung?: boolean; sortieren?: (r: Richtung | null, dazu: boolean) => void; + fertig: (aus: string[], zeit: string) => void; +}): void { + const [auf, ab] = SORT_TEXT[o.art ?? "text"]!; + const aktiv = o.aus.length > 0 || !!o.zeit; + const m = menue(anker, `
${esc(o.titel)}
+ ${o.sortieren ? ` + + ${o.weitereSortierung ? `
+ als weitere Sortierung
` : ""} + ${o.sortiert ? '' : ""}
` : ""} + + ${o.art === "datum" ? `` : ""} + +
+ ${o.werte.map((w, i) => ``).join("")} + ${o.werte.length ? "" : '

Keine Werte.

'}
+
`); + const suche = m.querySelector(".fm-suche")!; + const kasten = (i: number) => m.querySelector(`[data-w="${i}"]`)!; + const alle = m.querySelector('[data-m="alle"]')!; + const ok = m.querySelector('[data-m="ok"]')!; + const sichtbar = () => o.werte.map((_, i) => i).filter((i) => !m.querySelector(`label[data-i="${i}"]`)!.hidden); + const stand = () => { + const s = sichtbar(), an = s.filter((i) => kasten(i).checked).length; + alle.checked = s.length > 0 && an === s.length; + alle.indeterminate = an > 0 && an < s.length; + ok.disabled = an === 0 && o.werte.length > 0; + }; + suche.oninput = () => { + const q = suche.value.trim().toLocaleLowerCase("de"); + o.werte.forEach((w, i) => { m.querySelector(`label[data-i="${i}"]`)!.hidden = !!q && !w.text.toLocaleLowerCase("de").includes(q); }); + m.querySelector(".fm-alle span")!.textContent = q ? "(Alle Suchergebnisse auswählen)" : "(Alles auswählen)"; + stand(); + }; + m.addEventListener("change", (ev) => { + if (ev.target === alle) for (const i of sichtbar()) kasten(i).checked = alle.checked; + stand(); + }); + stand(); + if (innerWidth > 640) suche.focus(); + m.addEventListener("click", (ev) => { + const b = (ev.target as HTMLElement).closest("[data-m]"); + const was = b?.dataset.m; + if (!was || b instanceof HTMLInputElement || b instanceof HTMLSelectElement) return; + if (was === "zu") return menueSchliessen(); + if (["auf", "ab", "dazu-auf", "dazu-ab", "sort-weg"].includes(was)) { + menueSchliessen(); + return o.sortieren?.(was === "sort-weg" ? null : was.endsWith("ab") ? "ab" : "auf", was.startsWith("dazu")); + } + if (was === "filter-weg") { menueSchliessen(); return o.fertig([], ""); } + if (was === "ok") { + // wie Excel: mit Suchbegriff gilt nur, was gefunden und abgehakt ist + const s = new Set(sichtbar()); + const aus = o.werte.filter((w, i) => !(s.has(i) && kasten(i).checked)).map((w) => w.wert); + const zeit = m.querySelector('[data-m="zeit"]')?.value ?? ""; + menueSchliessen(); + o.fertig(aus, zeit); + } + }); +} + +/** Text eines Filters für den Chip: „Kategorie: Büro, Einkauf“ oder „Kategorie: ohne Büro“ */ +export function filterText(alleWerte: FilterWert[], aus: string[], zeit?: string | null): string { + const teile: string[] = []; + if (zeit) teile.push(ZEITRAUM_TEXT[zeit] ?? zeit); + if (aus.length) { + const text = (w: string) => alleWerte.find((x) => x.wert === w)?.text ?? w; + const an = alleWerte.filter((w) => !aus.includes(w.wert)); + const liste = (l: string[]) => (l.length > 3 ? `${l.slice(0, 3).join(", ")} +${l.length - 3}` : l.join(", ")); + teile.push(an.length && an.length <= aus.length ? liste(an.map((w) => w.text)) : `ohne ${liste(aus.map(text))}`); + } + return teile.join(", "); +} + +/** Eine Tabelle mit Sortieren, Filtern, Ausblenden und Ansichten */ +export function liste(o: ListenOptionen): HTMLElement { + const wurzel = document.createElement("div"); + wurzel.className = `liste${o.klein ? " klein" : ""}`; + const g = (speicher[o.schluessel] ??= {}); + const vorgabe = ansichtAus({ ...leereAnsicht(), ...o.vorgabe }); + const vorlagen = (o.vorlagen ?? []).map((v) => ({ name: v.name, ansicht: ansichtAus({ ...leereAnsicht(), ...v.ansicht }) })); + const basis = (name: string | null | undefined): Ansicht => { + const s = g.ansichten?.find((x) => x.name === name); + return s ? ansichtAus(s.ansicht) : vorlagen.find((x) => x.name === name)?.ansicht ?? vorgabe; + }; + let name: string | null = g.name && (g.ansichten?.some((x) => x.name === g.name) || vorlagen.some((x) => x.name === g.name)) ? g.name : null; + let a: Ansicht = g.aktuell ? ansichtAus(g.aktuell) : basis(name); + let zeigeAus = false; + const setze = (neu: Ansicht, neuerName = name) => { + a = { ...neu, aus: neu.aus.slice(-1000) }; + name = neuerName; + Object.assign(g, { aktuell: a, name }); + merken(o.schluessel); + zeichne(); + }; + + // Werte jeder Spalte einmal ausrechnen + const z = o.zeilen; + const ids = z.map((x, i) => String(x.id ?? i)); + const tmp = document.createElement("div"); + const klartext = (html: string) => { tmp.innerHTML = html; return (tmp.textContent ?? "").replace(/\s+/g, " ").trim(); }; + const beweglich = o.spalten.filter((s) => !s.fest); + const sw: SpaltenWerte[] = beweglich.map((s) => { + const sortWerte = z.map((x) => (s.sortWert ? s.sortWert(x) : undefined)); + const werte = z.map((x, i) => (s.art === "datum" ? monatVon(sortWerte[i] as string | null) : (s.text ? s.text(x) : klartext(s.wert(x))) || LEER)); + return { id: s.id, art: s.art, wert: (i) => werte[i]!, sort: (i) => (s.sortWert ? sortWerte[i] : werte[i] === LEER ? null : werte[i]) }; + }); + const spalte = (id: string) => beweglich.find((s) => s.id === id)!; + const werteVon = (id: string): FilterWert[] => { + const s = sw.find((x) => x.id === id)!; + const h = heute(); + const n = new Map(); + z.forEach((_, i) => { if (passt(i, a, sw, h, id)) n.set(s.wert(i), (n.get(s.wert(i)) ?? 0) + 1); }); + for (const w of a.filter[id] ?? []) if (!n.has(w)) n.set(w, 0); + const erster = new Map(); + z.forEach((_, i) => { if (!erster.has(s.wert(i))) erster.set(s.wert(i), i); }); + return [...n].map(([wert, anzahl]) => ({ wert, anzahl, text: s.art === "datum" ? monatText(wert) : wert })) + .sort((x, y) => (x.wert === LEER ? 1 : y.wert === LEER ? -1 : s.art === "datum" ? (x.wert < y.wert ? -1 : 1) + : s.art === "zahl" && erster.has(x.wert) && erster.has(y.wert) ? Number(s.sort(erster.get(x.wert)!)) - Number(s.sort(erster.get(y.wert)!)) + : x.text.localeCompare(y.text, "de", { numeric: true }))); + }; + const alleWerte = (id: string) => { + const s = sw.find((x) => x.id === id)!; + return [...new Set(z.map((_, i) => s.wert(i)))].map((w) => ({ wert: w, text: s.art === "datum" ? monatText(w) : w, anzahl: 0 })); + }; + + function zeichne(): void { + const h = heute(); + const ausSet = new Set(a.aus); + const gefiltert = z.map((_, i) => i).filter((i) => passt(i, a, sw, h)); + const versteckt = gefiltert.filter((i) => ausSet.has(ids[i]!)); + const zeigen = sortiere(zeigeAus ? gefiltert : gefiltert.filter((i) => !ausSet.has(ids[i]!)), a.sort, sw); + const filterIds = beweglich.map((s) => s.id).filter((id) => a.filter[id]?.length || a.zeit[id]); + const geaendert = !gleich(a, basis(name)); + + const sortChip = a.sort.length ? `Sortiert: ${a.sort.map(([id, r], n) => `${a.sort.length > 1 ? `${n + 1}. ` : ""}${esc(spalte(id)?.titel ?? id)} ${r === "auf" ? "↑" : "↓"}`).join(" · ")}` : ""; + const chips = filterIds.map((id) => ``).join(""); + const leisteZeigen = !o.klein || filterIds.length || (a.sort.length && !gleich({ ...a, filter: {}, zeit: {}, aus: [] }, { ...vorgabe, filter: {}, zeit: {}, aus: [] })); + const leiste = leisteZeigen ? `
+ ${o.klein ? "" : ``} + ${o.klein ? "" : ''} + ${sortChip}${chips} + ${geaendert ? '' : ""}
` : ""; + + const kopf = o.spalten.map((s) => { + if (s.fest) return `${s.kopf ?? esc(s.titel)}`; + const nr = a.sort.findIndex(([id]) => id === s.id); + const r = nr >= 0 ? a.sort[nr]![1] : null; + const gefiltertHier = filterIds.includes(s.id); + return ` + `; + }).join(""); + const zeile = (i: number) => { + const x = z[i]!, weg = ausSet.has(ids[i]!); + return `${o.spalten.map((s) => `${s.wert(x)}`).join("")} + `; + }; + const breite = o.spalten.length + 1; + const rumpf = !z.length ? `${esc(o.leer ?? "Noch nichts eingetragen.")}` + : !zeigen.length ? `${versteckt.length ? "Alle passenden Zeilen sind ausgeblendet." : "Nichts passt zu den Filtern."} ` + : zeigen.map(zeile).join(""); + const [eins, mehr] = o.einheit ?? ["Eintrag", "Einträge"]; + const sichtbar = zeigen.length; + const anzahl = !z.length ? "" : `${sichtbar === z.length ? `${z.length} ${z.length === 1 ? eins : mehr}` : `${sichtbar} von ${z.length} ${z.length === 1 ? eins : mehr}`}${versteckt.length + ? ` · ${versteckt.length} ausgeblendet · ${zeigeAus ? ' · ' : ""}` : ""}`; + wurzel.innerHTML = `${leiste}
${kopf}${rumpf}
+ ${anzahl && (!o.klein || sichtbar !== z.length || versteckt.length) ? `

${anzahl}

` : ""}${o.fuss ? o.fuss(zeigen.filter((i) => !ausSet.has(ids[i]!)).map((i) => z[i]!)) : ""}`; + } + + function spaltenMenue(id: string, anker: HTMLElement): void { + const s = spalte(id); + const nr = a.sort.findIndex(([x]) => x === id); + filterMenue(anker, { + titel: s.titel, art: s.art, werte: werteVon(id), aus: a.filter[id] ?? [], zeit: a.zeit[id], + sortiert: nr >= 0 ? a.sort[nr]![1] : null, weitereSortierung: a.sort.some(([x]) => x !== id), + sortieren: (r, dazu) => { + const ohne = a.sort.filter(([x]) => x !== id); + setze({ ...a, sort: r === null ? ohne : dazu ? [...ohne, [id, r]] : [[id, r]] }); + }, + fertig: (aus, zeit) => { + const filter = { ...a.filter }, zeiten = { ...a.zeit }; + if (aus.length) filter[id] = aus; else delete filter[id]; + if (zeit) zeiten[id] = zeit; else delete zeiten[id]; + setze({ ...a, filter, zeit: zeiten }); + }, + }); + } + + function ansichtenMenue(anker: HTMLElement): void { + const eigene = g.ansichten ?? []; + const geaendert = !gleich(a, basis(name)); + const eintrag = (n: string | null, text: string) => ``; + const m = menue(anker, `
Ansichten
+ ${eintrag(null, "Standard")}${vorlagen.filter((v) => !eigene.some((e) => e.name === v.name)).map((v) => eintrag(v.name, v.name)).join("")}${eigene.map((v) => eintrag(v.name, v.name)).join("")}
+ + ${name && eigene.some((e) => e.name === name) && geaendert ? `` : ""} + ${name && eigene.some((e) => e.name === name) ? `` : ""} +

Eine Ansicht merkt sich Sortierung, Filter und ausgeblendete Zeilen.

`, "ansichten-menue"); + m.addEventListener("click", async (ev) => { + const b = (ev.target as HTMLElement).closest("[data-v],[data-m]"); + if (!b) return; + if (b.dataset.v !== undefined) { menueSchliessen(); return setze(basis(b.dataset.v || null), b.dataset.v || null); } + const was = b.dataset.m; + menueSchliessen(); + if (was === "neu") { + const r = await dialog("Ansicht speichern", [{ name: "name", titel: "Name der Ansicht", pflicht: true, hilfe: "z. B. Meine Woche" }], {}, false); + if (r?.aktion !== "speichern") return; + const n = String(r.daten.name).slice(0, 40); + g.ansichten = [...eigene.filter((e) => e.name !== n), { name: n, ansicht: a }]; + setze(a, n); + } else if (was === "ueber" && name) { + g.ansichten = eigene.map((e) => (e.name === name ? { name, ansicht: a } : e)); + setze(a, name); + } else if (was === "weg" && name) { + g.ansichten = eigene.filter((e) => e.name !== name); + setze(a, vorlagen.some((v) => v.name === name) ? name : null); + } + }); + } + + function spaltenAuswahl(anker: HTMLElement): void { + const m = menue(anker, `
Sortieren und filtern nach
+ ${beweglich.map((s) => ``).join("")}`); + m.addEventListener("click", (ev) => { + const b = (ev.target as HTMLElement).closest("[data-s],[data-m]"); + if (b?.dataset.m === "zu") return menueSchliessen(); + if (b?.dataset.s) spaltenMenue(b.dataset.s, anker); + }); + } + + wurzel.addEventListener("click", (ev) => { + const t = ev.target as HTMLElement; + const knopf = t.closest("[data-menue],[data-aus],[data-chip-weg],[data-a]"); + if (knopf && wurzel.contains(knopf)) { + ev.stopPropagation(); + if (knopf.dataset.menue) return spaltenMenue(knopf.dataset.menue, knopf); + if (knopf.dataset.aus) { + const id = knopf.dataset.aus; + return setze({ ...a, aus: a.aus.includes(id) ? a.aus.filter((x) => x !== id) : [...a.aus, id] }); + } + if (knopf.dataset.chipWeg) { + const filter = { ...a.filter }, zeit = { ...a.zeit }; + delete filter[knopf.dataset.chipWeg]; + delete zeit[knopf.dataset.chipWeg]; + return setze({ ...a, filter, zeit }); + } + switch (knopf.dataset.a) { + case "sort-weg": return setze({ ...a, sort: [] }); + case "zuruecksetzen": zeigeAus = false; return setze(basis(name)); + case "filter-alle-weg": return setze({ ...a, filter: {}, zeit: {} }); + case "aus-zeigen": zeigeAus = !zeigeAus; return zeichne(); + case "alle-ein": zeigeAus = false; return setze({ ...a, aus: a.aus.filter((x) => !ids.includes(x)) }); + case "ansichten": return ansichtenMenue(knopf); + case "spalten": return spaltenAuswahl(knopf); + } + return; + } + // Zeile anklicken öffnet sie; Links, Knöpfe und Eingaben in der Zeile behalten ihre eigene Wirkung + if (!o.klick || t.closest("a,button,input,select,label,textarea")) return; + const tr = t.closest("tr[data-i]"); + if (tr && wurzel.contains(tr)) o.klick(z[Number(tr.dataset.i)]!); + }); + + zeichne(); + return wurzel; +} diff --git a/src/web/personal.ts b/src/web/personal.ts index 7b440e8..374ab4e 100644 --- a/src/web/personal.ts +++ b/src/web/personal.ts @@ -3,7 +3,8 @@ import { formatEuro } from "../domain/geld.js"; import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/personal.js"; -import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite, tabelle } from "./ui.js"; +import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js"; +import { liste as tabelle } from "./liste.js"; import { entscheiden } from "./urlaub.js"; const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]; @@ -31,13 +32,17 @@ export async function personalSeite(): Promise { inhalt.insertAdjacentHTML("beforeend", '

Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.

'); return; } - inhalt.appendChild(tabelle([ - { titel: "Name", wert: (z) => `${esc(z.name)}${z.antraege ? ` ${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}` : ""}` }, - { titel: "Arbeitszeit", wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' (Vorgabe)'), klasse: "optional" }, - { titel: "Heute", wert: (z) => heuteText(z.heute) }, - { titel: "Resturlaub", wert: (z) => `${tageText(z.urlaub.rest)} von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}` }, - { titel: "Zugang", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : 'keiner'), klasse: "optional" }, - ], liste, (z) => { location.hash = `mitarbeiter-${z.id}`; })); + inhalt.appendChild(tabelle({ + schluessel: "personal", einheit: ["Person", "Personen"], + spalten: [ + { id: "name", titel: "Name", text: (z) => z.name, wert: (z) => `${esc(z.name)}${z.antraege ? ` ${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}` : ""}` }, + { id: "arbeitszeit", titel: "Arbeitszeit", text: (z) => modellText(z.stunden), wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' (Vorgabe)'), klasse: "optional" }, + { id: "heute", titel: "Heute", wert: (z) => heuteText(z.heute) }, + { id: "rest", titel: "Resturlaub", art: "zahl", text: (z) => tageText(z.urlaub.rest), sortWert: (z) => z.urlaub.rest, wert: (z) => `${tageText(z.urlaub.rest)} von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}` }, + { id: "zugang", titel: "Zugang", text: (z) => z.anmeldename ?? "", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : 'keiner'), klasse: "optional" }, + ], + zeilen: liste, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; }, + })); } async function neuerMitarbeiter(): Promise { @@ -96,11 +101,15 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro // Modelle const mZiel = raster.querySelector("#modelle")!; if (eigeneModelle.length) { - mZiel.appendChild(tabelle([ - { titel: "Gültig ab", wert: (m) => dat(m.gueltig_ab) }, - ...WT.map((t, i) => ({ titel: t, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", klasse: "zahl" })), - { titel: "Woche", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, klasse: "zahl" }, - ], eigeneModelle, (m) => void modellDialog(m))); + mZiel.appendChild(tabelle({ + schluessel: "arbeitszeitmodelle", klein: true, + spalten: [ + { id: "ab", titel: "Gültig ab", art: "datum", wert: (m) => dat(m.gueltig_ab), sortWert: (m) => m.gueltig_ab }, + ...WT.map((t, i) => ({ id: `t${i}`, titel: t, art: "zahl" as const, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", sortWert: (m: Zeile) => m.stunden[i], klasse: "zahl" })), + { id: "woche", titel: "Woche", art: "zahl", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, sortWert: (m) => m.stunden.reduce((s: number, h: number) => s + h, 0), klasse: "zahl" }, + ], + zeilen: eigeneModelle, klick: (m) => void modellDialog(m), + })); } else mZiel.innerHTML = `

Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}

`; // Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8) @@ -115,13 +124,17 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro // Abwesenheiten const aZiel = raster.querySelector("#abw")!; - if (eigeneAbw.length) aZiel.appendChild(tabelle([ - { titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) }, - { titel: "Zeitraum", wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) }, - { titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") }, - { titel: "Status", wert: (a) => `${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}` }, - { titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" }, - ], eigeneAbw, (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void neuLaden(); }) : abwDialog(a)))); + if (eigeneAbw.length) aZiel.appendChild(tabelle({ + schluessel: "abwesenheiten", klein: true, einheit: ["Abwesenheit", "Abwesenheiten"], + spalten: [ + { id: "art", titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) }, + { id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (a) => a.von, wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) }, + { id: "umfang", titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") }, + { id: "status", titel: "Status", text: (a) => a.status, wert: (a) => `${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}` }, + { id: "notiz", titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" }, + ], + zeilen: eigeneAbw, klick: (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void neuLaden(); }) : abwDialog(a)), + })); else aZiel.innerHTML = '

Keine Abwesenheiten eingetragen.

'; // ---------- Dialoge ---------- diff --git a/src/web/stunden.ts b/src/web/stunden.ts index b734698..73e2584 100644 --- a/src/web/stunden.ts +++ b/src/web/stunden.ts @@ -3,6 +3,7 @@ import { type Abzugsart, dauerText, minuten, rechneTag, regelPause, uhrzeit } from "../domain/zeit.js"; import { type Zeile, api, dat, dateiSpeichern, esc, heute, inhalt, lies, merke, seite } from "./ui.js"; +import { liste as tabelleMit } from "./liste.js"; const WT = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"]; const WT_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"]; @@ -266,14 +267,22 @@ export async function stundenSeite(): Promise { return `
${esc(l.name)}${dauerText(ist)} Std.${soll ? `Soll ${dauerText(soll)} · ${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}` : ""}
`; }).join("")}`); - const tabelle = document.createElement("div"); - tabelle.className = "tabelle-rolle"; - tabelle.innerHTML = d.tage.length ? ` - ${d.tage.map((t: Zeile, i: number) => ` - - `).join("")}
TagPersonZeitPauseAbzugArbeitszeitBaustellen
${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}${esc(t.name)}${t.beginn}–${t.ende}${t.pause_min || ""}${t.abzug_min || ""}${dauerText(t.netto_min)}${esc(t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", "))}${t.notiz ? ` ${esc(t.notiz)}` : ""}
` - : '

In diesem Monat sind keine Stunden gebucht.

'; - inhalt.appendChild(tabelle); + const baustellen = (t: Zeile) => t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", "); + inhalt.appendChild(tabelleMit({ + schluessel: "stunden", einheit: ["Tag", "Tage"], leer: "In diesem Monat sind keine Stunden gebucht.", + zeilen: d.tage.map((t: Zeile) => ({ ...t, id: t.id ?? `${t.kontakt_id}-${t.datum}` })), + spalten: [ + { id: "tag", titel: "Tag", art: "datum", wert: (t) => `${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}`, sortWert: (t) => t.datum }, + { id: "person", titel: "Person", wert: (t) => esc(t.name) }, + { id: "zeit", titel: "Zeit", wert: (t) => `${t.beginn}–${t.ende}`, sortWert: (t) => t.beginn }, + { id: "pause", titel: "Pause", art: "zahl", wert: (t) => String(t.pause_min || ""), sortWert: (t) => t.pause_min || 0, klasse: "zahl" }, + { id: "abzug", titel: "Abzug", art: "zahl", wert: (t) => String(t.abzug_min || ""), sortWert: (t) => t.abzug_min || 0, klasse: "zahl" }, + { id: "arbeitszeit", titel: "Arbeitszeit", art: "zahl", wert: (t) => `${dauerText(t.netto_min)}`, sortWert: (t) => t.netto_min, klasse: "zahl" }, + { id: "baustellen", titel: "Baustellen", text: baustellen, wert: (t) => `${esc(baustellen(t))}${t.notiz ? ` ${esc(t.notiz)}` : ""}`, klasse: "optional" }, + ], + klick: (t) => void oeffne(d.tage.find((x: Zeile) => x.kontakt_id === t.kontakt_id && x.datum === t.datum) ?? t), + fuss: (l) => (l.length && l.length !== d.tage.length ? `

Summe der gezeigten Tage: ${dauerText(l.reduce((s, t) => s + t.netto_min, 0))} Std.

` : ""), + })); const oeffne = async (t: Zeile | null) => { const huelle = document.getElementById("dialog-huelle")!; @@ -321,10 +330,6 @@ export async function stundenSeite(): Promise { } }); leiste.querySelector("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); }; - tabelle.onclick = (ev) => { - const tr = (ev.target as HTMLElement).closest("tr[data-i]"); - if (tr) void oeffne(d.tage[Number(tr.dataset.i)]); - }; } /** Inhaber und Büro: zwischen eigenen Stunden und allen umschalten */ diff --git a/src/web/styles.css b/src/web/styles.css index ca63b49..16f2a8c 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -313,8 +313,6 @@ dl.werte dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; .g-trenner:hover, .g-trenner.zieht { background: var(--akzent-hell); border-color: var(--akzent); } /* Zoom an der Zeitskala und Abschläge als Meilensteine (Henning, 20.10.2026) */ -.g-zoom { display: inline-flex; align-items: center; gap: 4px; } -.g-zoom button { min-width: 32px; padding-inline: 8px; } .g-zeit { cursor: ew-resize; touch-action: none; user-select: none; } .zahlung-ms { position: absolute; top: 19px; width: 18px; height: 18px; pointer-events: auto; cursor: pointer; z-index: 2; clip-path: polygon(50% 0, 100% 50%, 50% 100%, 0 50%); display: grid; place-items: center; font-size: 11px; font-weight: 700; @@ -562,3 +560,73 @@ button.haupt.gross { padding: 14px 22px; font-size: 17px; flex: 1; } .last.leer { background: repeating-linear-gradient(135deg, rgb(120 130 150 / 0.18) 0 4px, transparent 4px 8px); color: var(--leise); border: 1px solid var(--linie); } .dialog .b-dauer { border-bottom: 1px solid var(--linie); padding-bottom: 10px; margin-bottom: 10px; } .dialog .b-dauer .schalter { margin-top: 8px; color: var(--text); } + +/* Sortieren und Filtern wie in Excel (alle Tabellen) */ +.liste { margin-bottom: 8px; } +.liste-leiste { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin-bottom: 10px; } +.liste-leiste .ansicht-knopf { padding: 6px 12px; font-size: 14px; } +.liste-leiste .ansicht-knopf i { font-style: normal; color: var(--holz); font-size: 12px; } +.liste-leiste .nur-schmal { padding: 6px 12px; font-size: 14px; } +.chip { display: inline-flex; align-items: center; gap: 2px; background: var(--akzent-hell); color: var(--akzent); border-radius: 999px; font-size: 13px; padding: 2px 4px 2px 10px; max-width: 100%; } +.chip.sort { background: var(--bg); color: var(--text); border: 1px solid var(--linie); } +.chip > span, .chip-text { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.chip button { background: none; border: 0; color: inherit; font: inherit; cursor: pointer; padding: 3px 6px; border-radius: 999px; } +.chip button:hover { background: rgb(0 0 0 / 0.06); } +.chip-text { display: inline-flex; align-items: center; gap: 5px; padding-left: 0 !important; } +.chip svg, .th-zeichen svg, .fm-zeile svg { width: 11px; height: 11px; flex: none; } +th .th-knopf { all: unset; cursor: pointer; display: inline-flex; align-items: center; gap: 5px; font: inherit; color: inherit; border-radius: 4px; } +th .th-knopf:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; } +th .th-zeichen { display: inline-flex; align-items: center; gap: 2px; color: var(--akzent); font-weight: 700; } +th .th-zeichen i { font-style: normal; color: var(--leise); opacity: 0.45; font-weight: 400; font-size: 11px; } +th:hover .th-zeichen i, th.aktiv .th-zeichen i { opacity: 1; } +th.aktiv { color: var(--akzent); } +th.zahl .th-knopf { flex-direction: row-reverse; } +td.auge-spalte, th.auge-spalte { width: 34px; padding-left: 0; padding-right: 8px; text-align: right; } +button.auge { background: none; border: 0; padding: 4px; color: var(--leise); cursor: pointer; opacity: 0; border-radius: 6px; line-height: 0; } +button.auge svg { width: 17px; height: 17px; } +tr:hover button.auge, button.auge:focus-visible, tr.ausgeblendet button.auge { opacity: 1; } +button.auge:hover { color: var(--akzent); background: var(--akzent-hell); } +@media (hover: none) { button.auge { opacity: 0.5; } } +tr.ausgeblendet td { opacity: 0.45; } +tr.ausgeblendet td.auge-spalte { opacity: 1; } +tr.leer td { color: var(--leise); text-align: center; padding: 22px; } +.filter-menue { position: fixed; z-index: 30; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 10px; box-shadow: 0 10px 30px rgb(0 0 0 / 0.2); width: 290px; padding: 6px; font-size: 14px; } +.filter-menue.ansichten-menue { width: 320px; } +.filter-menue.blatt { left: 0; right: 0; bottom: 0; width: auto; border-radius: 14px 14px 0 0; max-height: 85vh; overflow: auto; padding: 8px max(10px, env(safe-area-inset-right, 0px)) calc(10px + env(safe-area-inset-bottom, 0px)) max(10px, env(safe-area-inset-left, 0px)); } +.filter-menue hr { border: 0; border-top: 1px solid var(--linie); margin: 4px 0; } +.fm-kopf { display: flex; align-items: center; justify-content: space-between; padding: 4px 6px 6px; } +.fm-zu { background: none; border: 0; color: var(--leise); cursor: pointer; font-size: 15px; padding: 4px 6px; } +.fm-zeile { display: flex; gap: 8px; align-items: center; width: 100%; text-align: left; background: none; border: 0; color: inherit; font: inherit; padding: 7px 8px; border-radius: 6px; cursor: pointer; } +.fm-zeile > span { width: 16px; display: inline-flex; justify-content: center; color: var(--leise); flex: none; } +.fm-zeile:hover:not(:disabled) { background: var(--bg); } +.fm-zeile.an { color: var(--akzent); font-weight: 600; } +.fm-zeile:disabled { color: var(--leise); opacity: 0.6; cursor: default; } +.fm-weitere { display: flex; align-items: center; gap: 6px; padding: 4px 8px 4px 32px; color: var(--leise); } +.fm-weitere span { flex: 1; } +.fm-weitere button.neben { padding: 2px 10px; } +.fm-zeit { display: flex; align-items: center; gap: 8px; padding: 6px 8px; color: var(--leise); } +.fm-zeit select { flex: 1; padding: 6px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; } +.fm-suche { width: 100%; margin: 6px 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; } +.fm-werte { border: 1px solid var(--linie); border-radius: 6px; max-height: 240px; overflow: auto; padding: 4px 0; } +.blatt .fm-werte { max-height: 38vh; } +.fm-werte label { display: flex; align-items: center; gap: 8px; padding: 5px 8px; cursor: pointer; } +.fm-werte label:hover { background: var(--bg); } +.fm-werte label span { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.fm-werte label small { color: var(--leise); } +.fm-werte .hinweis { padding: 4px 8px; margin: 0; } +.filter-menue .knoepfe { display: flex; justify-content: flex-end; gap: 8px; padding: 8px 2px 2px; } +.filter-menue .knoepfe button:disabled { opacity: 0.5; cursor: default; } +.filter-menue > .hinweis { font-size: 12px; padding: 4px 8px; margin: 0; } +.g-links .auge-g { background: none; border: 0; color: var(--leise); cursor: pointer; padding: 0; width: 22px; height: 22px; border-radius: 5px; display: inline-flex; align-items: center; justify-content: center; flex: none; } +.g-links .auge-g svg { width: 15px; height: 15px; } +.g-links .auge-g:hover { background: var(--akzent-hell); color: var(--akzent); } +.g-zeile.ausgeblendet .g-links > *:not(.name), .g-zeile.ausgeblendet .name .text { opacity: 0.45; } +.g-zeile.ausgeblendet .aktionen { opacity: 1; } +.leiste .g-aus { font-size: 14px; color: var(--leise); } +.leiste .chip button { padding: 5px 6px; } +td .unter.nur-schmal, .liste-leiste .nur-schmal { display: none; } +@media (max-width: 800px) { + td .unter.nur-schmal { display: block; } + .liste-leiste .nur-schmal { display: inline-block; } + td.auge-spalte, th.auge-spalte { width: 28px; padding-right: 4px; } +} diff --git a/src/web/ui.ts b/src/web/ui.ts index fe16166..792c3c6 100644 --- a/src/web/ui.ts +++ b/src/web/ui.ts @@ -186,17 +186,6 @@ export async function bearbeiten(pfad: string, titel: string, felder: Feld[], ze /** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */ export const hinweis = { text: "" }; -export function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement { - const t = document.createElement("table"); - t.innerHTML = `${spalten.map((s) => `${esc(s.titel)}`).join("")} - ${zeilen.map((z, i) => `${spalten.map((s) => `${s.wert(z)}`).join("")}`).join("")}`; - if (klick) t.addEventListener("click", (ev) => { - const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null; - if (tr) klick(zeilen[Number(tr.dataset.i)]!); - }); - return t; -} - // Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement { inhalt.innerHTML = `

${esc(titel)}

${hinweis.text ? `
${esc(hinweis.text)}
` : ""}`; diff --git a/test/ansicht.test.ts b/test/ansicht.test.ts new file mode 100644 index 0000000..534a53f --- /dev/null +++ b/test/ansicht.test.ts @@ -0,0 +1,64 @@ +import { describe, expect, it } from "vitest"; +import { type SpaltenWerte, LEER, ansichtAus, imZeitraum, leereAnsicht, monatText, passt, sortiere, vergleiche } from "../src/domain/ansicht.js"; + +// Montag 19.10.2026 bis Sonntag 25.10.2026 +const HEUTE = "2026-10-21"; + +describe("Zeiträume wie im Datumsfilter von Excel", () => { + it("Wochen laufen von Montag bis Sonntag", () => { + expect(imZeitraum("diese-woche", "2026-10-19", HEUTE)).toBe(true); + expect(imZeitraum("diese-woche", "2026-10-25", HEUTE)).toBe(true); + expect(imZeitraum("diese-woche", "2026-10-26", HEUTE)).toBe(false); + expect(imZeitraum("naechste-woche", "2026-10-26", HEUTE)).toBe(true); + expect(imZeitraum("letzte-woche", "2026-10-18", HEUTE)).toBe(true); + }); + it("„Bis Ende dieser Woche“ nimmt Überfälliges mit, ohne Datum nie", () => { + expect(imZeitraum("bis-wochenende", "2025-01-01", HEUTE)).toBe(true); + expect(imZeitraum("bis-wochenende", "2026-10-26", HEUTE)).toBe(false); + expect(imZeitraum("bis-wochenende", null, HEUTE)).toBe(false); + }); + it("Monate über den Jahreswechsel", () => { + expect(imZeitraum("naechster-monat", "2027-01-05", "2026-12-20")).toBe(true); + expect(imZeitraum("letzter-monat", "2026-11-30", "2026-12-20")).toBe(true); + expect(monatText("2026-10")).toBe("Oktober 2026"); + }); +}); + +describe("Filtern und Sortieren", () => { + const zeilen = [ + { kat: "Büro", f: "2026-10-23", n: 5 }, + { kat: "", f: null, n: 12 }, + { kat: "Einkauf", f: "2026-10-20", n: 5 }, + { kat: "Büro", f: "2026-11-02", n: 1 }, + ]; + const spalten: SpaltenWerte[] = [ + { id: "kat", wert: (i) => zeilen[i]!.kat || LEER, sort: (i) => zeilen[i]!.kat || null }, + { id: "f", art: "datum", wert: (i) => (zeilen[i]!.f ?? LEER).slice(0, 7), sort: (i) => zeilen[i]!.f }, + { id: "n", art: "zahl", wert: (i) => String(zeilen[i]!.n), sort: (i) => zeilen[i]!.n }, + ]; + const alle = [0, 1, 2, 3]; + + it("abgewählte Werte und Zeiträume blenden Zeilen aus, neue Werte bleiben sichtbar", () => { + const a = { ...leereAnsicht(), filter: { kat: ["Büro"] } }; + expect(alle.filter((i) => passt(i, a, spalten, HEUTE))).toEqual([1, 2]); + const b = { ...leereAnsicht(), zeit: { f: "diese-woche" } }; + expect(alle.filter((i) => passt(i, b, spalten, HEUTE))).toEqual([0, 2]); + // die Werteliste einer Spalte richtet sich nach den anderen Filtern, nicht nach dem eigenen + expect(alle.filter((i) => passt(i, a, spalten, HEUTE, "kat"))).toEqual(alle); + }); + + it("mehrere Sortierungen nacheinander, Leeres immer hinten", () => { + expect(sortiere(alle, [["kat", "auf"], ["n", "ab"]], spalten)).toEqual([0, 3, 2, 1]); + expect(sortiere(alle, [["kat", "ab"]], spalten)).toEqual([2, 0, 3, 1]); + expect(sortiere(alle, [["f", "auf"]], spalten)).toEqual([2, 0, 3, 1]); + // bei Gleichstand bleibt die ursprüngliche Reihenfolge + expect(sortiere(alle, [["n", "auf"]], spalten)).toEqual([3, 0, 2, 1]); + expect(vergleiche("P-26-9", "P-26-10", "auf")).toBeLessThan(0); + }); + + it("gespeicherte Ansichten werden geprüft, Unbrauchbares fällt weg", () => { + expect(ansichtAus({ sort: [["kat", "auf"], ["x", "quer"], "kaputt"], filter: { kat: ["Büro", 3], leer: [] }, zeit: { f: "diese-woche", g: "irgendwann" }, aus: ["a", 1] })) + .toEqual({ sort: [["kat", "auf"]], filter: { kat: ["Büro"] }, zeit: { f: "diese-woche" }, aus: ["a"] }); + expect(ansichtAus(null)).toEqual(leereAnsicht()); + }); +}); diff --git a/test/api.test.ts b/test/api.test.ts index 97c58a9..c19c312 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -410,6 +410,23 @@ describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => expect((await app.inject({ method: "POST", url: "/api/import/stand", payload: vorher })).statusCode).toBe(201); expect((await pool.query("select bool_and(dauer_fest) as alle from vorgang")).rows[0].alle).toBe(true); }); + + it("Ansichten der Tabellen je Benutzer: speichern, Sicherung, Umzug", async () => { + const ansicht = { aktuell: { sort: [["faellig", "auf"]], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" }, aus: [] }, name: "Meine Woche", ansichten: [] }; + expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: ansicht })).statusCode).toBe(204); + expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/Böse Tabelle", payload: ansicht })).statusCode).toBe(400); + expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { x: "y".repeat(100_001) } })).statusCode).toBe(413); + expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht }); + const stand = (await app.inject("/api/export")).json(); + expect(stand.daten.ansichten).toHaveLength(1); + // auf dem Server gibt es schon eine Ansicht des Inhabers: die aus der Sicherung gewinnt, die Daten zählen trotzdem als leer + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + expect((await app.inject({ method: "PUT", url: "/api/ich/ansichten/aufgaben", payload: { name: null } })).statusCode).toBe(204); + const r = await app.inject({ method: "POST", url: "/api/import/stand", payload: stand }); + expect(r.statusCode, r.body).toBe(201); + expect((await app.inject("/api/ich/ansichten")).json()).toEqual({ aufgaben: ansicht }); + }); }); describe.skipIf(!url)("Anmeldung und Rollen (U1, U2)", () => {