1 Commits

Author SHA1 Message Date
Claude
f8b3a0f3b8 0.54.0: Kategorien und Gruppen der laufenden Kosten als Standardlisten, Löschen per ✕
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-11-20 07:44:37 +00:00
11 changed files with 318 additions and 24 deletions

View File

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

View File

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

View File

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

View File

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

View File

@@ -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<FastifyInstance> {
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
registriereStammdaten(app, pool, ladeEinstellungen);
registriereKostenlisten(app, pool);
registriereStundensaetze(app, pool);
registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() });

View File

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

View File

@@ -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<string, number>): 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<Einstellungen> {
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<Map<string, number>> {
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<Record<KostenListe, ListenEintrag[]>> {
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<void> {
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 }));
});
}

View File

@@ -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<Liste, { name: string; anzahl: number }[]>;
const LISTE_TEXT: Record<Liste, [string, string]> = { 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<Listen> {
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 = `<h2>Kategorien und Gruppen</h2>
<div class="lk-reiter" role="tablist">${(["kategorie", "gruppe"] as Liste[]).map((a) => `<button type="button" role="tab" aria-selected="${a === art}" class="${a === art ? "an" : ""}" data-reiter="${a}">${LISTE_TEXT[a][1]}</button>`).join("")}</div>
<ul>${eintraege.map((x, i) => `<li draggable="true" data-i="${i}"><span class="zeilen-griff" title="Ziehen, um die Reihenfolge zu ändern">⋮⋮</span><input data-name="${esc(x.name)}" value="${esc(x.name)}" aria-label="${eins}">
<span class="lk-anzahl">${x.anzahl ? `${x.anzahl} ${x.anzahl === 1 ? "Position" : "Positionen"}` : "leer"}</span><button type="button" class="neben lk-weg" data-weg="${esc(x.name)}" title="Löschen" aria-label="${eins} löschen">✕</button></li>`).join("")}</ul>
${eintraege.length ? "" : `<p class="hinweis">Noch keine ${mehr}.</p>`}
${fr ? `<div class="warnung lk-frage">„${esc(fr.name)}“ wird noch von ${fr.anzahl} ${fr.anzahl === 1 ? "Position" : "Positionen"} benutzt. Verschieben nach
<select id="lk-ziel" aria-label="Verschieben nach">${art === "gruppe" ? '<option value="">– ohne Gruppe</option>' : ziele.includes("Sonstiges") ? "" : '<option value="Sonstiges">Sonstiges</option>'}${ziele.map((n) => `<option value="${esc(n)}">${esc(n)}</option>`).join("")}</select>
und löschen?<div class="knoepfe"><button type="button" class="neben" data-a="frage-weg">Abbrechen</button><button type="button" class="haupt" data-a="verschieben">Verschieben und löschen</button></div></div>` : ""}
<form class="neu"><input id="lk-neu" placeholder="Neue ${eins}" aria-label="Neue ${eins}"><button class="neben">Hinzufügen</button></form>
<p class="fehler">${esc(fehler)}</p>
<p class="hinweis">Umbenennen ändert alle Positionen mit. Die Reihenfolge gilt für die Auswahl und die Gruppen in der Liste.</p>
<div class="knoepfe"><button type="button" class="haupt" data-a="fertig">Fertig</button></div>`;
if (!frage) box.querySelector<HTMLInputElement>("#lk-neu")!.focus();
};
const laden = async () => { l = await api<Listen>("laufende-kosten/listen"); };
const versuche = async (fn: () => Promise<unknown>) => {
try { await fn(); await laden(); zeichne(); } catch (e) { await laden(); zeichne((e as Error).message); }
};
const reihe = (namen: string[]) => api<Listen>(`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<HTMLInputElement>("#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<HTMLElement>("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<HTMLSelectElement>("#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<HTMLElement>("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<HTMLElement>("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<string, number> = { 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<void>) | null = null;
let tasteDa = false;
export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string } | null = null): Promise<void> {
const [zeilen, e] = await Promise.all([api<Zeile[]>("laufende-kosten"), api<Zeile>("einstellungen").catch(() => ({} as Zeile))]);
const [zeilen, e, listen] = await Promise.all([api<Zeile[]>("laufende-kosten"), api<Zeile>("einstellungen").catch(() => ({} as Zeile)),
api<Listen>("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
</div>`;
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: `<b>${euro(Math.round(m))}</b>`, jeJahr: `<b>${glatt(l.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0))}</b>` };
@@ -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) ? ' <span class="lk-bald">endet bald</span>' : ""}`,
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<Zeile>("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: () => `<button type="button" class="neben" data-lk="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>`,
fuss: () => '<p class="hinweis lk-hilfe">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</p>',
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: () => `<button type="button" class="neben" data-lk="listen" title="Kategorien und Gruppen anlegen, umbenennen, sortieren, löschen">Kategorien und Gruppen …</button><button type="button" class="neben" data-lk="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>`,
fuss: () => '<p class="hinweis lk-hilfe">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</p>',
});
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);

View File

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

View File

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

View File

@@ -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<string, { name: string; anzahl: number }[]>;
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" } });