From f8b3a0f3b83015105439af47946b356f46d695a6 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 20 Nov 2026 07:44:37 +0000 Subject: [PATCH] =?UTF-8?q?0.54.0:=20Kategorien=20und=20Gruppen=20der=20la?= =?UTF-8?q?ufenden=20Kosten=20als=20Standardlisten,=20L=C3=B6schen=20per?= =?UTF-8?q?=20=E2=9C=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz --- CHANGELOG.md | 7 ++ README.md | 2 +- deploy/.env.beispiel | 2 +- package.json | 2 +- src/server/app.ts | 2 + src/server/einstellungen.ts | 8 ++ src/server/kostenlisten.ts | 81 ++++++++++++++++ src/web/laufendekosten.ts | 184 ++++++++++++++++++++++++++++++++---- src/web/liste.ts | 8 +- src/web/styles.css | 15 +++ test/api.test.ts | 31 ++++++ 11 files changed, 318 insertions(+), 24 deletions(-) create mode 100644 src/server/kostenlisten.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index ea5f3be..d578487 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.54.0 (20.11.2026) + +- Laufende Kosten: Kategorien und Gruppen sind Standardlisten. Der Knopf „Kategorien und Gruppen …“ in der Leiste der Liste öffnet ein kleines Fenster mit den Reitern Kategorien und Gruppen: anlegen, umbenennen (ändert alle Positionen mit), Reihenfolge per Ziehen, löschen. Wird ein Eintrag noch benutzt, fragt das Löschen, wohin die Positionen wandern; so lassen sich zwei Einträge zusammenführen. Das Fenster ist nur offen, solange man es braucht. +- Neue Gruppen gibt es sofort, auch ohne Position: Sie stehen leer in der Liste mit „+ Position in …“. Die Gruppen erscheinen in der Reihenfolge der Liste. +- In der Maske (Doppelklick) sind Kategorie und Gruppe Auswahlfelder; der letzte Eintrag „Kategorien bearbeiten …“ bzw. „Gruppen bearbeiten …“ öffnet dasselbe Fenster. Auch beim Klick in die Kategorie-Zelle gibt es die Auswahl. +- Fehleingaben löschen: ✕ am Zeilenende wie bei den Zahlungen im Projekt (erster Klick fragt, zweiter löscht). Strg+Z bzw. „Rückgängig“ legt die Position wieder an. + ## 0.53.2 (14.11.2026) - Kontakte: Über der Liste steht jetzt eine Suchzeile. Sie sucht in allen Spalten (Name, Firma, Rolle, Gewerk, Telefon, E-Mail, Ort) und filtert die Liste beim Tippen. diff --git a/README.md b/README.md index be38238..611813b 100644 --- a/README.md +++ b/README.md @@ -48,7 +48,7 @@ cd deploy 1. Server mit Docker und git; ein Reverse Proxy (HAProxy) mit TLS leitet an `APP_ADRESSE:APP_PORT` aus `.env` weiter. 2. Repository von git.deichnet.com auf den Server klonen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen. -3. `cd deploy && ./update.sh 0.53.2` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`. +3. `cd deploy && ./update.sh 0.54.0` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`. 4. Beim ersten Aufruf fragt das Programm nach dem Inhaber und dem Einrichtungscode (aus `.env` oder `docker compose logs app | grep Einrichtungscode`). Alle weiteren Zugänge legt der Inhaber unter „Benutzer“ an. Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud. diff --git a/deploy/.env.beispiel b/deploy/.env.beispiel index c7a83d4..db6f4aa 100644 --- a/deploy/.env.beispiel +++ b/deploy/.env.beispiel @@ -1,7 +1,7 @@ # Kopieren nach .env und ausfüllen. Die Datei bleibt nur auf dem Server. # Name des Images, das update.sh aus dem Git-Tag baut IMAGE=betrieb -APP_VERSION=0.53.2 +APP_VERSION=0.54.0 # Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN) APP_ADRESSE=100.64.0.8 APP_PORT=33181 diff --git a/package.json b/package.json index 6b3e2ac..efabc16 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.53.2", + "version": "0.54.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/server/app.ts b/src/server/app.ts index fcb1676..6e7b8dc 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -15,6 +15,7 @@ import { Nextcloud, STATUSORDNER, fehlerText, ordnerAbgleichen, webdavBasis } fr import { CardDav, ergebnisText, kontakteAbgleichen, vcfEinlesen } from "./kontaktabgleich.js"; import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js"; import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; +import { registriereKostenlisten } from "./kostenlisten.js"; import { liquiditaet } from "../domain/liquiditaet.js"; import { formatEuro } from "../domain/geld.js"; import { geldAbHeute, laufendJeMonat, lage } from "../domain/lage.js"; @@ -137,6 +138,7 @@ export async function baueApp(o: Optionen): Promise { registriereAngebote(app, pool, ladeEinstellungen, mitOrdner); registriereStammdaten(app, pool, ladeEinstellungen); + registriereKostenlisten(app, pool); registriereStundensaetze(app, pool); registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() }); diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 2d4bebc..ad8869e 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -96,6 +96,14 @@ export const EinstellungenSchema = z.object({ }) .prefault({}), aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE), + // Standardlisten der laufenden Kosten (Henning, 20.11.2026): Reihenfolge für Auswahl und Gruppierung, Gruppen auch ohne Position. + // Werte, die Positionen benutzen, aber hier fehlen, hängt das Programm hinten an. + kostenListen: z + .object({ + kategorie: z.array(z.string().trim().min(1).max(120)).max(200).default([]), + gruppe: z.array(z.string().trim().min(1).max(120)).max(200).default([]), + }) + .prefault({}), // Stufe 3a: Vorgaben der Angebotskalkulation. Stundensätze (EK, Cent) gelten, bis Hennings Stundensatz-Excel da ist kalkulation: z .object({ diff --git a/src/server/kostenlisten.ts b/src/server/kostenlisten.ts new file mode 100644 index 0000000..bf75a95 --- /dev/null +++ b/src/server/kostenlisten.ts @@ -0,0 +1,81 @@ +// Kategorien und Gruppen der laufenden Kosten als Standardlisten (Henning, 20.11.2026, Entwurf laufende-kosten/kategorien): +// anlegen, umbenennen, sortieren, löschen. Umbenennen ändert alle Positionen mit; Löschen eines benutzten Eintrags +// verschiebt dessen Positionen in einen anderen (so lassen sich zwei Einträge zusammenführen). + +import type { FastifyInstance, FastifyRequest } from "fastify"; +import { z } from "zod"; +import { type Client, type Pool, transaktion } from "./db.js"; +import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; +import { werName } from "./anmeldung.js"; + +export type KostenListe = "kategorie" | "gruppe"; +export interface ListenEintrag { name: string; anzahl: number } + +const Art = z.object({ art: z.enum(["kategorie", "gruppe"]) }); +const Name = z.string().trim().min(1).max(120); +const Reihe = z.object({ namen: z.array(Name).max(200) }); +// nach = "" heißt bei Gruppen „ohne Gruppe“; Kategorien fallen dann auf „Sonstiges“ +const Umbenennen = z.object({ von: Name, nach: z.string().trim().max(120) }); + +/** Liste in der gespeicherten Reihenfolge, dahinter benutzte Werte, die (noch) fehlen; je Eintrag die Zahl der Positionen */ +export function listeMitAnzahl(gespeichert: string[], benutzt: Map): ListenEintrag[] { + const namen = [...new Set(gespeichert)]; + const rest = [...benutzt.keys()].filter((n) => !namen.includes(n)).sort((a, b) => a.localeCompare(b, "de", { numeric: true })); + return [...namen, ...rest].map((name) => ({ name, anzahl: benutzt.get(name) ?? 0 })); +} + +async function lade(c: Client | Pool): Promise { + return EinstellungenSchema.parse((await c.query<{ daten: unknown }>("select daten from einstellungen limit 1")).rows[0]?.daten ?? {}); +} + +async function benutzt(c: Client | Pool, art: KostenListe): Promise> { + const r = await c.query<{ name: string; anzahl: string }>(`select ${art} as name, count(*) as anzahl from laufende_kosten where coalesce(${art}, '') <> '' group by ${art}`); + return new Map(r.rows.map((x) => [x.name, Number(x.anzahl)])); +} + +async function listen(c: Client | Pool): Promise> { + const e = await lade(c); + return { + kategorie: listeMitAnzahl(e.kostenListen.kategorie, await benutzt(c, "kategorie")), + gruppe: listeMitAnzahl(e.kostenListen.gruppe, await benutzt(c, "gruppe")), + }; +} + +async function speichere(c: Client, art: KostenListe, namen: string[]): Promise { + const e = await lade(c); + const neu = EinstellungenSchema.parse({ ...e, kostenListen: { ...e.kostenListen, [art]: [...new Set(namen)] } }); + await c.query("update einstellungen set daten = $1", [neu]); +} + +export function registriereKostenlisten(app: FastifyInstance, pool: Pool): void { + const wer = (req: FastifyRequest) => werName(req); + + app.get("/api/laufende-kosten/listen", async () => listen(pool)); + + // Reihenfolge, neue und gelöschte Einträge. Ein Eintrag, den Positionen noch benutzen, bleibt (hinten) stehen. + app.put("/api/laufende-kosten/listen/:art", async (req) => { + const { art } = Art.parse(req.params); + const { namen } = Reihe.parse(req.body); + return transaktion(pool, wer(req), async (c) => { + await speichere(c, art, namen); + return listen(c); + }); + }); + + // umbenennen; gibt es den neuen Namen schon, werden beide zusammengeführt. Leerer neuer Name: Positionen verlieren + // die Gruppe bzw. kommen nach „Sonstiges“, der Eintrag verschwindet aus der Liste. + app.post("/api/laufende-kosten/listen/:art/umbenennen", async (req, reply) => { + const { art } = Art.parse(req.params); + const { von, nach: roh } = Umbenennen.parse(req.body); + const nach = roh || (art === "kategorie" ? "Sonstiges" : ""); + if (nach === von) return listen(pool); + return transaktion(pool, wer(req), async (c) => { + await c.query(`update laufende_kosten set ${art} = $2 where ${art} = $1`, [von, nach || null]); + const alt = listeMitAnzahl((await lade(c)).kostenListen[art], new Map()).map((x) => x.name); + const liste = alt.includes(von) ? alt : [...alt, von]; + const neu = nach && !liste.includes(nach) ? liste.map((n) => (n === von ? nach : n)) : liste.filter((n) => n !== von); + await speichere(c, art, neu); + return listen(c); + }).catch((err) => reply.status(400).send({ fehler: (err as Error).message })); + }); +} diff --git a/src/web/laufendekosten.ts b/src/web/laufendekosten.ts index b5c5f38..fbc8c86 100644 --- a/src/web/laufendekosten.ts +++ b/src/web/laufendekosten.ts @@ -3,7 +3,7 @@ // Terminplan, Strg+Z nimmt zurück, eine Zeile lässt sich in eine andere Gruppe ziehen. Ausgeblendete Zeilen zählen // in Summen, Kacheln und Liquidität weiter mit. -import { type Feld, type Zeile, api, bearbeiten, dat, esc, euro, heute, inhalt, seite } from "./ui.js"; +import { BEARBEITEN, type Feld, type Zeile, api, bearbeiten, dat, esc, euro, heute, huelle, inhalt, seite } from "./ui.js"; import { liste } from "./liste.js"; import { termineLaufend } from "../domain/liquiditaet.js"; import { laeuftHeute } from "../domain/lage.js"; @@ -12,11 +12,143 @@ import { formatEuro, parseEuro } from "../domain/geld.js"; export const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]]; const RHYTHMUS_TEXT = Object.fromEntries(RHYTHMEN); -const LK_FELDER: Feld[] = [ - { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" }, { name: "gruppe", titel: "Gruppe" }, - { name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN }, - { name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" }, -]; + +// Standardlisten für Kategorie und Gruppe (Henning, 20.11.2026): Auswahl statt freiem Text, Editor nur bei Bedarf +type Liste = "kategorie" | "gruppe"; +type Listen = Record; +const LISTE_TEXT: Record = { kategorie: ["Kategorie", "Kategorien"], gruppe: ["Gruppe", "Gruppen"] }; +const kategorieOptionen = (l: Listen, wert?: string): [string, string][] => { + const namen = l.kategorie.map((k) => k.name); + if (!namen.length) namen.push("Sonstiges"); + if (wert && !namen.includes(wert)) namen.push(wert); + return namen.map((n) => [n, n]); +}; +const gruppeOptionen = (l: Listen): [string, string][] => [["", "– ohne Gruppe"], ...l.gruppe.map((g): [string, string] => [g.name, g.name])]; + +function lkFelder(l: Listen, wert?: Zeile): Feld[] { + return [ + { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, + { name: "kategorie", titel: "Kategorie", art: "auswahl", optionen: kategorieOptionen(l, wert?.kategorie), + bearbeiten: { text: "Kategorien bearbeiten …", aktion: async () => kategorieOptionen(await listenEditor("kategorie"), wert?.kategorie) } }, + { name: "gruppe", titel: "Gruppe", art: "auswahl", optionen: gruppeOptionen(l), + bearbeiten: { text: "Gruppen bearbeiten …", aktion: async () => gruppeOptionen(await listenEditor("gruppe")) } }, + { name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN }, + { name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" }, + ]; +} + +/** + * Kleines Fenster über der Seite mit den Reitern Kategorien und Gruppen: anlegen, umbenennen (ändert alle Positionen mit), + * Reihenfolge per Ziehen, löschen. Ein benutzter Eintrag wird beim Löschen in einen anderen verschoben (= zusammenführen). + */ +export function listenEditor(start: Liste): Promise { + return new Promise((fertig) => { + const warSichtbar = !huelle.hidden; + huelle.hidden = false; + const box = document.createElement("div"); + box.className = "dialog kategorien lk-listen"; + box.style.position = "fixed"; + box.setAttribute("role", "dialog"); + box.setAttribute("aria-label", "Kategorien und Gruppen"); + huelle.appendChild(box); + let art: Liste = start; + let l: Listen = { kategorie: [], gruppe: [] }; + let frage: string | null = null; + let ziehe: number | null = null; + const zeichne = (fehler = "") => { + const [eins, mehr] = LISTE_TEXT[art]; + const eintraege = l[art]; + const fr = frage === null ? null : eintraege.find((x) => x.name === frage); + const ziele = eintraege.filter((x) => x.name !== frage).map((x) => x.name); + box.innerHTML = `

