diff --git a/CHANGELOG.md b/CHANGELOG.md index f039b44..4ee61b5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,17 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.14.0 + +- Terminplan: Jedes Projekt hat unter dem Bauablauf die Abschnitte „Aufgaben“ und „Zahlungen“ mit „Einnahmen“ (grüne Rauten, die Raten aus dem Zahlungsplan) und „Ausgaben“ (rote Rauten, die Kosten von der Projektseite). Der Betrag steht in der Spalte „Ressourcen / Betrag“, die Summen stehen an den Abschnitten. +- Rauten ziehen verschiebt den Termin. Hängt eine Raute an einem Vorgang, wandert sie mit ihm: in der Spalte Vorgänger z. B. „4“ (Ende von Zeile 4), „4EE+3“ (3 Arbeitstage nach dem Ende) oder „4AA-5“ (5 Arbeitstage vor dem Anfang). Ziehen ändert nur den Abstand, die Verknüpfung bleibt. Gestellte oder bezahlte Raten und bezahlte Ausgaben stehen fest. Die gestrichelte Linie zeigt, woran sie hängt. +- Im Terminplan lassen sich Bezeichnung, Datum und Betrag direkt in der Tabelle ändern, mit „+“ am Abschnitt kommen neue Aufgaben, Raten und Ausgaben dazu. Die Raten lassen sich an der Nummer verschieben. Alles gilt sofort auch im Zahlungsplan, in der Nachkalkulation und in der Liquidität. +- Aufgaben im Terminplan sind dieselben wie in der Aufgabenliste und der Übersicht: abhaken, Fälligkeit ändern oder löschen gilt überall. Eine Aufgabe mit Projekt erscheint von selbst im Terminplan. +- Aufgaben für jedes Projekt: Unter Daten steht eine Vorlage, z. B. „Statik anfordern, 15 Arbeitstage vor dem Anfang von Abbund“, „Material bestellen, 7 vor Abbund“, „Gerüst bestellen, 5 vor Richten“, „Subunternehmer beauftragen, 10 vor dem ersten Vorgang“. Jedes beauftragte Projekt bekommt sie, sobald es den passenden Vorgang hat. Gelöschte kommen nicht wieder. Hat der Vorgang schon angefangen oder wäre die Aufgabe schon überfällig (laufende Projekte), kommt sie nicht. +- Schlussrechnung ohne Betrag: Lässt du bei einer Schlussrechnung den Betrag leer, ist sie der Rest aus Auftragswert und allen anderen Raten und rechnet sich bei jeder Änderung neu, bis sie gestellt ist. Der automatische Zahlungsplan legt die Schlussrechnung so an. +- Zahlungsplan: Zeilen am Griff ⋮⋮ verschieben (ohne Sortierung). Die Reihenfolge gilt auch im Terminplan. Filter und Ausblenden wie in jeder Tabelle. +- Projektseite: neue Kachel „Auftragswert“; ein Klick darauf ändert ihn. Das Feld heißt überall „Auftragswert netto“ statt „Umsatz netto“. + ## 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“. diff --git a/demo/kern.ts b/demo/kern.ts index db15546..410a225 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -13,6 +13,7 @@ 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"; +import m012 from "../src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -21,6 +22,7 @@ const MIGRATIONEN: [string, string][] = [ ["009_zeiterfassung.sql", m009], ["010_dauer_aus_besetzung.sql", m010], ["011_ansichten.sql", m011], + ["012_zahlungen_aufgaben_im_terminplan.sql", m012], ]; export async function starte(db: PGlite, v70?: unknown) { diff --git a/demo/main.ts b/demo/main.ts index 2f20e0a..0186594 100644 --- a/demo/main.ts +++ b/demo/main.ts @@ -98,6 +98,11 @@ async function main() { } })); + // Aufgaben-Vorlage für beauftragte Projekte, die sie noch nicht haben (z. B. nach einem Update der Testversion) + const vorlage = await app.verarbeite("POST", "/api/vorlage/anwenden"); + // auch ohne neue Aufgaben: vermerkt, was ein Projekt schon bekommen hat + if (vorlage.ok) await speichern(); + const original = window.fetch.bind(window); window.fetch = async (eingabe: RequestInfo | URL, init?: RequestInit) => { const adresse = typeof eingabe === "string" ? eingabe : eingabe instanceof URL ? eingabe.href : eingabe.url; diff --git a/package.json b/package.json index ba63113..33a108c 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.13.0", + "version": "0.14.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/domain/bezug.ts b/src/domain/bezug.ts new file mode 100644 index 0000000..ee4b7f9 --- /dev/null +++ b/src/domain/bezug.ts @@ -0,0 +1,54 @@ +// Zahlungen, Kosten und Aufgaben im Terminplan (Henning, 20.10.2026): jede kann an einem Vorgang hängen, +// am Anfang (AA) oder am Ende (EE), mit Versatz in Arbeitstagen, z. B. „4EE+3“ = 3 Arbeitstage nach dem +// Ende von Zeile 4, „3AA−5“ = 5 Arbeitstage vor ihrem Anfang. Verschiebt sich der Vorgang, wandert sie mit. + +import { type Datum } from "./datum.js"; +import { type Arbeitswoche, arbeitstageZwischen, naechsterArbeitstag, verschiebeArbeitstage } from "./kalender.js"; +import { type PlanVorgang, anfang, ende } from "./terminplan.js"; + +export type BezugArt = "AA" | "EE"; + +export interface Bezug { + vorgang_id: string | null; + bezug_art: BezugArt; + /** Arbeitstage, negativ = davor */ + bezug_tage: number; +} + +/** Datum, das sich aus dem Vorgang ergibt */ +export function bezugsTermin(v: PlanVorgang, art: BezugArt, tage: number, woche: Arbeitswoche): Datum { + const d = art === "AA" ? anfang(v, woche) : ende(v, woche); + return tage === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, tage, woche); +} + +/** Versatz in Arbeitstagen, damit das Datum `ziel` herauskommt (z. B. nach dem Ziehen der Raute) */ +export function bezugsTage(v: PlanVorgang, art: BezugArt, ziel: Datum, woche: Arbeitswoche): number { + const d = art === "AA" ? anfang(v, woche) : ende(v, woche); + const z = naechsterArbeitstag(ziel, woche); + return z >= d ? arbeitstageZwischen(d, z, woche) - 1 : -(arbeitstageZwischen(z, d, woche) - 1); +} + +/** + * „4“, „4EE+3“, „4 AA -5“, „4AA−5t“ lesen. EA zählt wie EE, AE wie AA (bei einem Termin ohne Dauer dasselbe). + * Leer heißt: nicht verknüpft. `nummern` ordnet Zeilennummern den Vorgängen zu. + */ +export function leseBezug(text: string, nummern: Map): Bezug { + const t = text.trim().replace(/[−–]/g, "-"); + if (!t) return { vorgang_id: null, bezug_art: "EE", bezug_tage: 0 }; + const m = /^(\d+)\s*(EA|AA|EE|AE)?\s*(?:([+-])\s*(\d+))?\s*(?:t|tage?|at)?\.?$/i.exec(t); + if (!m) throw new Error(`„${text}“ verstehe ich nicht. Beispiele: 4, 4EE+3, 4AA-5`); + const id = nummern.get(Number(m[1])); + if (!id) throw new Error(`Zeile ${m[1]} ist kein Vorgang.`); + const art: BezugArt = (m[2] ?? "EE").toUpperCase().startsWith("A") ? "AA" : "EE"; + return { vorgang_id: id, bezug_art: art, bezug_tage: m[3] ? (m[3] === "-" ? -1 : 1) * Number(m[4]) : 0 }; +} + +/** Anzeige wie in der Spalte Vorgänger: „4“, „4EE+3“, „4AA−5“ */ +export function bezugText(b: Partial, nummer: Map): string { + if (!b.vorgang_id) return ""; + const nr = nummer.get(b.vorgang_id); + if (nr === undefined) return ""; + const tage = Number(b.bezug_tage ?? 0); + if (b.bezug_art !== "AA" && tage === 0) return String(nr); + return `${nr}${b.bezug_art === "AA" ? "AA" : "EE"}${tage ? `${tage > 0 ? "+" : "−"}${Math.abs(tage)}` : ""}`; +} diff --git a/src/domain/projektplan.ts b/src/domain/projektplan.ts index 5c6e047..287d8d8 100644 --- a/src/domain/projektplan.ts +++ b/src/domain/projektplan.ts @@ -4,6 +4,7 @@ import { type Datum } from "./datum.js"; import { type Cent } from "./geld.js"; import { type Arbeitswoche, endeNachDauer } from "./kalender.js"; +import { type BezugArt, bezugsTermin } from "./bezug.js"; import { type Daten, type Einnahme, type Ausgabe, type Kostenart, type LaufendeKosten, projektBewegungen } from "./liquiditaet.js"; export interface BestandProjekt { @@ -27,6 +28,8 @@ export interface BestandVorgang { export interface BestandZahlung { projekt_id: string; vorgang_id?: string | null; + bezug_art?: BezugArt; + bezug_tage?: number; bezeichnung: string; netto: Cent; termin: Datum; @@ -44,6 +47,10 @@ export interface BestandKosten { termin: Datum; mit_vorsteuer: boolean; zahlungsziel_tage?: number | null; + status?: string; + vorgang_id?: string | null; + bezug_art?: BezugArt; + bezug_tage?: number; } export interface Bestand { @@ -68,6 +75,12 @@ function folgtVorgang(z: BestandZahlung): boolean { export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten = false): Daten { const ende = new Map(b.vorgaenge.map((v) => [v.id, vorgangsEnde(v, woche)])); + const vorgang = new Map(b.vorgaenge.map((v) => [v.id, v])); + // am Anfang oder Ende des Vorgangs, mit Versatz (Terminplan) + const bezogen = (x: { vorgang_id?: string | null; bezug_art?: BezugArt; bezug_tage?: number }) => { + const v = x.vorgang_id ? vorgang.get(x.vorgang_id) : undefined; + return v ? bezugsTermin({ ...v, dauer: Math.ceil(v.dauer) }, x.bezug_art ?? "EE", Number(x.bezug_tage ?? 0), woche) : undefined; + }; const einnahmen: Einnahme[] = []; const ausgaben: Ausgabe[] = []; @@ -87,14 +100,15 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten projekt: p.nummer, bezeichnung: z.bezeichnung, netto: z.netto, - termin: z.rechnungsdatum ?? (folgtVorgang(z) ? ende.get(z.vorgang_id!) : undefined) ?? z.termin, + termin: z.rechnungsdatum ?? (folgtVorgang(z) ? bezogen(z) : undefined) ?? z.termin, bezahltAm: z.bezahlt_am ?? undefined, zahlungszielTage: z.zahlungsziel_tage ?? undefined, })); const kosten: Ausgabe[] = b.kosten .filter((k) => k.projekt_id === p.id) .map((k) => ({ - projekt: p.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, + projekt: p.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, + termin: (k.status !== "bezahlt" ? bezogen(k) : undefined) ?? k.termin, mitVorsteuer: k.mit_vorsteuer, zahlungszielTage: k.zahlungsziel_tage ?? undefined, })); const r = projektBewegungen({ diff --git a/src/server/app.ts b/src/server/app.ts index 702f216..b759c9e 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -7,7 +7,7 @@ import { randomBytes, timingSafeEqual } from "node:crypto"; import { z, ZodError } from "zod"; import { type Client, type Pool, transaktion } from "./db.js"; import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js"; -import { legeZahlungsplanAn, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; +import { legeZahlungsplanAn, restNachziehen, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; import { uebersicht } from "./uebersicht.js"; import { aufgabenKalender, baustellenKalender } from "./kalender.js"; import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js"; @@ -24,6 +24,8 @@ import { istEingeteilt, registriereIch } from "./ich.js"; import { registrierePersonal } from "./personal.js"; import { registriereZeiten } from "./zeiten.js"; import { registriereUrlaub, zeitraumText } from "./urlaub.js"; +import { vorlageAnwenden } from "./vorlage.js"; +import { type BezugArt, bezugsTage } from "../domain/bezug.js"; export interface Optionen { pool: Pool; @@ -149,18 +151,37 @@ export async function baueApp(o: Optionen): Promise { // Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu // T15: auch Besetzung, Abwesenheiten und Arbeitszeitmodelle ändern die Dauer berechneter Vorgänge - const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "besetzung", "abwesenheit", "arbeitszeitmodell"]); + // Zahlungen, Kosten und Aufgaben können an Vorgängen hängen und wandern dann mit + const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "kosten", "aufgabe", "besetzung", "abwesenheit", "arbeitszeitmodell"]); // P12: Projektänderungen legen den Zahlungsplan an oder führen ihn nach; eine Rate von Hand ändern stellt ihn fest async function geplant(c: Client, tabelle: string, fn: () => Promise, bewegt: string[] = [], zahlungVon?: string): Promise { const e = await ladeEinstellungen(); if (tabelle === "projekt") { const ergebnis = await fn(); await zahlungsplaeneAutomatisch(c, { tage: e.arbeitstage }); + await restNachziehen(c); + await vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage }); return ergebnis; } if (!PLAN.has(tabelle)) return fn(); const aenderung = zahlungVon ? async () => { const r = await fn(); await zahlungsplanFest(c, zahlungVon); return r; } : fn; - return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag)).ergebnis; + return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag, e.aufgabenVorlage)).ergebnis; + } + + // Wer das Datum einer verknüpften Zahlung, Kosten oder Aufgabe ändert (z. B. die Raute im Terminplan zieht), + // ändert den Versatz zum Vorgang: sie bleibt verknüpft und wandert weiter mit + const DATUM_FELD: Record = { zahlung: "termin", kosten: "termin", aufgabe: "faellig_am" }; + async function versatzAusDatum(c: Client, tabelle: string, daten: Record, id?: string): Promise { + const feld = DATUM_FELD[tabelle]; + if (!feld || typeof daten[feld] !== "string" || daten.bezug_tage !== undefined) return; + const alt = id ? (await c.query(`select vorgang_id, bezug_art from ${tabelle} where id = $1`, [id])).rows[0] : undefined; + const vid = (daten.vorgang_id !== undefined ? daten.vorgang_id : alt?.vorgang_id) as string | null | undefined; + if (!vid) return; + const v = (await c.query("select id, start, dauer from vorgang where id = $1", [vid])).rows[0]; + if (!v) return; + const e = await ladeEinstellungen(); + const art = (daten.bezug_art ?? alt?.bezug_art ?? "EE") as BezugArt; + daten.bezug_tage = bezugsTage({ ...v, dauer: Number(v.dauer) }, art, daten[feld] as string, { tage: e.arbeitstage }); } const projektDerZahlung = async (c: Client, tabelle: string, id: string) => tabelle === "zahlung" ? (await c.query("select projekt_id from zahlung where id = $1", [id])).rows[0]?.projekt_id as string | undefined : undefined; @@ -191,9 +212,10 @@ export async function baueApp(o: Optionen): Promise { app.post(`/api/${t.pfad}`, async (req, reply) => { const daten = t.schema.parse(req.body) as Record; if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); - const spalten = felder.filter((f) => daten[f] !== undefined); const row = await transaktion(pool, benutzer(req), async (c) => { if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string }); + await versatzAusDatum(c, t.name, daten); + const spalten = felder.filter((f) => daten[f] !== undefined); return geplant(c, t.name, async () => (await c.query( spalten.length @@ -212,9 +234,10 @@ export async function baueApp(o: Optionen): Promise { if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); // T15: wer die Dauer von Hand ändert, legt sie fest (wie beim Zahlungsplan) if (t.name === "vorgang" && daten.dauer !== undefined && daten.dauer_fest === undefined) daten.dauer_fest = true; - const spalten = felder.filter((f) => daten[f] !== undefined); - if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); + if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" }); const row = await transaktion(pool, benutzer(req), async (c) => { + await versatzAusDatum(c, t.name, daten, id); + const spalten = felder.filter((f) => daten[f] !== undefined); if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) { const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0]; if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id); @@ -247,10 +270,19 @@ export async function baueApp(o: Optionen): Promise { app.put("/api/einstellungen", async (req) => { const neu = EinstellungenSchema.parse(req.body); - await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu])); + await transaktion(pool, benutzer(req), async (c) => { + await c.query("update einstellungen set daten = $1", [neu]); + await vorlageAnwenden(c, neu.aufgabenVorlage, { tage: neu.arbeitstage }); + }); return neu; }); + // Aufgaben-Vorlage auf alle beauftragten Projekte anwenden (Testversion nach dem Laden, Server nach dem Update) + app.post("/api/vorlage/anwenden", async (req) => { + const e = await ladeEinstellungen(); + return { neu: await transaktion(pool, benutzer(req), (c) => vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage })) }; + }); + const LiquiAnfrage = z.object({ ansicht: z.enum(["woche", "monat"]).default("woche"), start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 42f76a9..1feaeab 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -1,5 +1,23 @@ import { z } from "zod"; +// Aufgaben, die jedes beauftragte Projekt von selbst bekommt (Henning, 20.10.2026), an einem Vorgang festgemacht: +// bezug ist ein Wort aus dem Vorgangsnamen („Abbund“), leer = der erste Vorgang des Projekts +export const VorlageEintrag = z.object({ + id: z.string().regex(/^[a-z0-9-]{1,40}$/), + text: z.string().trim().min(1).max(200), + bezug: z.string().trim().max(60).default(""), + art: z.enum(["AA", "EE"]).default("AA"), + tage: z.number().int().min(-500).max(500).default(0), + kategorie_id: z.string().nullable().default(null), +}); +export type VorlageEintrag = z.infer; +export const STANDARD_VORLAGE: VorlageEintrag[] = [ + { id: "statik", text: "Statik anfordern", bezug: "Abbund", art: "AA", tage: -15, kategorie_id: null }, + { id: "material", text: "Material bestellen", bezug: "Abbund", art: "AA", tage: -7, kategorie_id: null }, + { id: "geruest", text: "Gerüst bestellen", bezug: "Richten", art: "AA", tage: -5, kategorie_id: null }, + { id: "sub", text: "Subunternehmer beauftragen", bezug: "", art: "AA", tage: -10, kategorie_id: null }, +]; + export const EinstellungenSchema = z.object({ arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]), stundenProTag: z.number().positive().default(8), @@ -31,6 +49,7 @@ export const EinstellungenSchema = z.object({ pausenabzug: z.enum(["bis_grenze", "voll"]).default("bis_grenze"), // geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden kalenderToken: z.string().min(20).nullable().default(null), + aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE), }); export type Einstellungen = z.infer; diff --git a/src/server/index.ts b/src/server/index.ts index c23d99a..14c334a 100644 --- a/src/server/index.ts +++ b/src/server/index.ts @@ -1,5 +1,7 @@ import { randomBytes } from "node:crypto"; -import { erstellePool } from "./db.js"; +import { erstellePool, transaktion } from "./db.js"; +import { EinstellungenSchema } from "./einstellungen.js"; +import { vorlageAnwenden } from "./vorlage.js"; import { migriere } from "./migrate.js"; import { baueApp } from "./app.js"; import { Nextcloud } from "./nextcloud.js"; @@ -12,6 +14,12 @@ if (!url) { const pool = erstellePool(url); await migriere(pool, (t) => console.log(t)); +// Aufgaben-Vorlage für Projekte, die seit dem letzten Start nichts geändert haben (z. B. nach einem Update) +{ + const e = EinstellungenSchema.parse((await pool.query("select daten from einstellungen limit 1")).rows[0]?.daten ?? {}); + const neu = await transaktion(pool, "system", (c) => vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage })); + if (neu) console.log(`Aufgaben-Vorlage: ${neu} neue Aufgaben angelegt`); +} // P10: Ordner der Projekte; gleicher Zugang wie für die Sicherung, eigene Adresse const { NEXTCLOUD_PROJEKTE_URL: ncUrl, NEXTCLOUD_BENUTZER: ncBenutzer, NEXTCLOUD_PASSWORT: ncPasswort } = process.env; const nextcloud = ncUrl && ncBenutzer && ncPasswort ? new Nextcloud({ url: ncUrl, benutzer: ncBenutzer, passwort: ncPasswort }) : undefined; diff --git a/src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql b/src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql new file mode 100644 index 0000000..7d446a3 --- /dev/null +++ b/src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql @@ -0,0 +1,29 @@ +-- Zahlungen, Kosten und Aufgaben im Terminplan (Henning, 20.10.2026): jede kann an einem Vorgang hängen, +-- am Anfang (AA) oder Ende (EE) mit Versatz in Arbeitstagen, und wandert mit ihm. +-- Raten hingen schon bisher am Ende ihres Vorgangs (vorgang_id): das ist EE ohne Versatz. +alter table zahlung + add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')), + add column bezug_tage integer not null default 0; +alter table kosten + add column vorgang_id uuid references vorgang (id) on delete set null, + add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')), + add column bezug_tage integer not null default 0; +alter table aufgabe + add column vorgang_id uuid references vorgang (id) on delete set null, + add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')), + add column bezug_tage integer not null default 0, + -- aus welchem Eintrag der Aufgaben-Vorlage sie stammt + add column vorlage text; + +-- Welche Einträge der Aufgaben-Vorlage ein Projekt schon bekommen hat; wer eine solche Aufgabe löscht, +-- bekommt sie nicht wieder +create table projekt_vorlage ( + id uuid primary key default gen_random_uuid(), + projekt_id uuid not null references projekt (id) on delete cascade, + vorlage text not null, + angelegt_am timestamptz not null default now(), + unique (projekt_id, vorlage) +); + +-- Schlussrechnung ohne eigenen Betrag (Henning, 20.10.2026): Rest aus Auftragswert minus alle anderen Raten +alter table zahlung add column rest boolean not null default false; diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts index 1d8dc44..1a209ef 100644 --- a/src/server/tabellen.ts +++ b/src/server/tabellen.ts @@ -128,6 +128,9 @@ export const TABELLEN: Tabelle[] = [ bezahlt_am: datum.nullable().optional(), reihenfolge: z.number().int().optional(), zahlungsziel_tage: z.number().int().min(0).nullable().optional(), + bezug_art: z.enum(["AA", "EE"]).optional(), + bezug_tage: z.number().int().min(-500).max(500).optional(), + rest: z.boolean().optional(), }), }, { @@ -144,6 +147,9 @@ export const TABELLEN: Tabelle[] = [ mit_vorsteuer: z.boolean().optional(), status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(), zahlungsziel_tage: z.number().int().min(0).nullable().optional(), + vorgang_id: id.nullable().optional(), + bezug_art: z.enum(["AA", "EE"]).optional(), + bezug_tage: z.number().int().min(-500).max(500).optional(), }), }, { @@ -181,6 +187,9 @@ export const TABELLEN: Tabelle[] = [ kontakt_id: id.nullable().optional(), kategorie_id: id.nullable().optional(), erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(), + vorgang_id: id.nullable().optional(), + bezug_art: z.enum(["AA", "EE"]).optional(), + bezug_tage: z.number().int().min(-500).max(500).optional(), }), }, // Stufe 2: Personal (M1, M8, M4, M10) @@ -243,4 +252,5 @@ export const TABELLEN: Tabelle[] = [ export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] = [ { name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" }, { name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" }, + { name: "projekt_vorlage", pfad: "projekt_vorlagen", sortierung: "projekt_id, vorlage" }, ]; diff --git a/src/server/terminplan.ts b/src/server/terminplan.ts index 8b475de..fce6c57 100644 --- a/src/server/terminplan.ts +++ b/src/server/terminplan.ts @@ -1,6 +1,6 @@ // Terminplan auf dem Server: Laden für das Gantt und Neuplanung der Nachfolger nach jeder // Änderung an Vorgängen oder Verknüpfungen, in derselben Transaktion. -import { zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; +import { restNachziehen, zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; import type { Client, Pool } from "./db.js"; import type { Arbeitswoche } from "../domain/kalender.js"; import { kuerzel, ueberschneidungen } from "../domain/einsatz.js"; @@ -8,6 +8,9 @@ import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVor import { type KapBesetzung, type Personaldaten, auslastung, dauerNachBesetzung, reduzierteTage } from "../domain/kapazitaet.js"; import { ladePersonal } from "./personal.js"; import { plusTage } from "../domain/datum.js"; +import { type BezugArt, bezugsTermin } from "../domain/bezug.js"; +import type { VorlageEintrag } from "./einstellungen.js"; +import { vorlageAnwenden } from "./vorlage.js"; export class PlanFehler extends Error { statusCode = 409; @@ -38,7 +41,7 @@ async function ladeKapazitaet(c: Client | Pool, stundenProTag: number): Promise< * Gibt die IDs der verschobenen Vorgänge zurück. */ export async function mitNeuplanung( - c: Client, woche: Arbeitswoche, aenderung: () => Promise, bewegt: string[] = [], stundenProTag = 8, + c: Client, woche: Arbeitswoche, aenderung: () => Promise, bewegt: string[] = [], stundenProTag = 8, vorlage?: VorlageEintrag[], ): Promise<{ ergebnis: T; verschoben: string[] }> { const vorher = await ladeStand(c); const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche); @@ -58,19 +61,31 @@ export async function mitNeuplanung( } for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]); for (const [id, dauer] of dauern) await c.query("update vorgang set dauer = $2 where id = $1", [id, dauer]); - await zahlungenNachziehen(c, woche); + await bezuegeNachziehen(c, woche); await zahlungsplaeneAutomatisch(c, woche); + await restNachziehen(c); + if (vorlage) await vorlageAnwenden(c, vorlage, woche); return { ergebnis, verschoben: [...new Set([...starts.keys(), ...dauern.keys()])] }; } -/** Geplante Raten, die an einem Vorgang hängen, werden mit dessen Ende fällig und wandern mit ihm. */ -export async function zahlungenNachziehen(c: Client, woche: Arbeitswoche): Promise { - const r = await c.query<{ id: string; termin: string; start: string; dauer: number }>( - `select z.id, z.termin, v.start, v.dauer from zahlung z join vorgang v on v.id = z.vorgang_id - where coalesce(z.status, 'geplant') = 'geplant'`); - for (const z of r.rows) { - const e = ende({ id: z.id, start: z.start, dauer: Number(z.dauer) }, woche); - if (e !== z.termin) await c.query("update zahlung set termin = $2 where id = $1", [z.id, e]); +/** + * Was an einem Vorgang hängt, wandert mit ihm: geplante Raten, nicht bezahlte Kosten und offene Aufgaben. + * Bezug am Anfang (AA) oder Ende (EE) mit Versatz in Arbeitstagen. + */ +export async function bezuegeNachziehen(c: Client, woche: Arbeitswoche): Promise { + const teile: [string, string, string][] = [ + ["zahlung", "termin", "coalesce(x.status, 'geplant') = 'geplant'"], + ["kosten", "termin", "x.status <> 'bezahlt'"], + ["aufgabe", "faellig_am", "x.erledigt_am is null"], + ]; + for (const [tabelle, feld, offen] of teile) { + const r = await c.query<{ id: string; datum: string | null; bezug_art: BezugArt; bezug_tage: number; vid: string; start: string; dauer: number }>( + `select x.id, x.${feld} as datum, x.bezug_art, x.bezug_tage, v.id as vid, v.start, v.dauer + from ${tabelle} x join vorgang v on v.id = x.vorgang_id where ${offen}`); + for (const z of r.rows) { + const soll = bezugsTermin({ id: z.vid, start: z.start, dauer: Number(z.dauer) }, z.bezug_art, Number(z.bezug_tage), woche); + if (soll !== z.datum) await c.query(`update ${tabelle} set ${feld} = $2 where id = $1`, [z.id, soll]); + } } } @@ -84,7 +99,7 @@ export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; v /** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag = 8) { - const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen] = await Promise.all([ + const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben] = await Promise.all([ pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, p.umsatz_netto, p.zahlungsplan, k.name as bauherr from projekt p left join kontakt k on k.id = p.bauherr_id order by p.reihenfolge, p.nummer`), pool.query("select id, projekt_id, name, ist_meilenstein, reihenfolge from abschnitt order by reihenfolge, name"), @@ -93,7 +108,12 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag pool.query(`select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.personen, b.freigegeben, k.name, k.firma, k.rolle from besetzung b left join kontakt k on k.id = b.kontakt_id order by b.angelegt_am`), pool.query("select id, name, firma, rolle from kontakt where rolle in ('mitarbeiter', 'subunternehmer') order by rolle, name"), - pool.query("select id, projekt_id, vorgang_id, art, bezeichnung, netto, termin, status from zahlung order by termin, reihenfolge"), + pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status, rest, reihenfolge from zahlung order by reihenfolge, termin"), + pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status from kosten order by termin, bezeichnung"), + // Aufgaben eines Projekts stehen im Terminplan in dessen Abschnitt „Aufgaben“ + pool.query(`select a.id, a.projekt_id, a.vorgang_id, a.bezug_art, a.bezug_tage, a.text, a.faellig_am, a.erledigt_am, a.kategorie_id, g.name as kategorie + from aufgabe a left join aufgabe_kategorie g on g.id = a.kategorie_id where a.projekt_id is not null + order by a.faellig_am nulls last, a.angelegt_am`), ]); const kap = await ladeKapazitaet(pool, stundenProTag); const vs = vorgaenge.rows.map((v) => { @@ -130,6 +150,8 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag besetzungen: bs, leute: leute.rows, zahlungen: zahlungen.rows, + kosten: kosten.rows, + aufgaben: aufgaben.rows, ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })), arbeitstage: woche.tage, team, diff --git a/src/server/vorlage.ts b/src/server/vorlage.ts new file mode 100644 index 0000000..eaa36b3 --- /dev/null +++ b/src/server/vorlage.ts @@ -0,0 +1,50 @@ +// Aufgaben-Vorlage (Henning, 20.10.2026): jedes beauftragte Projekt bekommt Aufgaben wie „Material bestellen, +// 7 Arbeitstage vor Abbund“. Sie hängen am passenden Vorgang, wandern mit ihm und stehen in den Aufgaben, +// in der Übersicht und im Terminplan. Jeder Eintrag kommt je Projekt nur einmal: wer die Aufgabe löscht, +// bekommt sie nicht wieder. +import type { Client } from "./db.js"; +import type { VorlageEintrag } from "./einstellungen.js"; +import type { Arbeitswoche } from "../domain/kalender.js"; +import { anfang } from "../domain/terminplan.js"; +import { bezugsTermin } from "../domain/bezug.js"; + +/** Projekte, die Vorlage-Aufgaben bekommen */ +export const MIT_VORLAGE = ["auftrag", "ausfuehrung"]; + +/** + * Legt fehlende Vorlage-Aufgaben an. Ein Eintrag wartet, bis das Projekt einen passenden Vorgang hat. + * Hat dieser Vorgang schon angefangen oder wäre die Aufgabe schon überfällig (laufende Projekte), gilt sie als + * erledigt und wird nur vermerkt. + * Gibt die Zahl der neuen Aufgaben zurück. + */ +export async function vorlageAnwenden(c: Client, vorlage: VorlageEintrag[], woche: Arbeitswoche, heute = new Date().toISOString().slice(0, 10)): Promise { + if (!vorlage.length) return 0; + const projekte = (await c.query<{ id: string }>("select id from projekt where status = any($1)", [MIT_VORLAGE])).rows; + if (!projekte.length) return 0; + const vs = (await c.query<{ id: string; projekt_id: string; name: string; start: string; dauer: number }>( + `select v.id, a.projekt_id, v.name, v.start, v.dauer from vorgang v join abschnitt a on a.id = v.abschnitt_id + where a.projekt_id = any($1)`, [projekte.map((p) => p.id)])).rows.map((v) => ({ ...v, dauer: Number(v.dauer) })); + const schon = new Set((await c.query<{ projekt_id: string; vorlage: string }>("select projekt_id, vorlage from projekt_vorlage")).rows.map((r) => `${r.projekt_id}/${r.vorlage}`)); + let neu = 0; + for (const p of projekte) { + const eigene = vs.filter((v) => v.projekt_id === p.id).map((v) => ({ ...v, anfang: anfang(v, woche) })).sort((a, b) => a.anfang.localeCompare(b.anfang)); + if (!eigene.length) continue; + for (const e of vorlage) { + if (schon.has(`${p.id}/${e.id}`)) continue; + const wort = e.bezug.trim().toLowerCase(); + const anker = wort ? eigene.find((v) => v.name.toLowerCase().includes(wort)) : eigene[0]; + if (!anker) continue; + await c.query("insert into projekt_vorlage (projekt_id, vorlage) values ($1, $2)", [p.id, e.id]); + schon.add(`${p.id}/${e.id}`); + // laufende Projekte: was schon hätte erledigt sein müssen, ist es vermutlich auch + const termin = bezugsTermin(anker, e.art, e.tage, woche); + if (anker.anfang < heute || termin < heute) continue; + await c.query( + `insert into aufgabe (text, projekt_id, kategorie_id, vorgang_id, bezug_art, bezug_tage, faellig_am, vorlage) + values ($1, $2, (select id from aufgabe_kategorie where id::text = $3), $4, $5, $6, $7, $8)`, + [e.text, p.id, e.kategorie_id ?? "", anker.id, e.art, e.tage, termin, e.id]); + neu++; + } + } + return neu; +} diff --git a/src/server/zahlungsplan.ts b/src/server/zahlungsplan.ts index 373da52..b195ab2 100644 --- a/src/server/zahlungsplan.ts +++ b/src/server/zahlungsplan.ts @@ -20,8 +20,8 @@ export async function legeZahlungsplanAn(c: Client, projektId: string, umsatz: n const neu = []; for (const [i, z] of (await vorschlag(c, projektId, umsatz, woche)).entries()) { neu.push((await c.query( - `insert into zahlung (projekt_id, vorgang_id, art, bezeichnung, netto, termin, status, reihenfolge) values ($1, $2, $3, $4, $5, $6, 'geplant', $7) returning *`, - [projektId, z.vorgang_id, z.art, z.bezeichnung, z.netto, z.termin, i])).rows[0]); + `insert into zahlung (projekt_id, vorgang_id, art, bezeichnung, netto, termin, status, reihenfolge, rest) values ($1, $2, $3, $4, $5, $6, 'geplant', $7, $8) returning *`, + [projektId, z.vorgang_id, z.art, z.bezeichnung, z.netto, z.termin, i, z.art === "schluss"])).rows[0]); } await c.query("update projekt set zahlungsplan = 'auto' where id = $1", [projektId]); return neu; @@ -57,3 +57,14 @@ export async function zahlungsplaeneAutomatisch(c: Client, woche: Arbeitswoche): export async function zahlungsplanFest(c: Client, projektId: string): Promise { await c.query("update projekt set zahlungsplan = 'fest' where id = $1 and zahlungsplan is distinct from 'fest'", [projektId]); } + +/** + * Schlussrechnung ohne eigenen Betrag (Henning, 20.10.2026): solange sie geplant ist, ist sie der Rest aus + * Auftragswert und allen anderen Raten (gestellt, bezahlt und noch geplant), damit nichts doppelt zählt. + */ +export async function restNachziehen(c: Client): Promise { + await c.query(`update zahlung z set netto = r.soll from ( + select z2.id, greatest(0, coalesce(p.umsatz_netto, 0) - coalesce((select sum(a.netto) from zahlung a where a.projekt_id = z2.projekt_id and a.id <> z2.id), 0)) as soll + from zahlung z2 join projekt p on p.id = z2.projekt_id where z2.rest and z2.status = 'geplant') r + where z.id = r.id and z.netto <> r.soll`); +} diff --git a/src/web/app.ts b/src/web/app.ts index acac2f7..4ebeda5 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -60,7 +60,7 @@ async function projektFelder(): Promise { { name: "bauherr_id", titel: "Kunde (Bauherr)", art: "auswahl", optionen: [["", "–"], ...sortiert.map((k): [string, string] => [k.id, k.name])] }, { name: "baustelle_strasse", titel: "Baustelle: Straße" }, { name: "baustelle_plz", titel: "Baustelle: PLZ" }, { name: "baustelle_ort", titel: "Baustelle: Ort" }, { name: "vertragsart", titel: "Vertragsart", art: "auswahl", optionen: VERTRAGSARTEN }, { name: "abnahme_am", titel: "Abnahme am", art: "datum" }, - { name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" }, + { name: "umsatz_netto", titel: "Auftragswert netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" }, { name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" }, { name: "notiz", titel: "Beschreibung", art: "langtext" }, ]; @@ -90,7 +90,7 @@ async function projekte(): Promise { { 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: "umsatz", titel: "Auftragswert", 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" }, ], @@ -107,7 +107,8 @@ const KOSTENARTEN: [string, string][] = [["material", "Material"], ["fremd", "Fr const KOSTENSTATUS: [string, string][] = [["geplant", "geplant"], ["bestellt", "bestellt"], ["bezahlt", "bezahlt"]]; const ZAHLUNG_FELDER: Feld[] = [ { name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "art", titel: "Art", art: "auswahl", optionen: ZAHLUNGSARTEN }, - { name: "netto", titel: "Betrag netto", art: "euro", pflicht: true }, { name: "termin", titel: "Termin", art: "datum", pflicht: true }, + { name: "netto", titel: "Betrag netto", art: "euro", hilfe: "Bei der Schlussrechnung leer lassen: dann ist sie der Rest aus Auftragswert und allen anderen Raten." }, + { name: "termin", titel: "Termin", art: "datum", pflicht: true }, { name: "status", titel: "Status", art: "auswahl", optionen: ZAHLUNGSSTATUS }, { name: "rechnungsdatum", titel: "Rechnungsdatum", art: "datum" }, { name: "bezahlt_am", titel: "Bezahlt am", art: "datum" }, ]; @@ -117,6 +118,7 @@ const KACHEL_SYMBOL: Record = { zeitraum: '', baustelle: '', auftrag: '', + auftragswert: '', stunden: '', ordner: '', beschreibung: '', @@ -190,6 +192,8 @@ async function projektSeite(id: string): Promise { ziel.innerHTML = `
${kachel("stunden", "Arbeitsstunden", `

${stundenText(ist)}

/ ${soll ? stundenText(soll) : "0:00 Std."}

${anteil ? `` : ""}${anteil === null ? "– %" : `${anteil} %`}
`)} + ${kachel("auftragswert", "Auftragswert", `

netto

+

${eigeneZahlungen.length ? `${eigeneZahlungen.length} ${eigeneZahlungen.length === 1 ? "Rate" : "Raten"} im ${p.zahlungsplan === "auto" ? ", passen sich an" : ""}` : "Mit dem Auftragswert und Terminen entsteht der Zahlungsplan."}

`)} ${kachel("kunde", "Kunde", kunde ? `

${esc(kunde.name)}${kunde.firma ? `
${esc(kunde.firma)}` : ""}

${[kunde.telefon && `${esc(kunde.telefon)}`, kunde.email && esc(kunde.email)].filter(Boolean).join("
")}

` @@ -286,7 +290,28 @@ async function projektSeite(id: string): Promise { const vorgangName = (vid: string) => vorgaenge.find((x: Zeile) => x.id === vid)?.name ?? ""; const felder: Feld[] = [...ZAHLUNG_FELDER]; felder.splice(4, 0, { name: "vorgang_id", titel: "Fällig nach Vorgang", art: "auswahl", optionen: [["", "– Termin von Hand –"], ...vorgaenge.map((v: Zeile): [string, string] => [v.id, v.name])] }); - knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", felder, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden()); + // Schlussrechnung ohne Betrag: Rest aus Auftragswert und den anderen Raten (Henning, 20.10.2026) + const zahlungBearbeiten = async (z: Zeile | null) => { + const werte = z ? { ...z, netto: z.rest && z.status === "geplant" ? null : z.netto } : { projekt_id: id, art: "abschlag", status: "geplant", termin: heute(), netto: null }; + const e = await dialog(z ? "Zahlung bearbeiten" : "Neue Zahlung", felder, werte, !!z); + if (!e) return; + if (e.aktion === "loeschen") { await api(`zahlungen/${z!.id}`, "DELETE"); return neuLaden(); } + const d = { ...e.daten }; + if (d.netto === null) { + if (d.art !== "schluss") { hinweis.text = "Ohne Betrag geht nur die Schlussrechnung (Rest aus dem Auftragswert). Die Zahlung wurde nicht gespeichert."; return neuLaden(); } + Object.assign(d, { netto: 0, rest: true }); + } else d.rest = false; + // anderer Vorgang gewählt: fällig am Ende dieses Vorgangs + if (d.vorgang_id && d.vorgang_id !== z?.vorgang_id) Object.assign(d, { bezug_art: "EE", bezug_tage: 0 }); + if (z) await api(`zahlungen/${z.id}`, "PATCH", d); + else await api("zahlungen", "POST", { projekt_id: id, reihenfolge: eigeneZahlungen.length, ...d }); + neuLaden(); + }; + knopf("+ Zahlung", () => void zahlungBearbeiten(null)); + const bezugText = (z: Zeile) => { + const n = Number(z.bezug_tage ?? 0), name = esc(vorgangName(z.vorgang_id)); + return n === 0 && z.bezug_art !== "AA" ? `nach ${name}` : `${Math.abs(n)} AT ${n < 0 ? "vor" : "nach"} ${z.bezug_art === "AA" ? "Anfang" : "Ende"} ${name}`; + }; const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0); const info = document.createElement("div"); info.className = "vorschlag"; @@ -307,11 +332,16 @@ async function projektSeite(id: string): Promise { schluessel: "projekt-zahlungen", klein: true, einheit: ["Rate", "Raten"], spalten: [ { id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}` }, - { id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `nach ${esc(vorgangName(z.vorgang_id))}` : ""}` }, + { id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `${bezugText(z)}` : ""}` }, { id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `${esc(z.status)}`, klasse: "optional" }, - { id: "netto", titel: "Netto", art: "zahl", wert: (z) => euro(z.netto), sortWert: (z) => z.netto, klasse: "zahl" }, + { id: "netto", titel: "Netto", art: "zahl", wert: (z) => `${euro(z.netto)}${z.rest ? 'Rest' : ""}`, sortWert: (z) => z.netto, klasse: "zahl" }, ], - zeilen: eigeneZahlungen, klick: async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden(), + zeilen: eigeneZahlungen, klick: (z) => void zahlungBearbeiten(z), + // Reihenfolge wie im Terminplan unter „Einnahmen“; von Hand verschoben ist der Plan fest + verschieben: async (ids) => { + for (const [i, zid] of ids.entries()) if (eigeneZahlungen.find((x) => x.id === zid)?.reihenfolge !== i) await api(`zahlungen/${zid}`, "PATCH", { reihenfolge: i }); + neuLaden(); + }, })); teil.insertAdjacentHTML("beforeend", `

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

`); } @@ -357,6 +387,13 @@ async function projektSeite(id: string): Promise { if (r.ordner_fehler) hinweis.text = r.ordner_fehler; return neuLaden(); } + if (a === "auftragswert") { + const e = await dialog("Auftragswert ändern", [{ name: "umsatz_netto", titel: "Auftragswert netto", art: "euro", + hilfe: p.zahlungsplan === "auto" ? "Der automatische Zahlungsplan rechnet die Raten neu." : "Eine Schlussrechnung ohne eigenen Betrag rechnet sich neu; andere Raten änderst du im Zahlungsplan." }], p, false); + if (e?.aktion !== "speichern") return; + await api(`projekte/${id}`, "PATCH", { umsatz_netto: e.daten.umsatz_netto ?? 0 }); + return neuLaden(); + } if (a === "zahlungsplan") { try { await api(`projekte/${id}/zahlungsplan`, "POST"); neuLaden(); } catch (err) { teil.querySelector(".fehler")!.textContent = (err as Error).message; } return; @@ -818,6 +855,64 @@ async function daten(): Promise { daten(); }; inhalt.appendChild(knopf); + await vorlageEditor(e); +} + +// Aufgaben, die jedes beauftragte Projekt bekommt (Henning, 20.10.2026), z. B. „Material bestellen, 7 Arbeitstage vor Abbund“ +async function vorlageEditor(e: Zeile): Promise { + const kategorien = await api("aufgaben-kategorien"); + const bereich = document.createElement("section"); + bereich.className = "vorlage"; + inhalt.appendChild(bereich); + let zeilen: Zeile[] = (e.aufgabenVorlage ?? []).map((v: Zeile) => ({ ...v })); + const zeichne = (meldung = "") => { + bereich.innerHTML = `

Aufgaben für jedes Projekt

+

Jedes beauftragte Projekt bekommt diese Aufgaben. Sie hängen am ersten Vorgang, dessen Name das Stichwort enthält (ohne Stichwort: am ersten Vorgang des Projekts), wandern mit ihm und stehen in den Aufgaben, der Übersicht und im Terminplan unter „Aufgaben“. Gibt es den Vorgang noch nicht, kommt die Aufgabe, sobald er angelegt ist. Hat er schon angefangen oder wäre die Aufgabe schon überfällig, kommt sie nicht mehr.

+
+ ${zeilen.map((v, i) => ` + + + + + + + `).join("")} +
AufgabeArbeitstageVorgang mit StichwortKategorie
+

${esc(meldung)}

`; + }; + const lies = () => { + bereich.querySelectorAll("tbody tr").forEach((tr) => { + const v = zeilen[Number(tr.dataset.i)]!; + const feld = (f: string) => tr.querySelector(`[data-f="${f}"]`)!.value.trim(); + const tage = Math.abs(Math.round(Number(feld("tage").replace(",", ".")) || 0)); + Object.assign(v, { text: feld("text"), bezug: feld("bezug"), art: feld("art"), tage: feld("richtung") === "vor" ? -tage : tage, kategorie_id: feld("kategorie_id") || null }); + }); + }; + bereich.addEventListener("click", async (ev) => { + const t = ev.target as HTMLElement; + if (t.dataset.weg) { lies(); zeilen.splice(Number(t.dataset.weg), 1); return zeichne(); } + if (t.dataset.a === "dazu") { lies(); zeilen.push({ id: "", text: "", bezug: "", art: "AA", tage: -5, kategorie_id: null }); zeichne(); bereich.querySelector("tbody tr:last-child input")?.focus(); return; } + if (t.dataset.a === "sichern") { + lies(); + zeilen = zeilen.filter((v) => v.text); + // neue Einträge bekommen eine feste Kennung; damit weiß jedes Projekt, was es schon bekommen hat + const vergeben = new Set(zeilen.map((v) => v.id).filter(Boolean)); + for (const v of zeilen) if (!v.id) { + const basis = v.text.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30) || "aufgabe"; + let id = basis, n = 2; + while (vergeben.has(id)) id = `${basis}-${n++}`; + vergeben.add(id); + v.id = id; + } + try { + const vorher = (await api("aufgaben")).length; + Object.assign(e, await api("einstellungen", "PUT", { ...e, aufgabenVorlage: zeilen })); + const neu = (await api("aufgaben")).length - vorher; + zeichne(`Gespeichert.${neu > 0 ? ` ${neu} neue ${neu === 1 ? "Aufgabe" : "Aufgaben"} in laufenden Projekten.` : ""}`); + } catch (err) { zeichne((err as Error).message); } + } + }); + zeichne(); } // Reihenfolge wie die Module im Lastenheft (Henning, 18.10.2026); Benutzer und Daten immer zuletzt. diff --git a/src/web/gantt.ts b/src/web/gantt.ts index 655b0db..f034e22 100644 --- a/src/web/gantt.ts +++ b/src/web/gantt.ts @@ -4,7 +4,8 @@ // anderen Vorgänge sichtbar bleiben; die Bearbeitungsspalten lassen sich ausblenden. // Die Neuplanung der Nachfolger macht der Server. -import { formatEuro } from "../domain/geld.js"; +import { formatEuro, parseEuro } from "../domain/geld.js"; +import { bezugText, leseBezug } from "../domain/bezug.js"; import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js"; import { wer } from "../domain/einsatz.js"; import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag } from "../domain/kalender.js"; @@ -39,6 +40,9 @@ interface Plan { leute: Zeile[]; ueberschneidungen: Zeile[]; zahlungen: Zeile[]; + /** Ausgaben (Kosten) und Aufgaben der Projekte, im Abschnitt „Zahlungen“ und „Aufgaben“ */ + kosten?: Zeile[]; + aufgaben?: Zeile[]; arbeitstage: number[]; team?: string[]; auslastung?: { ab: Datum; geplant: number; verfuegbar: number; personen: { kontakt_id: string; geplant: number; verfuegbar: number }[] }[]; @@ -95,7 +99,18 @@ export const dauerText = (n: number) => `${n} ${n === 1 ? "Tag" : "Tage"}`; /** Nach dem Speichern und Neuzeichnen hier weiter bearbeiten (Enter: nächste Zeile, Tab: nächste Spalte) */ let weiter: { id: string; feld: string } | null = null; -const FELDER = ["name", "dauer", "vg", "start", "ende"]; +/** In welcher Spalte ein Feld steht; Enter springt in dieselbe Spalte der nächsten Zeile */ +const SPALTE_VON: Record = { + name: "name", dauer: "dauer", vg: "vg", start: "anfang", ende: "ende", + "t-text": "name", "t-vg": "vg", "t-datum": "anfang", + "z-name": "name", "z-vg": "vg", "z-datum": "anfang", "z-betrag": "res", + "k-name": "name", "k-vg": "vg", "k-datum": "anfang", "k-betrag": "res", +}; +/** Zahlungen, Kosten und Aufgaben im Terminplan (Henning, 20.10.2026): Art im Plan → Pfad der API und Datumsfeld */ +const POSTEN: Record<"t" | "z" | "k", { pfad: string; datum: string }> = { + t: { pfad: "aufgaben", datum: "faellig_am" }, z: { pfad: "zahlungen", datum: "termin" }, k: { pfad: "kosten", datum: "termin" }, +}; +const GRUPPE_NAME: Record = { aufg: "Aufgaben", zahl: "Zahlungen", ein: "Einnahmen", aus: "Ausgaben" }; /** „5, 7AA+2“ (Zeilennummern) → Liste von Verknüpfungen; wirft, wenn in der Zeile kein Vorgang steht. */ export function leseVorgaenger(text: string, nummern: Map): { vorgaenger_id: string; art: string; verzoegerung: number }[] { @@ -147,7 +162,8 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise aus.length ? `` : ``; - const alleIds = new Set([...plan.projekte, ...plan.abschnitte, ...plan.vorgaenge].map((x) => x.id as string)); + const alleIds = new Set([...plan.projekte, ...plan.abschnitte, ...plan.vorgaenge, ...(plan.aufgaben ?? []), ...(plan.zahlungen ?? []), ...(plan.kosten ?? [])].map((x) => x.id as string)); + for (const p of plan.projekte) for (const g of Object.keys(GRUPPE_NAME)) alleIds.add(`${g}:${p.id}`); const anzahlAus = ansicht.aus.filter((id) => alleIds.has(id)).length; leiste.innerHTML = `${Object.keys(ZOOM).map((z) => ``).join("")} @@ -164,6 +180,13 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise ({ + aufgaben: (plan.aufgaben ?? []).filter((t) => t.projekt_id === pid), + raten: (plan.zahlungen ?? []).filter((z) => z.projekt_id === pid), + kosten: (plan.kosten ?? []).filter((k) => k.projekt_id === pid), + }); + const postenListe = (art: string) => (art === "t" ? plan.aufgaben : art === "z" ? plan.zahlungen : plan.kosten) ?? []; + const postenDatum = (art: string, o: Zeile): Datum | undefined => (art === "t" ? o.faellig_am : o.termin) ?? undefined; const zeilenNr = new Map(); let zaehler = 0; for (const p of [...projekteAlle, ...plan.projekte.filter((p) => !projekteAlle.includes(p))]) { @@ -172,6 +195,14 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise v.abschnitt_id === a.id)) zeilenNr.set(v.id, ++zaehler); } + const pp = postenVon(p.id); + zeilenNr.set(`aufg:${p.id}`, ++zaehler); + for (const t of pp.aufgaben) zeilenNr.set(t.id, ++zaehler); + zeilenNr.set(`zahl:${p.id}`, ++zaehler); + zeilenNr.set(`ein:${p.id}`, ++zaehler); + for (const z of pp.raten) zeilenNr.set(z.id, ++zaehler); + zeilenNr.set(`aus:${p.id}`, ++zaehler); + for (const k of pp.kosten) zeilenNr.set(k.id, ++zaehler); } const idVon = new Map(plan.vorgaenge.map((v) => [zeilenNr.get(v.id)!, v.id])); const linksVon = (id: string) => plan.verknuepfungen.filter((k) => k.vorgang_id === id); @@ -179,8 +210,9 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise projekte.some((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id))); - let von = montagDerWoche(plusTage(sichtbar.reduce((m, v) => (v.anfang < m ? v.anfang : m), heute), -7)); - let bis = plusTage(sichtbar.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 30)), 21); + const postenDaten = filter ? [] : projekte.flatMap((p) => { const pp = postenVon(p.id); return [...pp.aufgaben.map((t) => t.faellig_am), ...pp.raten.map((z) => z.termin), ...pp.kosten.map((k) => k.termin)]; }).filter(Boolean) as Datum[]; + let von = montagDerWoche(plusTage([...sichtbar.map((v) => v.anfang as Datum), ...postenDaten].reduce((m, d) => (d < m ? d : m), heute), -7)); + let bis = plusTage([...sichtbar.map((v) => v.ende as Datum), ...postenDaten].reduce((m, d) => (d > m ? d : m), plusTage(heute, 30)), 21); // die Zeitskala füllt auch weit herausgezoomt die Breite const minTage = Math.ceil(1600 / W); if (tageZwischen(von, bis) + 1 < minTage) bis = plusTage(von, minTage - 1); @@ -208,7 +240,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise`).join(""); // Zeilen aufbauen - type Reihe = { art: "p" | "a" | "v"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum }; + type Reihe = { art: "p" | "a" | "v" | "g" | "t" | "z" | "k"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum }; const reihen: Reihe[] = []; projekte.forEach((p, i) => { const f = farbe(p, i); @@ -227,6 +259,23 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise { const d = l.filter(Boolean).sort() as Datum[]; return d.length ? { von: d[0], bis: d.at(-1) } : {}; }; + const gruppe = (g: string, art: "t" | "z" | "k", l: Zeile[]) => { + if (!sichtbarZeile(`${g}:${p.id}`)) return; + reihen.push({ art: "g", obj: { id: `${g}:${p.id}`, gruppe: g, name: GRUPPE_NAME[g], posten: l }, projekt: p, farbe: f, ...spanneDaten(l.map((x) => postenDatum(art, x))) }); + if (zu.has(`${g}:${p.id}`)) return; + for (const x of l) if (sichtbarZeile(x.id)) reihen.push({ art, obj: x, projekt: p, farbe: f, von: postenDatum(art, x), bis: postenDatum(art, x) }); + }; + gruppe("aufg", "t", pp.aufgaben); + if (!sichtbarZeile(`zahl:${p.id}`)) return; + reihen.push({ art: "g", obj: { id: `zahl:${p.id}`, gruppe: "zahl", name: GRUPPE_NAME.zahl, posten: [...pp.raten, ...pp.kosten] }, projekt: p, farbe: f, + ...spanneDaten([...pp.raten, ...pp.kosten].map((x) => x.termin)) }); + if (zu.has(`zahl:${p.id}`)) return; + gruppe("ein", "z", pp.raten); + gruppe("aus", "k", pp.kosten); }); const zeileVon = new Map(); reihen.forEach((r, i) => zeileVon.set(r.obj.id, i)); @@ -282,7 +331,8 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise { const o = r.obj; let links = "", balken = ""; - const nr = `${zeilenNr.get(o.id)}`; + const nr = ["p", "a", "v", "z"].includes(r.art) ? `${zeilenNr.get(o.id)}` + : `${zeilenNr.get(o.id)}`; const dauerZelle = () => `${r.von ? dauerText(arbeitstageZwischen(r.von, r.bis!, woche)) : ""}`; const datumZelle = (d?: Datum) => `${d ? tabellenDatum(d) : ""}`; const klapp = ``; @@ -304,10 +354,55 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise ${dauerZelle()}${datumZelle(r.von)}${datumZelle(r.bis)}`; if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, esc(o.name), r.von, r.bis); + } else if (r.art === "g") { + // Abschnitte „Aufgaben“, „Zahlungen“ mit „Einnahmen“ und „Ausgaben“ + const g = o.gruppe as string, l = o.posten as Zeile[]; + const ein = l.filter((x) => (plan.zahlungen ?? []).includes(x)).reduce((n, x) => n + Number(x.netto), 0); + const aus = l.filter((x) => (plan.kosten ?? []).includes(x)).reduce((n, x) => n + Number(x.netto), 0); + const neu = g === "aufg" ? "t" : g === "ein" ? "z" : g === "aus" ? "k" : ""; + const titelNeu = g === "aufg" ? "Aufgabe hinzufügen" : g === "ein" ? "Einnahme (Rate) hinzufügen" : "Ausgabe hinzufügen"; + const res = g === "aufg" ? `${l.filter((t) => !t.erledigt_am).length} offen` + : g === "zahl" ? `+${formatEuro(ein)} −${formatEuro(aus)}` + : !l.length ? "" : g === "ein" ? `+${formatEuro(ein)}` : `−${formatEuro(aus)}`; + links = `${nr}${klapp}${esc(o.name)} + ${neu ? `` : ""} + ${datumZelle(r.von)}${datumZelle(r.bis)}${res}`; + } else if (r.art === "t" || r.art === "z" || r.art === "k") { + const art = r.art; + const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) => + `${inhaltHtml}`; + const d = postenDatum(art, o); + const fertig = art === "t" ? !!o.erledigt_am : art === "z" ? o.status !== "geplant" : o.status === "bezahlt"; + const vgTitel = "Hängt an Zeile: z. B. 4 (am Ende), 4EE+3 (3 Arbeitstage nach dem Ende), 4AA-5 (5 Arbeitstage vor dem Anfang). Leer: fester Termin"; + const weg = ``; + const auge = ``; + const betrag = art === "t" ? "" : `${art === "z" ? "+" : "−"}${formatEuro(Number(o.netto))}`; + if (art === "t") { + links = `${nr}${zelle("t-text", `text${fertig ? " erledigt" : ""}`, esc(o.text), "Aufgabe")} + ${auge}${weg} + ${zelle("t-vg", "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle("t-datum", "zahl", d ? tabellenDatum(d) : 'Datum', "Fällig am")} + ${esc(o.kategorie ?? "")}`; + } else { + const statusText = art === "z" ? ({ geplant: "geplant", gestellt: "Rechnung gestellt", bezahlt: "bezahlt" } as Record)[o.status] ?? o.status + : ({ geplant: "geplant", bestellt: "bestellt", bezahlt: "bezahlt" } as Record)[o.status] ?? o.status; + links = `${nr}${zelle(`${art}-name`, "text", `${esc(o.bezeichnung)} ${esc(statusText)}${o.rest ? " · Rest" : ""}`, "Bezeichnung")} + ${auge}${weg} + ${zelle(`${art}-vg`, "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle(`${art}-datum`, "zahl", d ? tabellenDatum(d) : "", art === "z" ? "Fällig am" : "Termin")} + ${zelle(`${art}-betrag`, `betrag ${art === "z" ? "ein" : "aus"}`, betrag, art === "z" && o.art === "schluss" ? "Betrag netto; leer lassen = Rest aus Auftragswert und den anderen Raten" : "Betrag netto")}`; + } + if (d) { + const cx = x(d) + W / 2; + const spaet = art === "t" && !fertig && d < heute; + const klasse = `posten-ms ${art}${fertig ? " fertig" : ""}${spaet ? " spaet" : ""}${art === "z" ? ` ${esc(o.status ?? "geplant")}` : ""}`; + const fest = fertig && art !== "t"; + const name = art === "t" ? o.text : o.bezeichnung; + balken = `
${art === "t" && fertig ? "✓" : ""}
` + + beschriftung(cx, cx + 8, esc(name), undefined, d, betrag ? ` ${betrag}` : ""); + } } else { const ms = Number(o.dauer) === 0; const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) => - `${inhaltHtml}`; + `${inhaltHtml}`; links = `${nr}${zelle("name", "text", esc(o.name), "Bezeichnung")} ${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)) + dauerHinweis(o), dauerTitel(o))} @@ -357,6 +452,16 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise`; + }).join("") + reihen.filter((r) => (r.art === "t" || r.art === "z" || r.art === "k") && r.obj.vorgang_id && r.von).map((r) => { + // Zahlungen, Kosten und Aufgaben: gestrichelt vom Anfang (AA) oder Ende (EE) des Vorgangs zur Raute + const a = plan.vorgaenge.find((v) => v.id === r.obj.vorgang_id); + const ya = zeileVon.get(r.obj.vorgang_id), yb = zeileVon.get(r.obj.id); + if (!a || ya === undefined || yb === undefined) return ""; + const x1 = r.obj.bezug_art === "AA" ? x(a.anfang) : x(a.ende) + W, x2 = x(r.von!) + W / 2; + const y1 = ya * ZEILE + BALKEN_MITTE + 7, y2 = yb * ZEILE + BALKEN_MITTE; + // in Höhe der Raute von der Seite, damit die Linie die Beschriftung nicht kreuzt + const rand = x1 > x2 ? x2 + 9 : x2 - 9; + return ``; }).join(""); // Spaltenbreiten und Breite der Tabelle links (Trennleiste), beides gemerkt @@ -367,7 +472,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise
-