Abschläge als Meilensteine, Zoom an der Zeitskala, Liquidität übersichtlicher (0.4.0)
- POST /api/projekte/:id/zahlungsplan schlägt 30/40/20/10 vor; geplante Raten mit Vorgang wandern mit dessen Ende - Terminplan: €-Meilensteine je Projekt, Zoom per Regler und Ziehen an der Zeitskala - Liquidität: Kennzahlen, Kontostandverlauf, Zahlungen je Zeitraum mit Fälligkeitsdatum Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -2,6 +2,12 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.4.0
|
||||
|
||||
- Abschlagsrechnungen als Meilensteine: Ein Klick auf „€ vorschlagen“ im Terminplan oder „Zahlungsplan vorschlagen“ am Projekt legt 30 % Anzahlung, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung an. Die Raten hängen an den passenden Vorgängen, stehen als €-Rauten im Terminplan und wandern mit, solange sie noch nicht gestellt sind.
|
||||
- Terminplan zoomen wie in MS Project: Regler mit − und +, oder an der Zeitskala nach rechts (größer) oder links (kleiner) ziehen.
|
||||
- Liquidität übersichtlicher: Kennzahlen oben (Kontostand, tiefster Stand, Einnahmen und Ausgaben, Stand am Ende), Kontostand als Säulen, darunter je Woche oder Monat jede Zahlung mit Fälligkeitsdatum, Projekt und Betrag zum Aufklappen.
|
||||
|
||||
## 0.3.0
|
||||
|
||||
Wünsche aus dem ersten Test (20.10.2026):
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.3.0",
|
||||
"version": "0.4.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
// Prozentrechnung läuft über BigInt, damit kein Rundungsfehler entsteht.
|
||||
// Gerundet wird kaufmännisch (ab ,5 vom Betrag weg).
|
||||
|
||||
import type { Datum } from "./datum.js";
|
||||
|
||||
export type Cent = number;
|
||||
|
||||
function pruefeCent(c: Cent): void {
|
||||
@@ -111,3 +113,33 @@ export const STANDARD_ZAHLUNGSPLAN: { bezeichnung: string; prozent: number }[] =
|
||||
{ bezeichnung: "Abschlag nach Fertigstellung der Restarbeiten", prozent: 20 },
|
||||
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 10 },
|
||||
];
|
||||
|
||||
export interface ZahlungsVorschlag {
|
||||
bezeichnung: string;
|
||||
art: "anzahlung" | "abschlag" | "schluss";
|
||||
netto: Cent;
|
||||
/** Vorgang, nach dessen Ende die Rate fällig wird; die Anzahlung hängt an keinem Vorgang */
|
||||
vorgang_id: string | null;
|
||||
termin: Datum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Schlägt den Standard-Zahlungsplan als Meilensteine vor (Henning, 20.10.2026): Anzahlung bei Auftrag,
|
||||
* Abschlag nach dem letzten Richt-, Montage- oder Abbundvorgang, weiterer Abschlag nach dem vorletzten
|
||||
* Vorgang, Schlussrechnung nach dem letzten (oder einem Vorgang „Abnahme“).
|
||||
*/
|
||||
export function schlageZahlungsplanVor(
|
||||
auftragssumme: Cent, vorgaenge: { id: string; name: string; anfang: Datum; ende: Datum }[], heute: Datum,
|
||||
): ZahlungsVorschlag[] {
|
||||
const betraege = zahlungsplanBetraege(auftragssumme, STANDARD_ZAHLUNGSPLAN);
|
||||
const vs = [...vorgaenge].sort((a, b) => (a.ende < b.ende ? -1 : a.ende > b.ende ? 1 : 0));
|
||||
const letzter = (muster: RegExp) => [...vs].reverse().find((v) => muster.test(v.name));
|
||||
const schluss = letzter(/abnahme/i) ?? vs.at(-1);
|
||||
const richten = letzter(/richt/i) ?? letzter(/montage|aufstell/i) ?? letzter(/abbund/i) ?? vs.at(Math.ceil(vs.length / 2) - 1);
|
||||
const vorSchluss = schluss ? vs.filter((v) => v.ende < schluss.ende && (!richten || v.ende > richten.ende)).at(-1) ?? schluss : undefined;
|
||||
const anzahlung = vs.length ? (heute < vs[0]!.anfang ? heute : vs[0]!.anfang) : heute;
|
||||
const an = (v: { id: string; ende: Datum } | undefined) => ({ vorgang_id: v?.id ?? null, termin: v?.ende ?? heute });
|
||||
const arten = ["anzahlung", "abschlag", "abschlag", "schluss"] as const;
|
||||
const ziele = [{ vorgang_id: null, termin: anzahlung }, an(richten), an(vorSchluss), an(schluss)];
|
||||
return STANDARD_ZAHLUNGSPLAN.map((r, i) => ({ bezeichnung: r.bezeichnung, art: arten[i]!, netto: betraege[i]!, ...ziele[i]! }));
|
||||
}
|
||||
|
||||
@@ -14,6 +14,8 @@ import { TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet } from "../domain/liquiditaet.js";
|
||||
import { liquiditaetsDaten } from "../domain/projektplan.js";
|
||||
import { schlageZahlungsplanVor } from "../domain/geld.js";
|
||||
import { anfang, ende } from "../domain/terminplan.js";
|
||||
import { uebernimmV70 } from "../domain/v70.js";
|
||||
import { speichereUebernahme } from "./v70import.js";
|
||||
import { pruefeStand, speichereStand } from "./stand.js";
|
||||
@@ -82,8 +84,33 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
return mitOrdner(p, benutzer(req));
|
||||
});
|
||||
|
||||
// Standard-Zahlungsplan als Meilensteine vorschlagen (P9, Henning 20.10.2026), nur solange das Projekt noch keine Raten hat
|
||||
app.post("/api/projekte/:id/zahlungsplan", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const p = (await pool.query("select id, umsatz_netto from projekt where id = $1", [id])).rows[0];
|
||||
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
if (!(Number(p.umsatz_netto) > 0)) return reply.status(400).send({ fehler: "Bitte zuerst beim Projekt den Auftragswert (Umsatz netto) eintragen." });
|
||||
const e = await ladeEinstellungen();
|
||||
const woche = { tage: e.arbeitstage };
|
||||
const raten = await transaktion(pool, benutzer(req), async (c) => {
|
||||
if ((await c.query("select 1 from zahlung where projekt_id = $1 limit 1", [id])).rowCount) return null;
|
||||
const vs = (await c.query(`select v.id, v.name, v.start, v.dauer from vorgang v join abschnitt a on a.id = v.abschnitt_id where a.projekt_id = $1`, [id])).rows
|
||||
.map((v) => ({ id: v.id, name: v.name, anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }));
|
||||
const vorschlag = schlageZahlungsplanVor(Number(p.umsatz_netto), vs, new Date().toISOString().slice(0, 10));
|
||||
const neu = [];
|
||||
for (const [i, z] of vorschlag.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 *`,
|
||||
[id, z.vorgang_id, z.art, z.bezeichnung, z.netto, z.termin, i])).rows[0]);
|
||||
}
|
||||
return neu;
|
||||
});
|
||||
if (!raten) return reply.status(409).send({ fehler: "Das Projekt hat schon einen Zahlungsplan." });
|
||||
return reply.status(201).send(raten);
|
||||
});
|
||||
|
||||
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
|
||||
const PLAN = new Set(["vorgang", "vorgang_vorgaenger"]);
|
||||
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung"]);
|
||||
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = []): Promise<T> {
|
||||
if (!PLAN.has(tabelle)) return fn();
|
||||
const e = await ladeEinstellungen();
|
||||
|
||||
@@ -38,9 +38,21 @@ export async function mitNeuplanung<T>(
|
||||
throw new PlanFehler((e as Error).message);
|
||||
}
|
||||
for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]);
|
||||
await zahlungenNachziehen(c, woche);
|
||||
return { ergebnis, verschoben: [...starts.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<void> {
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
||||
/** Prüft eine neue Verknüpfung vor dem Speichern. */
|
||||
export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; vorgaenger_id: string }, ausser?: string): Promise<void> {
|
||||
const r = await c.query<Verknuepfung & { id: string }>("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger");
|
||||
@@ -51,7 +63,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) {
|
||||
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute] = await Promise.all([
|
||||
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen] = await Promise.all([
|
||||
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, 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"),
|
||||
@@ -60,6 +72,7 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche) {
|
||||
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"),
|
||||
]);
|
||||
const vs = vorgaenge.rows.map((v) => ({ ...v, anfang: anfang(v, woche), ende: ende(v, woche) }));
|
||||
const bs = besetzungen.rows.map((b) => ({
|
||||
@@ -75,6 +88,7 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche) {
|
||||
verknuepfungen: links.rows,
|
||||
besetzungen: bs,
|
||||
leute: leute.rows,
|
||||
zahlungen: zahlungen.rows,
|
||||
ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
|
||||
arbeitstage: woche.tage,
|
||||
};
|
||||
|
||||
106
src/web/app.ts
106
src/web/app.ts
@@ -2,7 +2,7 @@
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
import { terminplanSeite } from "./gantt.js";
|
||||
import { kalenderwoche, terminplanSeite } from "./gantt.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
|
||||
@@ -29,6 +29,7 @@ const huelle = document.getElementById("dialog-huelle")!;
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
||||
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
||||
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||||
|
||||
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
|
||||
|
||||
@@ -355,14 +356,28 @@ async function projektSeite(id: string): Promise<void> {
|
||||
teil.replaceChildren();
|
||||
knopfOrt.replaceChildren();
|
||||
if (projektTeil === "zahlungen") {
|
||||
knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", ZAHLUNG_FELDER, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden());
|
||||
// eine geplante Rate kann an einem Vorgang hängen und wandert dann mit dessen Ende (Meilenstein im Terminplan)
|
||||
const vorgangName = (vid: string) => { const v = vorgaenge.find((x: Zeile) => x.id === vid); return v ? `${v.nummer} ${v.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, vorgangName(v.id)])] });
|
||||
knopf("+ Zahlung", async () => (await bearbeiten("zahlungen", "Neue Zahlung", felder, null, { projekt_id: id, art: "abschlag", status: "geplant", termin: heute() })) && neuLaden());
|
||||
const summe = eigeneZahlungen.reduce((s, z) => s + z.netto, 0);
|
||||
if (!eigeneZahlungen.length) {
|
||||
const vorschlag = document.createElement("div");
|
||||
vorschlag.className = "vorschlag";
|
||||
vorschlag.innerHTML = `<p>Noch kein Zahlungsplan. Der Standard ist 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung nach Abnahme. Die Raten hängen an den passenden Vorgängen und erscheinen im Terminplan als €-Meilensteine.</p>
|
||||
<button class="haupt" data-a="vorschlag">Zahlungsplan vorschlagen</button> <span class="fehler" role="status"></span>`;
|
||||
vorschlag.querySelector<HTMLButtonElement>("button")!.onclick = async () => {
|
||||
try { await api(`projekte/${id}/zahlungsplan`, "POST"); neuLaden(); } catch (e) { vorschlag.querySelector(".fehler")!.textContent = (e as Error).message; }
|
||||
};
|
||||
teil.append(vorschlag);
|
||||
}
|
||||
teil.append(eigeneZahlungen.length ? tabelle([
|
||||
{ titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(Object.fromEntries(ZAHLUNGSARTEN)[z.art] ?? "")}</span>` },
|
||||
{ titel: "Termin", wert: (z) => dat(z.termin) },
|
||||
{ titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
|
||||
{ titel: "Status", wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
|
||||
{ titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" },
|
||||
], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", ZAHLUNG_FELDER, z)) && neuLaden()) : leer("Noch kein Zahlungsplan."));
|
||||
], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden()) : "");
|
||||
if (eigeneZahlungen.length) teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Umsatz netto ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
|
||||
} else if (projektTeil === "kosten") {
|
||||
const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle));
|
||||
@@ -437,26 +452,83 @@ async function terminplan(): Promise<void> {
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||||
}
|
||||
|
||||
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
|
||||
// oder Monat jede einzelne Zahlung mit Datum, Projekt und Betrag zum Aufklappen
|
||||
let liquiOffen = new Set<string>();
|
||||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
const leiste = seite("Liquidität");
|
||||
leiste.innerHTML = `<select id="l-ansicht"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
|
||||
<select id="l-anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>`;
|
||||
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
|
||||
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
|
||||
<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>`;
|
||||
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
|
||||
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
|
||||
a.value = ansicht;
|
||||
n.value = String(anzahl);
|
||||
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
|
||||
const perioden = await api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: ansicht === "woche" ? "Woche ab" : "Monat", wert: (p) => (ansicht === "woche" ? dat(p.von) : esc(p.von.slice(5, 7) + "/" + p.von.slice(0, 4))) },
|
||||
{ titel: "Einnahmen", wert: (p) => euro(p.einnahmen), klasse: "zahl" },
|
||||
{ titel: "Ausgaben", wert: (p) => euro(p.ausgaben), klasse: "zahl" },
|
||||
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl optional" },
|
||||
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
|
||||
], perioden, (p) => {
|
||||
const text = p.posten.map((x: Zeile) => `${dat(x.datum)} ${x.gruppe} ${x.projekt ?? ""} ${x.bezeichnung}: ${formatEuro(x.betrag)}`).join("\n") || "Keine Bewegungen";
|
||||
dialog(`${dat(p.von)} bis ${dat(p.bis)}`, [{ name: "t", titel: "Bewegungen", art: "langtext" }], { t: text }, false);
|
||||
}));
|
||||
const [perioden, projekte, einst] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
const projektName = new Map(projekte.map((p) => [p.nummer, p.bezeichnung]));
|
||||
const zeitraum = (p: Zeile) => (ansicht === "woche" ? `KW ${kalenderwoche(p.von)} · ${dat(p.von).slice(0, 6)} – ${dat(p.bis).slice(0, 6)}` : `${MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]} ${p.von.slice(0, 4)}`);
|
||||
|
||||
// Kennzahlen
|
||||
const tief = perioden.reduce((m, p) => (p.kontostand < m.kontostand ? p : m), perioden[0] ?? { kontostand: 0 });
|
||||
const summeEin = perioden.reduce((s, p) => s + p.einnahmen, 0), summeAus = perioden.reduce((s, p) => s + p.ausgaben, 0);
|
||||
const ende = perioden.at(-1);
|
||||
const kachel = (titel: string, wert: string, unter: string, rot = false) =>
|
||||
`<div class="kachel liqui-zahl"><h3>${esc(titel)}</h3><p class="gross${rot ? " fehler" : ""}">${wert}</p><p class="hinweis">${unter}</p></div>`;
|
||||
const startsaldo = Number(einst.startsaldo ?? 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="kacheln liqui-kacheln">
|
||||
${kachel("Kontostand", euro(startsaldo), einst.startsaldoDatum ? `eingetragen am ${dat(einst.startsaldoDatum)} · <a href="#daten">ändern</a>` : '<a href="#daten">unter Daten eintragen</a>')}
|
||||
${kachel("Tiefster Stand", tief ? euro(tief.kontostand) : "–", tief ? esc(zeitraum(tief)) : "", (tief?.kontostand ?? 0) < 0)}
|
||||
${kachel("Einnahmen / Ausgaben", `<span class="ein">${euro(summeEin)}</span><br>${euro(summeAus)}`, `im angezeigten Zeitraum, Saldo ${euro(summeEin + summeAus)}`)}
|
||||
${kachel(`Stand am ${ende ? dat(ende.bis) : ""}`, ende ? euro(ende.kontostand) : "–", "Ende des angezeigten Zeitraums", (ende?.kontostand ?? 0) < 0)}
|
||||
</div>`);
|
||||
|
||||
// Verlauf: Kontostand je Zeitraum als Säulen, unter null rot
|
||||
if (perioden.length) {
|
||||
const werte = perioden.map((p) => p.kontostand as number);
|
||||
const hoch = Math.max(0, ...werte), tiefst = Math.min(0, ...werte), spanne = hoch - tiefst || 1;
|
||||
const nullAb = (hoch / spanne) * 100;
|
||||
const jede = Math.ceil(perioden.length / 13);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<section class="karte liqui-verlauf"><h2>Kontostand am Ende ${ansicht === "woche" ? "der Woche" : "des Monats"}</h2>
|
||||
<div class="saeulen" style="--null:${nullAb}%">${perioden.map((p, i) => {
|
||||
const v = p.kontostand as number, h = (Math.abs(v) / spanne) * 100;
|
||||
return `<div class="saeule" title="${esc(zeitraum(p))}: ${euro(v)}"><div class="flaeche"><i class="${v < 0 ? "minus" : "plus"}" style="height:${h}%"></i></div>
|
||||
<small>${i % jede === 0 ? (ansicht === "woche" ? `KW ${kalenderwoche(p.von)}` : MONATSNAMEN[Number(p.von.slice(5, 7)) - 1]!.slice(0, 3)) : ""}</small></div>`;
|
||||
}).join("")}</div></section>`);
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
const heuteD = heute();
|
||||
const zeile = (x: Zeile) => {
|
||||
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
|
||||
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
|
||||
<td class="optional">${projekt}</td><td class="zahl ${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</td></tr>`;
|
||||
};
|
||||
const tab = document.createElement("table");
|
||||
tab.className = "liqui-tabelle";
|
||||
tab.innerHTML = `<thead><tr><th>${ansicht === "woche" ? "Woche" : "Monat"}</th><th class="zahl">Einnahmen</th><th class="zahl">Ausgaben</th><th class="zahl optional">Saldo</th><th class="zahl">Kontostand</th></tr></thead>
|
||||
${perioden.map((p) => {
|
||||
const offen = liquiOffen.has(p.von);
|
||||
const posten = [...p.posten].sort((x: Zeile, y: Zeile) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag));
|
||||
return `<tbody><tr class="klickbar periode${offen ? " offen" : ""}" data-von="${p.von}"><td><span class="pfeil">${offen ? "▾" : "▸"}</span> ${esc(zeitraum(p))} <small class="hinweis">${posten.length} ${posten.length === 1 ? "Zahlung" : "Zahlungen"}</small></td>
|
||||
<td class="zahl ein">${p.einnahmen ? euro(p.einnahmen) : "–"}</td><td class="zahl aus">${p.ausgaben ? euro(p.ausgaben) : "–"}</td><td class="zahl optional">${euro(p.saldo)}</td>
|
||||
<td class="zahl"><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b></td></tr>
|
||||
${offen ? `<tr class="details"><td colspan="5">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zahl">Betrag</th></tr></thead><tbody>${posten.map(zeile).join("")}</tbody></table>` : '<p class="hinweis">Keine Zahlungen in diesem Zeitraum.</p>'}</td></tr>` : ""}</tbody>`;
|
||||
}).join("")}`;
|
||||
tab.addEventListener("click", (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr.periode");
|
||||
if (!tr) return;
|
||||
const von = tr.dataset.von!;
|
||||
liquiOffen.has(von) ? liquiOffen.delete(von) : liquiOffen.add(von);
|
||||
liquiditaetSeite(ansicht, anzahl);
|
||||
});
|
||||
const alleOffen = perioden.every((p) => liquiOffen.has(p.von));
|
||||
const alleKnopf = leiste.querySelector<HTMLButtonElement>("#l-alle")!;
|
||||
alleKnopf.textContent = alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen";
|
||||
alleKnopf.onclick = () => { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); liquiditaetSeite(ansicht, anzahl); };
|
||||
inhalt.append(tab);
|
||||
}
|
||||
|
||||
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
// anderen Vorgänge sichtbar bleiben; die Bearbeitungsspalten lassen sich ausblenden.
|
||||
// Die Neuplanung der Nachfolger macht der Server.
|
||||
|
||||
import { formatEuro } from "../domain/geld.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";
|
||||
@@ -27,10 +28,16 @@ interface Plan {
|
||||
besetzungen: Zeile[];
|
||||
leute: Zeile[];
|
||||
ueberschneidungen: Zeile[];
|
||||
zahlungen: Zeile[];
|
||||
arbeitstage: number[];
|
||||
}
|
||||
|
||||
const ZOOM: Record<string, number> = { tag: 24, woche: 10, monat: 4 };
|
||||
// Zoom wie in MS Project: Regler und Ziehen an der Zeitskala (Henning, 20.10.2026), Pixel je Tag
|
||||
const ZOOM_MIN = 2, ZOOM_MAX = 48;
|
||||
const zoomGrenzen = (w: number) => Math.round(Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, w)) * 10) / 10;
|
||||
/** Welcher Tag beim Zoomen an welcher Stelle (Pixel ab dem Zeitbereich) stehen bleibt */
|
||||
let zoomAnker: { tag: number; px: number } | null = null;
|
||||
const ZEILE = 34;
|
||||
const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
|
||||
const MONATE = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
|
||||
@@ -78,13 +85,14 @@ export function vorgaengerText(links: Zeile[], nummer: Map<string, number>): str
|
||||
return links.map((k) => `${nummer.get(k.vorgaenger_id)}${k.art !== "EA" || k.verzoegerung ? ` ${k.art}` : ""}${k.verzoegerung ? (k.verzoegerung > 0 ? "+" : "") + k.verzoegerung : ""}`).join(", ");
|
||||
}
|
||||
|
||||
export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void> {
|
||||
const { api, esc, inhalt } = h;
|
||||
// erst laden, dann die Seite leeren: so springt die Ansicht beim Speichern nicht nach oben
|
||||
const plan = await api<Plan>("terminplan");
|
||||
// erst laden, dann die Seite leeren: so springt die Ansicht beim Speichern nicht nach oben;
|
||||
// beim Zoomen wird der schon geladene Plan nur neu gezeichnet
|
||||
const plan = vorhanden ?? await api<Plan>("terminplan");
|
||||
const leiste = h.seite("Terminplan");
|
||||
const woche: Arbeitswoche = { tage: plan.arbeitstage };
|
||||
let zoom = merke<string>("gantt-zoom") ?? "tag";
|
||||
const W = zoomGrenzen(merke<number>("gantt-w") ?? ZOOM[merke<string>("gantt-zoom") ?? "tag"] ?? 24);
|
||||
const schmal = merke<boolean>("gantt-schmal") ?? false;
|
||||
const zu = new Set<string>(merke<string[]>("gantt-zu") ?? []);
|
||||
const mitFertigen = merke<boolean>("gantt-fertige") ?? false;
|
||||
@@ -96,7 +104,8 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
if (filter && !personen.has(filter)) filter = "";
|
||||
const passt = (v: Zeile) => !filter || plan.besetzungen.some((b) => b.vorgang_id === v.id && wer(b) === filter);
|
||||
|
||||
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${z === zoom ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
|
||||
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${ZOOM[z] === W ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
|
||||
<span class="g-zoom" title="Zeitskala zoomen; du kannst auch an der Zeitskala nach links oder rechts ziehen"><button class="neben" data-a="kleiner" aria-label="Verkleinern">−</button><input type="range" data-a="zoom" min="${ZOOM_MIN}" max="${ZOOM_MAX}" step="0.5" value="${W}" aria-label="Zoom"><button class="neben" data-a="groesser" aria-label="Vergrößern">+</button></span>
|
||||
<button class="neben" data-a="heute">Heute</button>
|
||||
<select data-a="person" title="Nur Vorgänge dieser Person zeigen"><option value="">Alle Personen</option>${[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => `<option value="${esc(id)}"${id === filter ? " selected" : ""}>${esc(name)}</option>`).join("")}</select>
|
||||
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
|
||||
@@ -116,9 +125,9 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
const sichtbar = plan.vorgaenge.filter((v) => 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 minTage = zoom === "monat" ? 400 : zoom === "woche" ? 160 : 0;
|
||||
// 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);
|
||||
const W = ZOOM[zoom]!;
|
||||
const tage = tageZwischen(von, bis) + 1;
|
||||
const x = (d: Datum) => tageZwischen(von, d) * W;
|
||||
|
||||
@@ -171,7 +180,8 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
const klasse = ft ? "feiertag" : freitag ? "reserve" : frei ? "frei" : "";
|
||||
const titel = ft ? ft.name : freitag ? "Freitag: Reserve und Bürotag" : "";
|
||||
tagKopf += `<div class="${klasse}" style="width:${W}px"${titel ? ` title="${esc(titel)}"` : ""}>${W >= 18 ? Number(d.slice(8)) : ""}</div>`;
|
||||
if (klasse) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
|
||||
// weit herausgezoomt nur Feiertage schattieren, sonst wird die Fläche unruhig
|
||||
if (klasse && (W >= 6 || ft)) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
|
||||
}
|
||||
if (heute >= von && heute <= bis) schatten += `<i class="heute" style="left:${x(heute) + W / 2}px"></i>`;
|
||||
|
||||
@@ -179,14 +189,19 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
const zeilenHtml = reihen.map((r, i) => {
|
||||
const o = r.obj;
|
||||
let links = "", balken = "";
|
||||
const raten = r.art === "p" ? (plan.zahlungen ?? []).filter((z) => z.projekt_id === o.id) : [];
|
||||
const datumZelle = (d?: Datum) => `<span class="dat">${d ? kurzDatum(d) : "–"}</span>`;
|
||||
if (r.art === "p") {
|
||||
links = `<span class="griff" draggable="true" data-zieh="${o.id}" title="Ziehen, um die Reihenfolge zu ändern">⋮⋮</span>
|
||||
<button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
|
||||
<span class="name" title="${esc(o.bezeichnung)}"><b>${esc(o.nummer)}</b> ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
|
||||
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span><span></span><span></span>
|
||||
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span>
|
||||
${raten.length ? `<button class="verweis g-raten" data-raten="${o.id}" title="Zahlungsplan öffnen">€ ${raten.length} ${raten.length === 1 ? "Rate" : "Raten"}</button>`
|
||||
: `<button class="verweis g-raten" data-zahlungsplan="${o.id}" title="Standard-Zahlungsplan 30/40/20/10 als Meilensteine anlegen; dafür muss beim Projekt der Auftragswert stehen">€ vorschlagen</button>`}<span></span>
|
||||
<button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button>`;
|
||||
if (r.von) balken = `<div class="balken projekt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
|
||||
// Abschlagsrechnungen als Meilensteine (P9): geplant hohl, gestellt halb, bezahlt voll
|
||||
balken += raten.map((z) => `<div class="zahlung-ms ${esc(z.status ?? "geplant")}" data-raten="${o.id}" style="left:${x(z.termin) + W / 2 - 10}px;--farbe:${r.farbe}" title="${esc(z.bezeichnung)} · ${formatEuro(Number(z.netto))} netto · fällig ${formatDatum(z.termin)} · ${esc(z.status ?? "geplant")}">€</div>`).join("");
|
||||
} else if (r.art === "a") {
|
||||
links = `<span></span><button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
|
||||
<span class="name abschnitt zelle" data-id="${o.id}" data-feld="abschnitt" title="Klicken zum Umbenennen">${esc(o.name)}</span>
|
||||
@@ -256,7 +271,8 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
const linksBreite = () => box.querySelector<HTMLElement>(".g-kopf .g-links")?.offsetWidth ?? 0;
|
||||
const nachHeute = () => (box.scrollLeft = Math.max(0, x(heute) - (box.clientWidth - linksBreite()) / 3));
|
||||
const gespeichert = merke<number>("gantt-scroll");
|
||||
if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute();
|
||||
if (zoomAnker) box.scrollLeft = Math.max(0, zoomAnker.tag * W - zoomAnker.px);
|
||||
else if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute();
|
||||
box.scrollTop = merke<number>("gantt-scroll-oben") ?? 0;
|
||||
box.addEventListener("scroll", () => { merke("gantt-scroll", box.scrollLeft); merke("gantt-scroll-oben", box.scrollTop); }, { passive: true });
|
||||
const neuLaden = () => terminplanSeite(h);
|
||||
@@ -268,12 +284,45 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
if (z) { z.closest(".g-zeile")?.scrollIntoView({ block: "nearest" }); bearbeite(z); }
|
||||
}
|
||||
|
||||
// Zoomen hält den Tag in der Mitte (oder unter dem Mauszeiger) fest und zeichnet nur neu
|
||||
const zeitBreite = () => box.clientWidth - linksBreite();
|
||||
const zoome = (neuW: number, px = zeitBreite() / 2) => {
|
||||
neuW = zoomGrenzen(neuW);
|
||||
zoomAnker = { tag: (box.scrollLeft + px) / W, px };
|
||||
merke("gantt-w", neuW);
|
||||
if (neuW !== W) void terminplanSeite(h, plan).finally(() => (zoomAnker = null));
|
||||
else zoomAnker = null;
|
||||
};
|
||||
leiste.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest("button");
|
||||
if (b?.dataset.zoom) { merke("gantt-zoom", b.dataset.zoom); merke("gantt-scroll", null as unknown as number); neuLaden(); }
|
||||
if (b?.dataset.zoom) zoome(ZOOM[b.dataset.zoom]!);
|
||||
if (b?.dataset.a === "kleiner") zoome(W / 1.4);
|
||||
if (b?.dataset.a === "groesser") zoome(W * 1.4);
|
||||
if (b?.dataset.a === "heute") nachHeute();
|
||||
if (b?.dataset.a === "spalten") { merke("gantt-schmal", !schmal); neuLaden(); }
|
||||
});
|
||||
leiste.querySelector<HTMLInputElement>('[data-a="zoom"]')!.onchange = (ev) => zoome(Number((ev.target as HTMLInputElement).value));
|
||||
// an der Zeitskala ziehen: nach rechts größer, nach links kleiner
|
||||
box.querySelector<HTMLElement>(".g-zeit")!.addEventListener("pointerdown", (ev) => {
|
||||
if (ev.button !== 0) return;
|
||||
ev.preventDefault();
|
||||
const rand = box.getBoundingClientRect().left + linksBreite();
|
||||
const px = ev.clientX - rand, start = { x: ev.clientX, w: W, tag: (box.scrollLeft + px) / W };
|
||||
let offen = 0, ziel = W;
|
||||
const zieh = (e: PointerEvent) => {
|
||||
ziel = zoomGrenzen(start.w * Math.exp((e.clientX - start.x) / 160));
|
||||
if (offen) return;
|
||||
offen = requestAnimationFrame(() => {
|
||||
offen = 0;
|
||||
zoomAnker = { tag: start.tag, px };
|
||||
merke("gantt-w", ziel);
|
||||
void terminplanSeite(h, plan);
|
||||
});
|
||||
};
|
||||
const los = () => { document.removeEventListener("pointermove", zieh); document.removeEventListener("pointerup", los); setTimeout(() => (zoomAnker = null), 50); };
|
||||
document.addEventListener("pointermove", zieh);
|
||||
document.addEventListener("pointerup", los);
|
||||
});
|
||||
leiste.querySelector<HTMLSelectElement>('[data-a="person"]')!.onchange = (ev) => { merke("gantt-person", (ev.target as HTMLSelectElement).value); neuLaden(); };
|
||||
leiste.querySelector<HTMLInputElement>('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); };
|
||||
|
||||
@@ -294,6 +343,11 @@ export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
return neuLaden();
|
||||
}
|
||||
if (t.dataset.neuVorgang) return neuerVorgang(t.dataset.neuVorgang);
|
||||
if (t.dataset.raten) { location.hash = `projekt-${t.dataset.raten}`; return; }
|
||||
if (t.dataset.zahlungsplan) {
|
||||
try { await api(`projekte/${t.dataset.zahlungsplan}/zahlungsplan`, "POST"); } catch (e) { meldung.textContent = (e as Error).message; return; }
|
||||
return neuLaden();
|
||||
}
|
||||
// Löschen mit zweitem Klick bestätigen
|
||||
if (t.dataset.weg) {
|
||||
if (!t.classList.contains("sicher")) {
|
||||
@@ -529,7 +583,7 @@ function vorherigerArbeitstag(d: Datum, woche: Arbeitswoche): Datum {
|
||||
return x;
|
||||
}
|
||||
|
||||
function kalenderwoche(d: Datum): number {
|
||||
export function kalenderwoche(d: Datum): number {
|
||||
const t = new Date(`${d}T00:00:00Z`);
|
||||
t.setUTCDate(t.getUTCDate() + 4 - (t.getUTCDay() || 7));
|
||||
const jahresanfang = Date.UTC(t.getUTCFullYear(), 0, 1);
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
:root {
|
||||
--marke: #451e0c; --holz: #a26e3a;
|
||||
--leiste: #13294a; --leiste-text: #b9c7da; --leiste-aktiv: #234a7c;
|
||||
--bg: #f2f4f8; --fl: #ffffff; --text: #18202c; --leise: #5f6b7a; --linie: #e0e5ec;
|
||||
--ein: #2f6b5a; --bg: #f2f4f8; --fl: #ffffff; --text: #18202c; --leise: #5f6b7a; --linie: #e0e5ec;
|
||||
--akzent: #1d5fa8; --akzent-hover: #174d89; --akzent-text: #ffffff; --akzent-hell: #e4eefa;
|
||||
--warn: #b42318; --warnung-bg: #fdecea; --warnung-text: #7a1c14; --warnung-linie: #f5c2bd;
|
||||
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px;
|
||||
@@ -13,14 +13,14 @@
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root:not([data-theme="light"]) {
|
||||
--leiste: #0d1a2e; --leiste-aktiv: #1d3a62;
|
||||
--bg: #111822; --fl: #1a2331; --text: #e8edf4; --leise: #9aa7b8; --linie: #2b3747;
|
||||
--ein: #7fd0b2; --bg: #111822; --fl: #1a2331; --text: #e8edf4; --leise: #9aa7b8; --linie: #2b3747;
|
||||
--akzent: #5a9be0; --akzent-hover: #78b0ea; --akzent-text: #0d1a2e; --akzent-hell: #1d3352; --warn: #f97066;
|
||||
--warnung-bg: #3a1714; --warnung-text: #f9c9c3; --warnung-linie: #6b2620; color-scheme: dark;
|
||||
}
|
||||
}
|
||||
:root[data-theme="dark"] {
|
||||
--leiste: #0d1a2e; --leiste-aktiv: #1d3a62;
|
||||
--bg: #111822; --fl: #1a2331; --text: #e8edf4; --leise: #9aa7b8; --linie: #2b3747;
|
||||
--ein: #7fd0b2; --bg: #111822; --fl: #1a2331; --text: #e8edf4; --leise: #9aa7b8; --linie: #2b3747;
|
||||
--akzent: #5a9be0; --akzent-hover: #78b0ea; --akzent-text: #0d1a2e; --akzent-hell: #1d3352; --warn: #f97066;
|
||||
--warnung-bg: #3a1714; --warnung-text: #f9c9c3; --warnung-linie: #6b2620; color-scheme: dark;
|
||||
}
|
||||
@@ -285,3 +285,49 @@ dl.werte dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums;
|
||||
.g-links, .gantt.schmal .g-links { grid-template-columns: 22px 1fr 24px 24px; }
|
||||
.g-links > :nth-child(1), .g-links > :nth-child(4), .g-links > :nth-child(5), .g-links > :nth-child(6), .g-links > :nth-child(7), .g-links > :nth-child(8) { display: none; }
|
||||
}
|
||||
|
||||
/* Zoom an der Zeitskala und Abschläge als Meilensteine (Henning, 20.10.2026) */
|
||||
.g-zoom { display: inline-flex; align-items: center; gap: 4px; }
|
||||
.g-zoom button { min-width: 32px; padding-inline: 8px; }
|
||||
.g-zoom input[type="range"] { width: 120px; accent-color: var(--akzent); }
|
||||
.g-zeit { cursor: ew-resize; touch-action: none; user-select: none; }
|
||||
.zahlung-ms { position: absolute; top: 7px; width: 20px; height: 20px; pointer-events: auto; cursor: pointer; z-index: 2;
|
||||
clip-path: polygon(50% 0, 100% 50%, 50% 100%, 0 50%); display: grid; place-items: center; font-size: 11px; font-weight: 700;
|
||||
background: color-mix(in srgb, var(--farbe) 30%, var(--fl)); color: var(--farbe); }
|
||||
.zahlung-ms.gestellt { background: color-mix(in srgb, var(--farbe) 55%, var(--fl)); color: #fff; }
|
||||
.zahlung-ms.bezahlt { background: var(--farbe); color: #fff; }
|
||||
.g-links .g-raten { font-size: 11.5px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; padding: 0; text-align: left; font-weight: 400; }
|
||||
.vorschlag { display: grid; gap: 10px; justify-items: start; padding: 4px 0 8px; }
|
||||
.vorschlag p { margin: 0; max-width: 65ch; color: var(--leise); }
|
||||
|
||||
/* Liquidität: Kennzahlen, Verlauf, Zahlungen je Zeitraum mit Datum (Henning, 20.10.2026) */
|
||||
.liqui-kacheln { grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); }
|
||||
.liqui-zahl .gross { font-size: 20px; font-weight: 600; font-variant-numeric: tabular-nums; }
|
||||
.liqui-zahl .gross small { color: var(--leise); font-weight: 400; }
|
||||
.liqui-verlauf { margin-bottom: 16px; }
|
||||
.liqui-verlauf h2 { font-size: 14px; margin: 0 0 8px; color: var(--leise); font-weight: 600; }
|
||||
.saeulen { display: flex; gap: 6px; height: 170px; align-items: stretch; }
|
||||
.saeule { flex: 1; min-width: 0; display: grid; grid-template-rows: 1fr auto; gap: 4px; }
|
||||
.saeule .flaeche { position: relative; border-bottom: 0; background: linear-gradient(var(--leise), var(--leise)) 0 var(--null) / 100% 1px no-repeat; }
|
||||
.saeule i { position: absolute; left: 12%; right: 12%; border-radius: 3px; }
|
||||
.saeule i.plus { bottom: calc(100% - var(--null)); background: var(--akzent); opacity: 0.8; }
|
||||
.saeule i.minus { top: var(--null); background: var(--warn); opacity: 0.85; }
|
||||
.saeule small { text-align: center; font-size: 11px; color: var(--leise); white-space: nowrap; overflow: hidden; }
|
||||
.liqui-zahl .ein { color: var(--ein); }
|
||||
.liqui-tabelle td.ein { color: var(--ein); }
|
||||
.liqui-tabelle .periode td:first-child { white-space: nowrap; }
|
||||
.liqui-tabelle .pfeil { display: inline-block; width: 14px; color: var(--leise); }
|
||||
.liqui-tabelle tr.periode.offen td { border-bottom-color: transparent; background: var(--akzent-hell); }
|
||||
.liqui-tabelle tr.details > td { padding: 0 0 12px 22px; background: var(--akzent-hell); }
|
||||
.posten-tabelle { width: 100%; background: var(--fl); border-radius: 8px; }
|
||||
.posten-tabelle th, .posten-tabelle td { font-size: 13px; padding: 6px 10px; }
|
||||
.posten-tabelle td.aus { color: var(--text); }
|
||||
.posten-tabelle td.ein { color: var(--ein); font-weight: 600; }
|
||||
.posten-tabelle tr.vorbei td { color: var(--leise); }
|
||||
@media (max-width: 800px) {
|
||||
.liqui-tabelle th, .liqui-tabelle td { padding-inline: 6px; font-size: 13px; }
|
||||
.liqui-tabelle .periode td:first-child { white-space: normal; }
|
||||
.liqui-tabelle .periode small { display: block; }
|
||||
.liqui-tabelle tr.details > td { padding-left: 6px; }
|
||||
.liqui-tabelle td.zahl { white-space: normal; }
|
||||
}
|
||||
|
||||
@@ -241,6 +241,30 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect((await app.inject(`/api/projekte/${p.id}`)).json().baustelle_ort).toBe("Mölln");
|
||||
});
|
||||
|
||||
it("Zahlungsplan wird als Meilensteine vorgeschlagen und wandert mit seinem Vorgang", async () => {
|
||||
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
|
||||
const p = await neu("projekte", { nummer: "P-26-098", bezeichnung: "Dachstuhl Ziegelei" });
|
||||
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(400);
|
||||
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 2_000_000 } });
|
||||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
|
||||
const richten = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-02", dauer: 2 });
|
||||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2026-11-09", dauer: 3 });
|
||||
const r = await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` });
|
||||
expect(r.statusCode, r.body).toBe(201);
|
||||
const raten = r.json();
|
||||
expect(raten.map((z: { netto: number }) => z.netto)).toEqual([600_000, 800_000, 400_000, 200_000]);
|
||||
expect(raten[1]).toMatchObject({ vorgang_id: richten.id, termin: "2026-11-03" });
|
||||
expect((await app.inject({ method: "POST", url: `/api/projekte/${p.id}/zahlungsplan` })).statusCode).toBe(409);
|
||||
// Richten verschiebt sich um eine Woche: die geplante Rate geht mit
|
||||
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-09" } });
|
||||
expect((await app.inject(`/api/zahlungen/${raten[1].id}`)).json().termin).toBe("2026-11-10");
|
||||
// gestellte Raten bleiben stehen
|
||||
await app.inject({ method: "PATCH", url: `/api/zahlungen/${raten[1].id}`, payload: { status: "gestellt" } });
|
||||
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${richten.id}`, payload: { start: "2026-11-16" } });
|
||||
expect((await app.inject(`/api/zahlungen/${raten[1].id}`)).json().termin).toBe("2026-11-10");
|
||||
expect((await app.inject("/api/terminplan")).json().zahlungen.filter((z: { projekt_id: string }) => z.projekt_id === p.id)).toHaveLength(4);
|
||||
});
|
||||
|
||||
it("Kalender-Abo nur mit gültigem Geheimnis", async () => {
|
||||
expect((await app.inject("/kalender/xxxxxxxxxxxxxxxxxxxxxxxx/baustellen.ics")).statusCode).toBe(404);
|
||||
const { kalenderToken } = (await app.inject({ method: "POST", url: "/api/kalender/neu" })).json();
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe } from "../src/domain/geld.js";
|
||||
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe, schlageZahlungsplanVor } from "../src/domain/geld.js";
|
||||
import { stundenZuArbeitstagen } from "../src/domain/arbeitszeit.js";
|
||||
|
||||
describe("Prozent und Umsatzsteuer", () => {
|
||||
@@ -73,3 +73,31 @@ describe("Stunden in Arbeitstage (wie V70)", () => {
|
||||
expect(stundenZuArbeitstagen(10, k("keine"), 3)).toBe(0.42);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Zahlungsplan als Meilensteine vorschlagen", () => {
|
||||
const vs = [
|
||||
{ id: "abbund", name: "Abbund", anfang: "2026-11-02", ende: "2026-11-05" },
|
||||
{ id: "richten", name: "Richten", anfang: "2026-11-09", ende: "2026-11-10" },
|
||||
{ id: "dach", name: "Dacheindeckung", anfang: "2026-11-11", ende: "2026-11-19" },
|
||||
{ id: "rest", name: "Restarbeiten", anfang: "2026-11-23", ende: "2026-11-24" },
|
||||
{ id: "abnahme", name: "Abnahme", anfang: "2026-11-25", ende: "2026-11-25" },
|
||||
];
|
||||
|
||||
it("hängt die Raten an Richten, vorletzten Vorgang und Abnahme", () => {
|
||||
const z = schlageZahlungsplanVor(4_000_000, vs, "2026-10-20");
|
||||
expect(z.map((r) => [r.art, r.netto, r.vorgang_id, r.termin])).toEqual([
|
||||
["anzahlung", 1_200_000, null, "2026-10-20"],
|
||||
["abschlag", 1_600_000, "richten", "2026-11-10"],
|
||||
["abschlag", 800_000, "rest", "2026-11-24"],
|
||||
["schluss", 400_000, "abnahme", "2026-11-25"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("geht auch ohne passende Namen und ohne Vorgänge", () => {
|
||||
const z = schlageZahlungsplanVor(100_001, vs.slice(2, 4), "2026-12-01");
|
||||
expect(z.map((r) => r.vorgang_id)).toEqual([null, "dach", "rest", "rest"]);
|
||||
expect(z.reduce((s, r) => s + r.netto, 0)).toBe(100_001);
|
||||
expect(z[0]!.termin).toBe("2026-11-11");
|
||||
expect(schlageZahlungsplanVor(1000, [], "2026-12-01").every((r) => r.vorgang_id === null && r.termin === "2026-12-01")).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user