Sortieren und Filtern wie in Excel in jeder Tabelle, Ansichten je Benutzer (0.13.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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:
Claude
2026-10-20 07:47:06 +00:00
parent d5f861318b
commit 6d0c5f238b
19 changed files with 966 additions and 157 deletions

View File

@@ -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.

View File

@@ -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) {

View File

@@ -62,7 +62,7 @@ async function main() {
if (speicher) {
melde("Deine Daten werden geladen …");
const daten: Record<string, Record<string, unknown>[]> = {};
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 });

View File

@@ -1,6 +1,6 @@
{
"name": "betrieb",
"version": "0.12.0",
"version": "0.13.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",

115
src/domain/ansicht.ts Normal file
View File

@@ -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<string, string[]>;
/** je Datumsspalte ein Zeitraum aus ZEITRAEUME */
zeit: Record<string, string>;
/** 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<Ansicht>;
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<string, unknown>) : {});
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<string, string>,
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<string, string> = 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;
});
}

View File

@@ -364,6 +364,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const daten: Record<string, unknown[]> = {};
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 };

View File

@@ -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();
});
}

View File

@@ -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)
);

View File

@@ -42,6 +42,7 @@ export async function speichereStand(c: Client, s: Stand): Promise<Record<string
anzahl[t.pfad] = zeilen.length;
}
anzahl.benutzer = await speichereBenutzer(c, s.daten.benutzer ?? []);
anzahl.ansichten = await speichereAnsichten(c, s.daten.ansichten ?? []);
if (s.einstellungen !== undefined) {
await c.query("update einstellungen set daten = $1", [EinstellungenSchema.parse(s.einstellungen)]);
}
@@ -66,6 +67,15 @@ async function speichereBenutzer(c: Client, zeilen: Record<string, unknown>[]):
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<string, unknown>[]): Promise<number> {
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<Record<string, unknown>[]> {
return (await c.query("select id, anmeldename, name, rolle, kontakt_id, aktiv, angelegt_am from benutzer order by angelegt_am")).rows;

View File

@@ -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<void> {
}
};
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" : '<span class="fehler">fehlt</span>') }]),
{ titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
], 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" : '<span class="fehler">fehlt</span>') }]),
{ id: "zugang", titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
],
zeilen: liste, klick: (z) => void oeffnen(z),
}));
inhalt.insertAdjacentHTML("beforeend", testversion
? `<p class="hinweis">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.</p>`
: `<p class="hinweis">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.</p>`);

View File

@@ -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();
}

View File

@@ -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<string, string[]>; zeit: Record<string, string>; 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<string, number> = { 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<void
const personen = new Map<string, string>();
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<string>("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<GanttAnsicht>) => { 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<string, FilterWert[]> = { person: personWerte, projekt: projektWerte };
const filterKnopf = (id: string, titel: string, aus: string[]) => aus.length
? `<span class="chip"><button class="chip-text" data-filter="${id}" title="${titel} filtern">${esc(titel)}: ${esc(h.filterText(filterWerte[id]!, aus))}</button><button data-filter-weg="${id}" aria-label="Filter ${titel} entfernen">✕</button></span>`
: `<button class="neben" data-filter="${id}" aria-haspopup="true">${titel} ▾</button>`;
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) => `<button class="neben${ZOOM[z] === W ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
<span class="g-zoom" title="Zeitskala zoomen; du kannst auch an der Zeitskala nach links oder rechts ziehen"><button class="neben" data-a="kleiner" aria-label="Verkleinern">−</button><button class="neben" data-a="groesser" aria-label="Vergrößern">+</button></span>
<button class="neben" data-a="heute">Heute</button>
<select data-a="person" title="Nur Vorgänge dieser Person zeigen"><option value="">Alle Personen</option>${[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => `<option value="${esc(id)}"${id === filter ? " selected" : ""}>${esc(name)}</option>`).join("")}</select>
${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("person", "Personal", personAus)}
${anzahlAus ? `<span class="g-aus">${anzahlAus} ausgeblendet · <button class="verweis" data-a="aus-zeigen">${ausZeigen ? "wieder verbergen" : "einblenden"}</button>${ausZeigen ? ' · <button class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}</span>` : ""}
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
<span class="hinweis">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.</span>
<span class="fehler g-meldung" role="status"></span>`;
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<string, number>();
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<void
const abs = plan.abschnitte.filter((a) => 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<string, number>();
@@ -258,7 +290,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
if (r.art === "p") {
const raten = (plan.zahlungen ?? []).filter((z) => z.projekt_id === o.id);
links = `${nr}<span class="name ebene0" style="box-shadow:inset 4px 0 0 ${r.farbe}">${klapp}<span class="text" title="${esc(o.bezeichnung)}">${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button></span></span>
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button></span></span>
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}
<span>${raten.length ? `<button class="verweis g-raten" data-raten="${o.id}" title="Zahlungsplan öffnen">€ ${raten.length} ${raten.length === 1 ? "Rate" : "Raten"}</button>`
: Number(o.umsatz_netto) > 0 && o.zahlungsplan === "fest"
@@ -269,7 +301,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
balken += raten.map((z) => `<div class="zahlung-ms ${esc(z.status ?? "geplant")}" data-raten="${o.id}" style="left:${x(z.termin) + W / 2 - 9}px;--farbe:${r.farbe}" title="${esc(z.bezeichnung)} · ${formatEuro(Number(z.netto))} netto · fällig ${formatDatum(z.termin)} · ${esc(z.status ?? "geplant")}">€</div>`).join("");
} else if (r.art === "a") {
links = `${nr}<span class="name ebene1">${klapp}<span class="text zelle" data-id="${o.id}" data-feld="abschnitt" title="Klicken zum Umbenennen">${esc(o.name)}</span>
<span class="aktionen"><button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button><button class="weg" data-weg="abschnitte/${o.id}" title="Abschnitt mit allen Vorgängen löschen">✕</button></span></span>
<span class="aktionen"><button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="abschnitte/${o.id}" title="Abschnitt mit allen Vorgängen löschen">✕</button></span></span>
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}<span></span>`;
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<void
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" title="${titel}">${inhaltHtml}</span>`;
links = `${nr}<span class="name ebene2">${zelle("name", "text", esc(o.name), "Bezeichnung")}
<span class="aktionen"><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
<span class="aktionen"><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
${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<void
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}" data-bar="${o.id}" style="left:${links0}px;width:${breite}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${dauerText(Math.ceil(o.dauer))}">${reduziertHtml(o, links0)}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`
+ beschriftung(links0, links0 + breite, esc(o.name), o.anfang, o.ende, leute);
}
return `<div class="g-zeile ${r.art}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
return `<div class="g-zeile ${r.art}${ausgeblendet.has(o.id) ? " ausgeblendet" : ""}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
}).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<void
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
${zeilenHtml}${auslastungHtml}
</div></div>
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}</div>
${reihen.length ? "" : `<p class="hinweis" style="padding:16px">${filter || projektAus.length || anzahlAus ? "Nichts passt zu den Filtern. Oben unter Projekte und Personal lassen sie sich wieder entfernen." : "Noch keine Projekte im Terminplan."}</p>`}</div>
<div class="g-trenner" role="separator" aria-orientation="vertical" aria-label="Trennleiste zwischen Tabelle und Zeitplan" title="Ziehen: Spalten ein- oder ausblenden; Doppelklick: alle Spalten zeigen"></div>`;
const box = rahmen.querySelector<HTMLElement>(".gantt")!;
if (plan.ueberschneidungen.length) {
@@ -440,9 +473,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
leiste.addEventListener("click", (ev) => {
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<HTMLElement>(".g-zeit")!.addEventListener("pointerdown", (ev) => {
@@ -465,12 +504,16 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
document.addEventListener("pointermove", zieh);
document.addEventListener("pointerup", los);
});
leiste.querySelector<HTMLSelectElement>('[data-a="person"]')!.onchange = (ev) => { merke("gantt-person", (ev.target as HTMLSelectElement).value); neuLaden(); };
leiste.querySelector<HTMLInputElement>('[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<HTMLElement>("[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]);

393
src/web/liste.ts Normal file
View File

@@ -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<Ansicht>;
/** fertige Ansichten, z. B. „Meine Woche“ */
vorlagen?: { name: string; ansicht: Partial<Ansicht> }[];
/** 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<string, Gespeichert> = {};
const warten = new Map<string, ReturnType<typeof setTimeout>>();
/** Beim Start und nach einem Benutzerwechsel: die Ansichten des Benutzers holen */
export async function ansichtenLaden(): Promise<void> {
try { speicher = await api<Record<string, Gespeichert>>("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 = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="3"/></svg>';
export const AUGE_ZU = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 3l18 18M10.6 5.1A10 10 0 0 1 12 5c6.5 0 10 7 10 7a17 17 0 0 1-3.2 4.1M6.6 6.6C3.8 8.4 2 12 2 12s3.5 7 10 7c1.8 0 3.4-.5 4.8-1.3M9.9 9.9a3 3 0 0 0 4.2 4.2"/></svg>';
const TRICHTER = '<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M3 4h18l-7 8.5V19l-4 2v-8.5z"/></svg>';
const SORT_TEXT: Record<string, [string, string]> = {
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, `<div class="fm-kopf"><b>${esc(o.titel)}</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
${o.sortieren ? `<button type="button" class="fm-zeile${o.sortiert === "auf" ? " an" : ""}" data-m="auf"><span>↑</span>${auf}</button>
<button type="button" class="fm-zeile${o.sortiert === "ab" ? " an" : ""}" data-m="ab"><span>↓</span>${ab}</button>
${o.weitereSortierung ? `<div class="fm-weitere"><span>+ als weitere Sortierung</span><button type="button" class="neben" data-m="dazu-auf" title="aufsteigend">↑</button><button type="button" class="neben" data-m="dazu-ab" title="absteigend">↓</button></div>` : ""}
${o.sortiert ? '<button type="button" class="fm-zeile" data-m="sort-weg"><span>✕</span>Sortierung entfernen</button>' : ""}<hr>` : ""}
<button type="button" class="fm-zeile" data-m="filter-weg"${aktiv ? "" : " disabled"}><span>${TRICHTER}</span>Filter entfernen</button>
${o.art === "datum" ? `<label class="fm-zeit">Datumsfilter <select data-m="zeit"><option value="">alle Daten</option>${ZEITRAEUME.map(([k, t]) => `<option value="${k}"${k === o.zeit ? " selected" : ""}>${t}</option>`).join("")}</select></label>` : ""}
<input type="search" class="fm-suche" placeholder="Suchen" aria-label="Werte durchsuchen">
<div class="fm-werte"><label class="fm-alle"><input type="checkbox" data-m="alle"> <span>(Alles auswählen)</span></label>
${o.werte.map((w, i) => `<label data-i="${i}"><input type="checkbox" data-w="${i}"${o.aus.includes(w.wert) ? "" : " checked"}> <span>${esc(w.text)}</span><small>${w.anzahl || ""}</small></label>`).join("")}
${o.werte.length ? "" : '<p class="hinweis">Keine Werte.</p>'}</div>
<div class="knoepfe"><button type="button" class="neben" data-m="zu">Abbrechen</button><button type="button" class="haupt" data-m="ok">OK</button></div>`);
const suche = m.querySelector<HTMLInputElement>(".fm-suche")!;
const kasten = (i: number) => m.querySelector<HTMLInputElement>(`[data-w="${i}"]`)!;
const alle = m.querySelector<HTMLInputElement>('[data-m="alle"]')!;
const ok = m.querySelector<HTMLButtonElement>('[data-m="ok"]')!;
const sichtbar = () => o.werte.map((_, i) => i).filter((i) => !m.querySelector<HTMLElement>(`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<HTMLElement>(`label[data-i="${i}"]`)!.hidden = !!q && !w.text.toLocaleLowerCase("de").includes(q); });
m.querySelector<HTMLElement>(".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<HTMLElement>("[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<HTMLSelectElement>('[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<string, number>();
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<string, number>();
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 ? `<span class="chip sort"><span>Sortiert: ${a.sort.map(([id, r], n) => `${a.sort.length > 1 ? `${n + 1}. ` : ""}${esc(spalte(id)?.titel ?? id)} ${r === "auf" ? "↑" : "↓"}`).join(" · ")}</span><button type="button" data-a="sort-weg" aria-label="Sortierung entfernen">✕</button></span>` : "";
const chips = filterIds.map((id) => `<span class="chip"><button type="button" class="chip-text" data-menue="${id}">${TRICHTER}${esc(spalte(id).titel)}: ${esc(filterText(alleWerte(id), a.filter[id] ?? [], a.zeit[id]))}</button><button type="button" data-chip-weg="${id}" aria-label="Filter ${esc(spalte(id).titel)} entfernen">✕</button></span>`).join("");
const leisteZeigen = !o.klein || filterIds.length || (a.sort.length && !gleich({ ...a, filter: {}, zeit: {}, aus: [] }, { ...vorgabe, filter: {}, zeit: {}, aus: [] }));
const leiste = leisteZeigen ? `<div class="liste-leiste">
${o.klein ? "" : `<button type="button" class="neben ansicht-knopf" data-a="ansichten" aria-haspopup="true">Ansicht: <b>${esc(name ?? "Standard")}</b>${geaendert ? " <i>geändert</i>" : ""} ▾</button>`}
${o.klein ? "" : '<button type="button" class="neben nur-schmal" data-a="spalten" aria-haspopup="true">Sortieren und filtern ▾</button>'}
${sortChip}${chips}
${geaendert ? '<button type="button" class="verweis" data-a="zuruecksetzen">Zurücksetzen</button>' : ""}</div>` : "";
const kopf = o.spalten.map((s) => {
if (s.fest) return `<th class="${s.klasse ?? ""}">${s.kopf ?? esc(s.titel)}</th>`;
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 `<th class="${s.klasse ?? ""}${r || gefiltertHier ? " aktiv" : ""}"${r ? ` aria-sort="${r === "auf" ? "ascending" : "descending"}"` : ""}>
<button type="button" class="th-knopf" data-menue="${s.id}" title="Sortieren und filtern">${s.kopf ?? esc(s.titel)}<span class="th-zeichen">${r ? `${r === "auf" ? "↑" : "↓"}${a.sort.length > 1 ? `<sup>${nr + 1}</sup>` : ""}` : ""}${gefiltertHier ? TRICHTER : ""}<i>▾</i></span></button></th>`;
}).join("");
const zeile = (i: number) => {
const x = z[i]!, weg = ausSet.has(ids[i]!);
return `<tr data-i="${i}" class="${o.klick ? "klickbar" : ""}${weg ? " ausgeblendet" : ""} ${o.zeilenKlasse?.(x) ?? ""}">${o.spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(x)}</td>`).join("")}
<td class="auge-spalte"><button type="button" class="auge" data-aus="${esc(ids[i])}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button></td></tr>`;
};
const breite = o.spalten.length + 1;
const rumpf = !z.length ? `<tr class="leer"><td colspan="${breite}">${esc(o.leer ?? "Noch nichts eingetragen.")}</td></tr>`
: !zeigen.length ? `<tr class="leer"><td colspan="${breite}">${versteckt.length ? "Alle passenden Zeilen sind ausgeblendet." : "Nichts passt zu den Filtern."} <button type="button" class="verweis" data-a="${versteckt.length ? "aus-zeigen" : "filter-alle-weg"}">${versteckt.length ? "Einblenden" : "Filter entfernen"}</button></td></tr>`
: 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 · <button type="button" class="verweis" data-a="aus-zeigen">${zeigeAus ? "wieder verbergen" : "einblenden"}</button>${zeigeAus ? ' · <button type="button" class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}` : ""}`;
wurzel.innerHTML = `${leiste}<div class="tabelle-rolle"><table class="${o.klasse ?? ""}"><thead><tr>${kopf}<th class="auge-spalte" aria-label="Ausblenden"></th></tr></thead><tbody>${rumpf}</tbody></table></div>
${anzahl && (!o.klein || sichtbar !== z.length || versteckt.length) ? `<p class="anzahl">${anzahl}</p>` : ""}${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) => `<button type="button" class="fm-zeile${n === name ? " an" : ""}" data-v="${esc(n ?? "")}"><span>${n === name ? "✓" : ""}</span>${esc(text)}</button>`;
const m = menue(anker, `<div class="fm-kopf"><b>Ansichten</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
${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("")}<hr>
<button type="button" class="fm-zeile" data-m="neu"><span>+</span>Aktuelle Ansicht speichern …</button>
${name && eigene.some((e) => e.name === name) && geaendert ? `<button type="button" class="fm-zeile" data-m="ueber"><span>↻</span>„${esc(name)}“ mit der aktuellen Ansicht überschreiben</button>` : ""}
${name && eigene.some((e) => e.name === name) ? `<button type="button" class="fm-zeile" data-m="weg"><span>✕</span>„${esc(name)}“ löschen</button>` : ""}
<p class="hinweis">Eine Ansicht merkt sich Sortierung, Filter und ausgeblendete Zeilen.</p>`, "ansichten-menue");
m.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[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, `<div class="fm-kopf"><b>Sortieren und filtern nach</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
${beweglich.map((s) => `<button type="button" class="fm-zeile" data-s="${s.id}"><span>${a.sort.some(([x]) => x === s.id) || a.filter[s.id] || a.zeit[s.id] ? "•" : ""}</span>${esc(s.titel)}</button>`).join("")}`);
m.addEventListener("click", (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[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<HTMLElement>("[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<HTMLElement>("tr[data-i]");
if (tr && wurzel.contains(tr)) o.klick(z[Number(tr.dataset.i)]!);
});
zeichne();
return wurzel;
}

View File

@@ -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<void> {
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.</p>');
return;
}
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => `${esc(z.name)}${z.antraege ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
{ titel: "Arbeitszeit", wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), klasse: "optional" },
{ titel: "Heute", wert: (z) => heuteText(z.heute) },
{ titel: "Resturlaub", wert: (z) => `${tageText(z.urlaub.rest)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
{ titel: "Zugang", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), 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 ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
{ id: "arbeitszeit", titel: "Arbeitszeit", text: (z) => modellText(z.stunden), wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), 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)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
{ id: "zugang", titel: "Zugang", text: (z) => z.anmeldename ?? "", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), klasse: "optional" },
],
zeilen: liste, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; },
}));
}
async function neuerMitarbeiter(): Promise<void> {
@@ -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 = `<p class="hinweis">Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}</p>`;
// 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) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
{ 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) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
{ 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 = '<p class="hinweis">Keine Abwesenheiten eingetragen.</p>';
// ---------- Dialoge ----------

View File

@@ -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<void> {
return `<div><small>${esc(l.name)}</small><b>${dauerText(ist)} Std.</b>${soll ? `<small>Soll ${dauerText(soll)} · <span class="${ist - soll < 0 ? "fehler" : ""}">${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}</span></small>` : ""}</div>`;
}).join("")}</div>`);
const tabelle = document.createElement("div");
tabelle.className = "tabelle-rolle";
tabelle.innerHTML = d.tage.length ? `<table><thead><tr><th>Tag</th><th>Person</th><th>Zeit</th><th class="zahl">Pause</th><th class="zahl">Abzug</th><th class="zahl">Arbeitszeit</th><th class="optional">Baustellen</th></tr></thead>
<tbody>${d.tage.map((t: Zeile, i: number) => `<tr class="klickbar" data-i="${i}"><td>${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}</td><td>${esc(t.name)}</td><td>${t.beginn}–${t.ende}</td>
<td class="zahl">${t.pause_min || ""}</td><td class="zahl">${t.abzug_min || ""}</td><td class="zahl"><b>${dauerText(t.netto_min)}</b></td>
<td class="optional">${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 ? ` <i>${esc(t.notiz)}</i>` : ""}</td></tr>`).join("")}</tbody></table>`
: '<p class="hinweis leer">In diesem Monat sind keine Stunden gebucht.</p>';
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) => `<b>${dauerText(t.netto_min)}</b>`, sortWert: (t) => t.netto_min, klasse: "zahl" },
{ id: "baustellen", titel: "Baustellen", text: baustellen, wert: (t) => `${esc(baustellen(t))}${t.notiz ? ` <i>${esc(t.notiz)}</i>` : ""}`, 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 ? `<p>Summe der gezeigten Tage: <strong>${dauerText(l.reduce((s, t) => s + t.netto_min, 0))} Std.</strong></p>` : ""),
}));
const oeffne = async (t: Zeile | null) => {
const huelle = document.getElementById("dialog-huelle")!;
@@ -321,10 +330,6 @@ export async function stundenSeite(): Promise<void> {
}
});
leiste.querySelector<HTMLSelectElement>("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); };
tabelle.onclick = (ev) => {
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr[data-i]");
if (tr) void oeffne(d.tage[Number(tr.dataset.i)]);
};
}
/** Inhaber und Büro: zwischen eigenen Stunden und allen umschalten */

View File

@@ -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; }
}

View File

@@ -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 = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
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 = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}`;

64
test/ansicht.test.ts Normal file
View File

@@ -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());
});
});

View File

@@ -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)", () => {