Kategorien und Gruppen

+
${(["kategorie", "gruppe"] as Liste[]).map((a) => ``).join("")}
+
    ${eintraege.map((x, i) => `
  • ⋮⋮ + ${x.anzahl ? `${x.anzahl} ${x.anzahl === 1 ? "Position" : "Positionen"}` : "leer"}
  • `).join("")}
+ ${eintraege.length ? "" : `

Noch keine ${mehr}.

`} + ${fr ? `
„${esc(fr.name)}“ wird noch von ${fr.anzahl} ${fr.anzahl === 1 ? "Position" : "Positionen"} benutzt. Verschieben nach + + und löschen?
` : ""} +
+

${esc(fehler)}

+

Umbenennen ändert alle Positionen mit. Die Reihenfolge gilt für die Auswahl und die Gruppen in der Liste.

+
`; + if (!frage) box.querySelector("#lk-neu")!.focus(); + }; + const laden = async () => { l = await api("laufende-kosten/listen"); }; + const versuche = async (fn: () => Promise) => { + try { await fn(); await laden(); zeichne(); } catch (e) { await laden(); zeichne((e as Error).message); } + }; + const reihe = (namen: string[]) => api(`laufende-kosten/listen/${art}`, "PUT", { namen }); + const schliessen = async () => { + document.removeEventListener("keydown", taste, true); + box.remove(); + huelle.hidden = !warSichtbar; + await laden().catch(() => undefined); + fertig(l); + }; + const taste = (ev: KeyboardEvent) => { + if (ev.key !== "Escape") return; + ev.stopPropagation(); + ev.preventDefault(); + if (frage) { frage = null; zeichne(); } else void schliessen(); + }; + document.addEventListener("keydown", taste, true); + box.addEventListener("submit", (ev) => { + ev.preventDefault(); + const name = box.querySelector("#lk-neu")!.value.trim(); + if (!name) return; + if (l[art].some((x) => x.name.toLocaleLowerCase("de") === name.toLocaleLowerCase("de"))) return zeichne(`„${name}“ gibt es schon.`); + void versuche(() => reihe([...l[art].map((x) => x.name), name])); + }); + box.addEventListener("change", (ev) => { + const feld = ev.target as HTMLInputElement; + const von = feld.dataset.name; + if (!von) return; + const nach = feld.value.trim(); + if (!nach || nach === von) { feld.value = von; return; } + void versuche(() => api(`laufende-kosten/listen/${art}/umbenennen`, "POST", { von, nach })); + }); + box.addEventListener("click", (ev) => { + const b = (ev.target as HTMLElement).closest("button"); + if (!b) return; + if (b.dataset.reiter) { art = b.dataset.reiter as Liste; frage = null; return zeichne(); } + if (b.dataset.weg !== undefined) { + const x = l[art].find((y) => y.name === b.dataset.weg); + if (!x) return; + if (x.anzahl) { frage = x.name; return zeichne(); } + return void versuche(() => reihe(l[art].map((y) => y.name).filter((n) => n !== x.name))); + } + if (b.dataset.a === "frage-weg") { frage = null; return zeichne(); } + if (b.dataset.a === "verschieben" && frage) { + const von = frage, nach = box.querySelector("#lk-ziel")!.value; + frage = null; + return void versuche(() => api(`laufende-kosten/listen/${art}/umbenennen`, "POST", { von, nach })); + } + if (b.dataset.a === "fertig") void schliessen(); + }); + // Reihenfolge per Ziehen + box.addEventListener("dragstart", (ev) => { + const li = (ev.target as HTMLElement).closest("li[data-i]"); + if (!li) return; + ziehe = Number(li.dataset.i); + ev.dataTransfer?.setData("text/plain", li.dataset.i!); + li.classList.add("zieht"); + }); + box.addEventListener("dragover", (ev) => { if (ziehe !== null && (ev.target as HTMLElement).closest("li[data-i]")) ev.preventDefault(); }); + box.addEventListener("drop", (ev) => { + const li = (ev.target as HTMLElement).closest("li[data-i]"); + if (ziehe === null || !li) return; + ev.preventDefault(); + const ziel = Number(li.dataset.i), namen = l[art].map((x) => x.name); + const [weg] = namen.splice(ziehe, 1); + namen.splice(ziel, 0, weg!); + ziehe = null; + void versuche(() => reihe(namen)); + }); + box.addEventListener("dragend", () => { ziehe = null; box.querySelector(".zieht")?.classList.remove("zieht"); }); + void laden().then(() => zeichne(), (e) => zeichne((e as Error).message)); + }); +} const JE_JAHR: Record = { monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 }; const glatt = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €"); @@ -31,18 +163,20 @@ export function summeJeMonat(zeilen: Zeile[], h: string): number { return zeilen.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z) / 12, 0); } -// Rückgängig: jeder Schritt merkt die alten Werte (oder dass die Zeile neu war); gilt bis zum Neuladen -type Schritt = { id: string; vorher: Zeile | null }; +// Rückgängig: jeder Schritt merkt die alten Werte (oder dass die Zeile neu war, oder die gelöschte Zeile); gilt bis zum Neuladen +type Schritt = { id: string; vorher: Zeile | null; geloescht?: Zeile }; +const NEU_ANLEGEN = ["bezeichnung", "kategorie", "gruppe", "betrag", "rhythmus", "start", "ende"]; const verlauf: Schritt[] = []; let zuruecknehmen: (() => Promise) | null = null; let tasteDa = false; export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string } | null = null): Promise { - const [zeilen, e] = await Promise.all([api("laufende-kosten"), api("einstellungen").catch(() => ({} as Zeile))]); + const [zeilen, e, listen] = await Promise.all([api("laufende-kosten"), api("einstellungen").catch(() => ({} as Zeile)), + api("laufende-kosten/listen").catch((): Listen => ({ kategorie: [], gruppe: [] }))]); const h = heute(); const y = scrollY; const neuLaden = (weiter: { id: string; spalte: string } | null = null) => laufendeKostenSeite(weiter); - seite("Laufende Kosten", { text: "+ Neue Position", aktion: async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: h, rhythmus: "monatlich" })) && neuLaden() }); + seite("Laufende Kosten", { text: "+ Neue Position", aktion: async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", lkFelder(listen), null, { start: h, rhythmus: "monatlich", kategorie: kategorieOptionen(listen)[0]![0] })) && neuLaden() }); const patch = async (z: Zeile, daten: Zeile, weiter: { id: string; spalte: string } | null = null) => { const vorher = Object.fromEntries(Object.keys(daten).map((k) => [k, z[k] ?? null])); @@ -53,7 +187,8 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string zuruecknehmen = async () => { const s = verlauf.pop(); if (!s) return; - if (s.vorher) await api(`laufende-kosten/${s.id}`, "PATCH", s.vorher); + if (s.geloescht) await api("laufende-kosten", "POST", Object.fromEntries(NEU_ANLEGEN.filter((k) => s.geloescht![k] != null).map((k) => [k, s.geloescht![k]]))); + else if (s.vorher) await api(`laufende-kosten/${s.id}`, "PATCH", s.vorher); else await api(`laufende-kosten/${s.id}`, "DELETE"); await neuLaden(); }; @@ -84,7 +219,6 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string `; inhalt.append(kopf); - const kategorien = [...new Set(zeilen.map((z) => z.kategorie).filter(Boolean))].sort((a, b) => a.localeCompare(b, "de")); const sum = (l: Zeile[]) => { const m = summeJeMonat(l, h); return { jeMonat: `${euro(Math.round(m))}`, jeJahr: `${glatt(l.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0))}` }; @@ -94,7 +228,7 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string spalten: [ { id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}${endetBald(z, h) ? ' endet bald' : ""}`, bearbeiten: { art: "text", roh: (z) => z.bezeichnung } }, - { id: "kategorie", titel: "Kategorie", klasse: "optional", wert: (z) => esc(z.kategorie), bearbeiten: { art: "text", roh: (z) => z.kategorie ?? "", vorschlaege: kategorien } }, + { id: "kategorie", titel: "Kategorie", klasse: "optional", wert: (z) => esc(z.kategorie), bearbeiten: { art: "auswahl", roh: (z) => z.kategorie ?? "", optionen: [...kategorieOptionen(listen), [BEARBEITEN, "Kategorien bearbeiten …"]] } }, { id: "betrag", titel: "Betrag", art: "zahl", klasse: "zahl", wert: (z) => euro(Number(z.betrag)), sortWert: (z) => Number(z.betrag), bearbeiten: { art: "euro", roh: (z) => formatEuro(Number(z.betrag), false) } }, { id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(RHYTHMUS_TEXT[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus), @@ -111,8 +245,9 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string zeilen, vorgabe: { sort: [["naechste", "auf"]] }, gruppieren: { - arten: [{ id: "gruppe", titel: "Gruppe", wert: (z) => z.gruppe ?? "" }, { id: "kategorie", titel: "Kategorie", wert: (z) => z.kategorie ?? "" }], - vorgabe: zeilen.some((z) => z.gruppe) ? "gruppe" : "kategorie", + arten: [{ id: "gruppe", titel: "Gruppe", wert: (z) => z.gruppe ?? "", reihe: listen.gruppe.map((g) => g.name) }, + { id: "kategorie", titel: "Kategorie", wert: (z) => z.kategorie ?? "", reihe: listen.kategorie.map((k) => k.name) }], + vorgabe: zeilen.some((z) => z.gruppe) || listen.gruppe.length ? "gruppe" : "kategorie", neu: async (art, gruppe, bezeichnung) => { const r = await api("laufende-kosten", "POST", { bezeichnung, betrag: 0, rhythmus: "monatlich", start: h, [art]: gruppe || (art === "kategorie" ? "Sonstiges" : null) }); verlauf.push({ id: r.id, vorher: null }); @@ -125,6 +260,7 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string const w = wert.trim(); let daten: Zeile; if (spalte === "bezeichnung") { if (!w) throw new Error("Bitte eine Bezeichnung eintragen."); daten = { bezeichnung: w }; } + else if (spalte === "kategorie" && w === BEARBEITEN) { await listenEditor("kategorie"); return neuLaden(); } else if (spalte === "kategorie") daten = { kategorie: w || "Sonstiges" }; else if (spalte === "betrag") { try { daten = { betrag: parseEuro(w) }; } catch { throw new Error("Bitte einen Betrag wie 120,50 eintragen."); } @@ -136,11 +272,21 @@ export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string await patch(z, daten, weiter); }, oeffnen, - klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && neuLaden(), - leiste: () => ``, - fuss: () => '

Zelle anklicken = direkt ändern · Enter speichert, Esc bricht ab, Tab springt weiter · Doppelklick = alle Felder · Strg+Z = Rückgängig · Zeile am ⋮⋮ in eine andere Gruppe ziehen = Gruppe ändern

', + klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", lkFelder(listen, z), z)) && neuLaden(), + // Fehleingabe löschen wie die Zahlungen im Projekt (Henning, 20.11.2026); Strg+Z legt sie wieder an + loeschen: async (z) => { + await api(`laufende-kosten/${z.id}`, "DELETE"); + verlauf.push({ id: z.id, vorher: null, geloescht: z }); + await neuLaden(); + }, + leiste: () => ``, + fuss: () => '

Zelle anklicken = direkt ändern · Enter speichert, Esc bricht ab, Tab springt weiter · Doppelklick = alle Felder · Strg+Z = Rückgängig · Zeile am ⋮⋮ in eine andere Gruppe ziehen = Gruppe ändern · ✕ am Zeilenende = löschen

', + }); + tabelle.addEventListener("click", (ev) => { + const t = ev.target as HTMLElement; + if (t.closest('[data-lk="zurueck"]')) void zuruecknehmen?.(); + if (t.closest('[data-lk="listen"]')) void listenEditor("gruppe").then(() => neuLaden()); }); - tabelle.addEventListener("click", (ev) => { if ((ev.target as HTMLElement).closest('[data-lk="zurueck"]')) void zuruecknehmen?.(); }); const karte = document.createElement("section"); karte.className = "karte lk-karte"; karte.append(tabelle); diff --git a/src/web/liste.ts b/src/web/liste.ts index 2d7eebf..db5abc7 100644 --- a/src/web/liste.ts +++ b/src/web/liste.ts @@ -29,7 +29,8 @@ export interface Spalte { /** Zeilen in Gruppen (Henning, 21.10.2026, laufende Kosten): Kopfzeile mit Anzahl und Summen, auf- und zuklappbar */ export interface Gruppierung { - arten: { id: string; titel: string; wert: (z: Zeile) => string }[]; + /** reihe: feste Reihenfolge der Gruppen, auch leere stehen da (laufende Kosten, Henning 20.11.2026) */ + arten: { id: string; titel: string; wert: (z: Zeile) => string; reihe?: string[] }[]; /** Art beim ersten Öffnen; "" = keine */ vorgabe: string; /** „+ Position in …“ unter jeder Gruppe: legt mit der eingegebenen Bezeichnung an */ @@ -363,7 +364,10 @@ export function liste(o: ListenOptionen): HTMLElement { let zeilenHtml = zeigen.map(zeile).join(""); if (art && zeigen.length) { const schluessel = (i: number) => art.wert(z[i]!); - const namen = [...new Set(gefiltert.map(schluessel))].sort((x, y) => (x === "" ? 1 : y === "" ? -1 : x.localeCompare(y, "de", { numeric: true }))); + const reihe = art.reihe ?? []; + const platz = (k: string) => (reihe.includes(k) ? reihe.indexOf(k) : reihe.length); + // leere Gruppen nur ohne Filter und Suche + const namen = [...new Set([...(gefiltert.length === z.length ? reihe : []), ...gefiltert.map(schluessel)])].sort((x, y) => (x === "" ? 1 : y === "" ? -1 : platz(x) - platz(y) || x.localeCompare(y, "de", { numeric: true }))); const zu = new Set(g.zu ?? []); zeilenHtml = namen.map((k) => { const hier = zeigen.filter((i) => schluessel(i) === k); diff --git a/src/web/styles.css b/src/web/styles.css index a23654d..5aee4ad 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -2315,3 +2315,18 @@ ol.am-zp-lese li .z + .z { min-width: 150px; } .am-zp-zeile select { grid-column: 1; } .am-zp-zeile > .z:not(.am-zp-rest) { grid-column: 2; } } + +/* Kategorien und Gruppen der laufenden Kosten (Henning, 20.11.2026) */ +.dialog.lk-listen { width: min(440px, calc(100% - 32px)); max-height: calc(100vh - 48px); overflow-y: auto; } +.lk-reiter { display: flex; gap: 4px; margin: 0 0 10px; } +.lk-reiter button { font: inherit; border: 0; background: none; color: var(--text); padding: 6px 12px; border-radius: 8px; cursor: pointer; } +.lk-reiter button.an { background: var(--akzent-hell); color: var(--akzent); font-weight: 600; } +.dialog.lk-listen li { align-items: center; } +.dialog.lk-listen li input { flex: 1; min-width: 0; } +.dialog.lk-listen li.zieht { opacity: .5; } +.dialog.lk-listen .zeilen-griff { cursor: grab; color: var(--leise); } +.lk-anzahl { font-size: 12px; color: var(--leise); min-width: 72px; text-align: right; } +.lk-frage { margin: 10px 0 0; padding: 10px; border-radius: 8px; } +.lk-frage select { margin: 4px 4px; width: auto; max-width: 100%; display: inline-block; } +.dialog.lk-listen li .lk-weg { flex: none; padding: 6px 10px; } +.lk-frage .knoepfe { margin-top: 8px; } diff --git a/test/api.test.ts b/test/api.test.ts index a91b80a..8c2ba5d 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -76,6 +76,37 @@ describe.skipIf(!url)("API mit Datenbank", () => { expect(r3.statusCode).toBe(400); }); + it("Kategorien und Gruppen der laufenden Kosten: Liste, umbenennen, zusammenführen, löschen (Henning, 20.11.2026)", async () => { + const a = await anlegen("laufende-kosten", { bezeichnung: "LK Leasing", kategorie: "LK Leasing", gruppe: "LK Fahrzeuge", betrag: 100, rhythmus: "monatlich", start: "2026-01-01" }); + const b = await anlegen("laufende-kosten", { bezeichnung: "LK Kfz", kategorie: "LK Versicherungen", gruppe: "LK Fahrzeuge", betrag: 100, rhythmus: "monatlich", start: "2026-01-01" }); + const liste = async () => (await app.inject("/api/laufende-kosten/listen")).json() as Record; + const namen = (l: { name: string }[]) => l.map((x) => x.name).filter((n) => n.startsWith("LK ")); + // benutzte Werte stehen ohne Speichern in der Liste; neue Gruppe ohne Position + expect((await liste()).gruppe.find((g) => g.name === "LK Fahrzeuge")?.anzahl).toBe(2); + let r = await app.inject({ method: "PUT", url: "/api/laufende-kosten/listen/gruppe", payload: { namen: ["LK Werkstatt", "LK Fahrzeuge"] } }); + expect(r.statusCode).toBe(200); + expect(namen(r.json().gruppe)).toEqual(["LK Werkstatt", "LK Fahrzeuge"]); + expect(r.json().gruppe[0]).toEqual({ name: "LK Werkstatt", anzahl: 0 }); + // umbenennen ändert die Positionen mit, die Stelle in der Liste bleibt + r = await app.inject({ method: "POST", url: "/api/laufende-kosten/listen/gruppe/umbenennen", payload: { von: "LK Fahrzeuge", nach: "LK Fuhrpark" } }); + expect(namen(r.json().gruppe)).toEqual(["LK Werkstatt", "LK Fuhrpark"]); + expect((await app.inject(`/api/laufende-kosten/${a.id}`)).json().gruppe).toBe("LK Fuhrpark"); + // zusammenführen: Ziel gibt es schon + r = await app.inject({ method: "POST", url: "/api/laufende-kosten/listen/kategorie/umbenennen", payload: { von: "LK Versicherungen", nach: "LK Leasing" } }); + expect(namen(r.json().kategorie)).toEqual(["LK Leasing"]); + expect((await app.inject(`/api/laufende-kosten/${b.id}`)).json().kategorie).toBe("LK Leasing"); + // Gruppe löschen: Positionen verlieren die Gruppe + r = await app.inject({ method: "POST", url: "/api/laufende-kosten/listen/gruppe/umbenennen", payload: { von: "LK Fuhrpark", nach: "" } }); + expect(namen(r.json().gruppe)).toEqual(["LK Werkstatt"]); + expect((await app.inject(`/api/laufende-kosten/${b.id}`)).json().gruppe).toBeNull(); + // Kategorie löschen ohne Ziel: Sonstiges + r = await app.inject({ method: "POST", url: "/api/laufende-kosten/listen/kategorie/umbenennen", payload: { von: "LK Leasing", nach: "" } }); + expect((await app.inject(`/api/laufende-kosten/${a.id}`)).json().kategorie).toBe("Sonstiges"); + await app.inject({ method: "PUT", url: "/api/laufende-kosten/listen/gruppe", payload: { namen: [] } }); + await app.inject({ method: "PUT", url: "/api/laufende-kosten/listen/kategorie", payload: { namen: [] } }); + for (const x of [a, b]) await app.inject({ method: "DELETE", url: `/api/laufende-kosten/${x.id}` }); + }); + it("Protokoll hält fest, wer was geändert hat", async () => { const k = await anlegen("kontakte", { name: "Holzhandel Nord" }, "henning"); await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { telefon: "04541 123" }, headers: { "x-benutzer": "buero" } });