Compare commits
3 Commits
feb19241c5
...
ee5b468502
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ee5b468502 | ||
|
|
ee202a450d | ||
|
|
176b1db832 |
18
CHANGELOG.md
18
CHANGELOG.md
@@ -2,6 +2,24 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.21.0
|
||||
|
||||
- Angebot als Dokument wie der spätere Ausdruck (Henning, 21.10.2026, Entwurf angebote/entwurf-uebersicht): Empfänger, Datum, Bindefrist, Betreff, Leistungsort und Einleitung stehen oben direkt sichtbar, Summe und Schlusstext unter den Positionen. Solange eine Position offen ist, klappt der Kopf zu einer Zeile zusammen.
|
||||
- Ruhige Positionszeilen: Pos., Menge, Einheit, Kurztext, EP, Gesamt, dahinter nur kleine Marker Aufmaß, Kalk. und Langtext. Alternativ- und Eventualpositionen kursiv mit der Summe in Klammern.
|
||||
- Ein Klick öffnet die Position mit Reitern Langtext, Aufmaß (Menge als Schild), Kalkulation (Kosten als Schild), Zuschläge & Preis und Mehr (Positionsart, Markierung, Kopieren, Löschen). Wechsel jederzeit, alles wird sofort gespeichert, das Aufmaß rechnet die Kalkulation nach, die Position merkt sich ihren zuletzt offenen Reiter. Lange Gruppen von Kostenzeilen sind eingeklappt („▸ 4 weitere Lohnzeilen“ mit Stunden und Summe). Darunter die Ergebniszeile Kosten → mit Zuschlägen und W&G → EP → Überschuss und die Knöpfe Als Leistung speichern, Abbrechen (setzt die Position auf den Stand beim Öffnen zurück) und Fertig.
|
||||
- Rechts eine Leiste mit Reitern Bausteine, Leistungen (Leistungen, Mengenvorlagen, Material), KI, Vorgaben (mit Beleg, Kalkulation je Kostenart, festgeschriebenen Ständen) und Prüfung; immer nur ein Panel.
|
||||
- Summen als feste Leiste unten: Netto, Brutto, Stunden, Kosten, Überschuss in € und %, Prüfung.
|
||||
- Liquidität, Lage (Henning, 21.10.2026): in „Kommt rein“ und „Geht raus“ blendet das Auge eine Zeile aus der Liste aus, je Benutzer gemerkt; Kurve, Satz und frei verfügbar rechnen weiter mit. Unter der Liste „n Zeilen ausgeblendet · einblenden“.
|
||||
- Liquidität, „Was wäre, wenn“: Haken weg lässt einen Posten probeweise weg, ein Klick aufs Datum verschiebt ihn probeweise. Die Kurve zeigt die Variante gestrichelt, oben steht, was geändert ist und wo der tiefste Punkt dann liegt; die Summe zeigt den probeweisen Betrag. Nichts davon wird gespeichert, „Zurücksetzen“ oder Seitenwechsel löscht es.
|
||||
|
||||
## 0.20.0
|
||||
|
||||
- Liquidität neu (Henning, 21.10.2026, Entwurf aus dem Liquiditäts-Thread): drei Reiter Lage, Monatsplan und Alle Zahlungen; Zeitraum 4 Wochen, 6 Wochen oder 3 Monate gilt für alle drei.
|
||||
- Lage: oben „Frei verfügbar heute“ (Kontostand minus Mindestgrenze) mit Ampel und einem Satz, in welcher Woche es am knappsten wird, wie weit über oder unter der Mindestgrenze, und warum (die größten Ausgaben davor, die nächste große Einnahme danach). Darunter die Kurve je Woche: Kontostand, Einnahmen, Ausgaben, Mindestgrenze und tiefster Punkt; eine Woche anklicken zeigt ihre Zahlungen. Unten „Kommt rein“ und „Geht raus“: Überfälliges rot oben, dann nach Datum, die ersten vier sichtbar, der Rest aufklappbar, laufende Kosten je Monat in einer Zeile.
|
||||
- Mindestgrenze über das Zahnrad an der Kurve: automatisch ein Monat laufende Kosten oder ein fester Betrag.
|
||||
- Offene Einnahmen, deren Zahltag vorbei ist, gelten als überfällig („x Tage überfällig“, ohne gestellte Rechnung „Rechnung fehlt“) und werden heute eingerechnet, statt aus der Vorschau zu fallen.
|
||||
- Startseite: der Liquiditätsblock zeigt dieselbe Lage für 4 Wochen.
|
||||
|
||||
## 0.19.0
|
||||
|
||||
- Terminplan: einzelne Freitage je Vorgang freigeben (Henning, 21.10.2026). Klick in „% erl.“ oder Rechtsklick auf den Balken, unter „Freitag arbeiten“ die Freitage im Zeitraum anhaken. Nur für diesen Vorgang zählt der Freitag als Arbeitstag: Dauer, Ende, Nachfolger, Auslastung, Kalender-Abo, „Wer macht was“ und die Einsätze am Handy. Für alle anderen bleibt der Freitag Reserve. Im Balken ist der freigegebene Freitag grün umrandet.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.19.0",
|
||||
"version": "0.21.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
46
src/domain/lage.ts
Normal file
46
src/domain/lage.ts
Normal file
@@ -0,0 +1,46 @@
|
||||
// Liquidität auf einen Blick (Henning, 21.10.2026): frei verfügbar heute, Ampel und ein Satz, wann es am knappsten
|
||||
// wird und warum. Die Mindestgrenze ist vorerst ein Monat laufende Kosten oder ein fester Betrag; Töpfe kommen in Stufe 5.
|
||||
|
||||
import { type Datum, plusMonate } from "./datum.js";
|
||||
import type { Cent } from "./geld.js";
|
||||
import type { LaufendeKosten, Periode, Posten } from "./liquiditaet.js";
|
||||
|
||||
export type Ampel = "gruen" | "gelb" | "rot";
|
||||
|
||||
export interface Lage {
|
||||
/** Kontostand heute minus Mindestgrenze */
|
||||
frei: Cent;
|
||||
ampel: Ampel;
|
||||
/** Woche mit dem niedrigsten Kontostand am Ende */
|
||||
tief: { von: Datum; bis: Datum; kontostand: Cent } | null;
|
||||
/** Abstand des Tiefpunkts zur Mindestgrenze, negativ = darunter */
|
||||
abstand: Cent;
|
||||
/** die größten Ausgaben bis zum Tiefpunkt */
|
||||
grund: Posten[];
|
||||
/** die nächste größere Einnahme nach dem Tiefpunkt */
|
||||
danach: Posten | null;
|
||||
}
|
||||
|
||||
/** Laufende Kosten eines Monats: monatliche voll, vierteljährliche ein Drittel, jährliche ein Zwölftel; nur was heute läuft */
|
||||
export function laufendJeMonat(laufend: LaufendeKosten[], heute: Datum): Cent {
|
||||
let summe = 0;
|
||||
for (const k of laufend) {
|
||||
if (k.rhythmus === "einmalig" || k.start > plusMonate(heute, 1) || (k.ende && k.ende < heute)) continue;
|
||||
summe += k.rhythmus === "monatlich" ? k.betrag : k.rhythmus === "vierteljaehrlich" ? k.betrag / 3 : k.betrag / 12;
|
||||
}
|
||||
return Math.round(summe);
|
||||
}
|
||||
|
||||
export function lage(wochen: Periode[], kontostand: Cent, mindestgrenze: Cent): Lage {
|
||||
const frei = kontostand - mindestgrenze;
|
||||
if (!wochen.length) return { frei, ampel: kontostand < 0 ? "rot" : kontostand < mindestgrenze ? "gelb" : "gruen", tief: null, abstand: frei, grund: [], danach: null };
|
||||
let ti = 0;
|
||||
wochen.forEach((w, i) => { if (w.kontostand < wochen[ti]!.kontostand) ti = i; });
|
||||
const t = wochen[ti]!;
|
||||
const tiefster = Math.min(kontostand, t.kontostand);
|
||||
const ampel: Ampel = tiefster < 0 ? "rot" : tiefster < mindestgrenze ? "gelb" : "gruen";
|
||||
const bisTief = wochen.slice(0, ti + 1).flatMap((w) => w.posten);
|
||||
const grund = bisTief.filter((p) => p.betrag < 0).sort((a, b) => a.betrag - b.betrag).slice(0, 2);
|
||||
const danach = wochen.slice(ti + 1, ti + 5).flatMap((w) => w.posten).filter((p) => p.betrag > 0).sort((a, b) => b.betrag - a.betrag)[0] ?? null;
|
||||
return { frei, ampel, tief: { von: t.von, bis: t.bis, kontostand: t.kontostand }, abstand: t.kontostand - mindestgrenze, grund, danach };
|
||||
}
|
||||
@@ -23,6 +23,10 @@ export interface Einnahme {
|
||||
termin: Datum;
|
||||
zahlungszielTage?: number;
|
||||
bezahltAm?: Datum;
|
||||
/** bezahlt, auch ohne Datum */
|
||||
bezahlt?: boolean;
|
||||
/** Rechnung gestellt (sonst nur geplant) */
|
||||
gestellt?: boolean;
|
||||
}
|
||||
|
||||
export interface Ausgabe {
|
||||
@@ -63,6 +67,11 @@ export interface Vorschau {
|
||||
startsaldo: Cent;
|
||||
ziele?: Zahlungsziele;
|
||||
ust?: UstEinstellungen;
|
||||
/**
|
||||
* Heute: offene Einnahmen, deren Zahltag schon vorbei ist, gelten als überfällig. Liegen sie vor dem
|
||||
* ersten Zeitraum, kommen sie heute in die Rechnung (das Geld steht ja noch aus), höchstens ein Jahr zurück.
|
||||
*/
|
||||
offeneAb?: Datum;
|
||||
}
|
||||
|
||||
export interface Posten {
|
||||
@@ -72,6 +81,11 @@ export interface Posten {
|
||||
bezeichnung: string;
|
||||
/** positiv = Eingang, negativ = Ausgang */
|
||||
betrag: Cent;
|
||||
/** Einnahme: bezahlt bzw. Rechnung gestellt */
|
||||
bezahlt?: boolean;
|
||||
gestellt?: boolean;
|
||||
/** Einnahme, die seit diesem Tag fällig und noch nicht bezahlt ist */
|
||||
ueberfaelligSeit?: Datum;
|
||||
}
|
||||
|
||||
export interface Periode {
|
||||
@@ -137,7 +151,8 @@ export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] {
|
||||
for (const e of d.einnahmen) {
|
||||
const steuer = ustAusNetto(e.netto, ust.satz);
|
||||
const zahltag = e.bezahltAm ?? plusTage(e.termin, e.zahlungszielTage ?? ziele.kundenTage);
|
||||
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer });
|
||||
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer,
|
||||
...(e.bezahltAm || e.bezahlt ? { bezahlt: true } : {}), ...(e.gestellt ? { gestellt: true } : {}) });
|
||||
buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), e.netto);
|
||||
}
|
||||
for (const a of d.ausgaben) {
|
||||
@@ -217,6 +232,14 @@ export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
|
||||
const grenzen = periodenGrenzen(v);
|
||||
if (grenzen.length === 0) return [];
|
||||
const alle = bewegungen(d, v, grenzen[grenzen.length - 1]!.bis);
|
||||
if (v.offeneAb) {
|
||||
const heute = v.offeneAb, frueh = plusTage(heute, -365), erster = grenzen[0]!.von;
|
||||
for (const p of alle) {
|
||||
if (p.gruppe !== "Projekteinnahmen" || p.bezahlt || p.datum >= heute || p.datum < frueh) continue;
|
||||
p.ueberfaelligSeit = p.datum;
|
||||
if (p.datum < erster) p.datum = heute;
|
||||
}
|
||||
}
|
||||
let kontostand = v.startsaldo;
|
||||
return grenzen.map(({ von, bis }) => {
|
||||
const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum));
|
||||
|
||||
@@ -102,6 +102,8 @@ export function liquiditaetsDaten(b: Bestand, woche: Arbeitswoche, mitAngeboten
|
||||
netto: z.netto,
|
||||
termin: z.rechnungsdatum ?? (folgtVorgang(z) ? bezogen(z) : undefined) ?? z.termin,
|
||||
bezahltAm: z.bezahlt_am ?? undefined,
|
||||
bezahlt: z.status === "bezahlt",
|
||||
gestellt: z.status === "gestellt" || !!z.rechnungsdatum,
|
||||
zahlungszielTage: z.zahlungsziel_tage ?? undefined,
|
||||
}));
|
||||
const kosten: Ausgabe[] = b.kosten
|
||||
|
||||
@@ -42,7 +42,7 @@ export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn
|
||||
|
||||
export async function ladeAngebot(c: Pick<Pool, "query">, id: string, e: Einstellungen) {
|
||||
const angebot = (await c.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, p.bauherr_id, p.status as projekt_status,
|
||||
k.name as bauherr_name, k.firma as bauherr_firma
|
||||
k.name as bauherr_name, k.firma as bauherr_firma, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort
|
||||
from angebot a join projekt p on p.id = a.projekt_id left join kontakt k on k.id = p.bauherr_id where a.id = $1`, [id])).rows[0];
|
||||
if (!angebot) return null;
|
||||
const [t, p, k] = await Promise.all([
|
||||
@@ -223,9 +223,10 @@ export function registriereAngebote(
|
||||
|
||||
app.get("/api/angebote/:id/voll", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const x = await ladeAngebot(pool, id, await einstellungen());
|
||||
const e = await einstellungen();
|
||||
const x = await ladeAngebot(pool, id, e);
|
||||
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return { ...x, pruefung: pruefung(x) };
|
||||
return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz };
|
||||
});
|
||||
|
||||
// A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“
|
||||
|
||||
@@ -14,6 +14,7 @@ import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js";
|
||||
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet } from "../domain/liquiditaet.js";
|
||||
import { laufendJeMonat, lage } from "../domain/lage.js";
|
||||
import { liquiditaetsDaten } from "../domain/projektplan.js";
|
||||
import { uebernimmV70 } from "../domain/v70.js";
|
||||
import { speichereUebernahme } from "./v70import.js";
|
||||
@@ -305,6 +306,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
ansicht: z.enum(["woche", "monat"]).default("woche"),
|
||||
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
|
||||
anzahl: z.coerce.number().int().min(1).max(104).default(12),
|
||||
// offene Einnahmen mit vergangenem Zahltag als überfällig markieren und heute einrechnen
|
||||
offene: z.enum(["0", "1"]).optional(),
|
||||
});
|
||||
|
||||
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
|
||||
@@ -329,11 +332,32 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
{ tage: e.arbeitstage },
|
||||
);
|
||||
const start = q.start ?? new Date().toISOString().slice(0, 10);
|
||||
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
|
||||
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust,
|
||||
offeneAb: q.offene === "1" ? start : undefined });
|
||||
}
|
||||
|
||||
app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query)));
|
||||
|
||||
// Lage der Liquidität (Henning, 21.10.2026): je Woche ab heute, frei verfügbar, Tiefpunkt und Grund
|
||||
async function liquiLage(heute: string, anzahl: number) {
|
||||
const e = await ladeEinstellungen();
|
||||
const [wochen, laufend] = await Promise.all([
|
||||
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl, offene: "1" }),
|
||||
pool.query("select betrag, rhythmus, start, ende from laufende_kosten"),
|
||||
]);
|
||||
const laufendMonat = laufendJeMonat(laufend.rows.map((l) => ({ bezeichnung: "", betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined })), heute);
|
||||
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendMonat;
|
||||
return {
|
||||
heute, wochen, kontostand: e.startsaldo, kontostandDatum: e.startsaldoDatum,
|
||||
mindestgrenze, mindestgrenzeArt: e.mindestgrenzeArt, festerBetrag: e.mindestreserve, laufendMonat,
|
||||
lage: lage(wochen, e.startsaldo, mindestgrenze),
|
||||
};
|
||||
}
|
||||
app.get("/api/liquiditaet/lage", async (req) => {
|
||||
const q = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), wochen: z.coerce.number().int().min(1).max(26).default(13) }).parse(req.query);
|
||||
return liquiLage(q.heute ?? new Date().toISOString().slice(0, 10), q.wochen);
|
||||
});
|
||||
|
||||
// Startseite: Aufgaben, Warnungen, wer macht was in den nächsten zwei Wochen, Liquidität 4 Wochen
|
||||
app.get("/api/uebersicht", async (req) => {
|
||||
const heute = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.query).heute ?? new Date().toISOString().slice(0, 10);
|
||||
@@ -345,10 +369,10 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id
|
||||
left join aufgabe_kategorie g on g.id = a.kategorie_id
|
||||
where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`),
|
||||
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl: 4 }),
|
||||
liquiLage(heute, 4),
|
||||
]);
|
||||
const u = uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui, mindestreserve: e.mindestreserve,
|
||||
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null });
|
||||
const u = { ...uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui: liqui.wochen, mindestreserve: liqui.mindestgrenze,
|
||||
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null }), liquiLage: { ...liqui, wochen: undefined } };
|
||||
// M10: offene Urlaubsanträge oben in den Warnungen, damit kein Mitarbeiter auf Antwort wartet
|
||||
const antraege = await pool.query(`select a.von, a.bis, a.kontakt_id, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id
|
||||
where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`);
|
||||
|
||||
@@ -45,6 +45,8 @@ export const EinstellungenSchema = z.object({
|
||||
startsaldo: z.number().int().default(0),
|
||||
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
|
||||
mindestreserve: z.number().int().default(0),
|
||||
// Mindestgrenze der Liquidität (Henning, 21.10.2026): automatisch ein Monat laufende Kosten oder fest der Betrag oben
|
||||
mindestgrenzeArt: z.enum(["auto", "fest"]).default("auto"),
|
||||
// M3: immer voll abziehen (6:10 → 5:40, Henning 20.10.2026) oder knapp über einer Grenze nur bis zur Grenze (6:10 → 6:00)
|
||||
pausenabzug: z.enum(["bis_grenze", "voll"]).default("voll"),
|
||||
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
|
||||
|
||||
@@ -59,7 +59,7 @@ export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve,
|
||||
warnungen.push({ art: "kontostand", ziel: "daten", text: "Aktueller Kontostand ist noch nicht eingetragen, die Liquidität rechnet ab 0 €" });
|
||||
} else if (knapp) {
|
||||
warnungen.push({ art: "kontostand", ziel: "liquiditaet",
|
||||
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter der Mindestreserve von ${formatEuro(mindestreserve)}` : ""}` });
|
||||
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter deiner Mindestgrenze von ${formatEuro(mindestreserve)}` : ""}` });
|
||||
}
|
||||
|
||||
const tage = naechsteArbeitstage(heute, 8, woche);
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026), neue Maske nach den Bildern vom 21.10.2026: das
|
||||
// Leistungsverzeichnis als Liste, die markierte Position zeigt Schalter (Langtext, Aufmaß, Kalkulation) und darunter
|
||||
// ihre Abschnitte. Rechts Summen, Bausteine, Leistungen, Mengenvorlagen und Material, Vorgaben und Prüfung.
|
||||
// Leistungsverzeichnis als Dokument wie der Ausdruck (Kopf, Einleitung, Positionen, Summe, Schlusstext); ein Klick öffnet die
|
||||
// Position mit Reitern (Langtext, Aufmaß, Kalkulation, Zuschläge & Preis, Mehr). Rechts Reiter für Bausteine, Leistungen, KI, Vorgaben, Prüfung.
|
||||
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
@@ -11,7 +11,7 @@ import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
import type { KiVorschlag } from "../domain/ki.js";
|
||||
import { alleVorlagen, blattAktion, blattHtml, eingabenAbfragen, kuerzelListe, setze, vorlagenListeHtml, zahlAus, zahlText } from "./mengenblatt.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, optionenHtml, seite } from "./ui.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, lies, merke, optionenHtml, seite } from "./ui.js";
|
||||
import { liste } from "./liste.js";
|
||||
|
||||
export const ANGEBOT_STATUS: Record<string, string> = { entwurf: "Entwurf", versendet: "Versendet", angenommen: "Angenommen", abgelehnt: "Abgelehnt" };
|
||||
@@ -23,7 +23,7 @@ const stdText = (h: number) => `${String(Math.round(h * 100) / 100).replace(".",
|
||||
/** Cent mit Nachkommastellen (je Einheit), auf den Cent gerundet angezeigt */
|
||||
const euroGenau = (c: number) => formatEuro(Math.round(c));
|
||||
/** Betrag ohne €-Zeichen für enge Tabellenspalten, deren Kopf schon „€“ oder „EK“ sagt */
|
||||
const betrag = (c: number) => euroGenau(c).replace(/\s*€$/u, "");
|
||||
const betrag = (c: number) => euroGenau(c).replace(/\s*\u20ac$/u, "");
|
||||
|
||||
export function angebotMarke(a: Zeile): string {
|
||||
const abgelaufen = a.status === "versendet" && a.bindefrist && a.bindefrist < heute();
|
||||
@@ -82,33 +82,59 @@ export async function angeboteSeite(): Promise<void> {
|
||||
|
||||
// ---------- Angebot bearbeiten (neue Maske, Bilder 1 bis 5 vom 21.10.2026) ----------
|
||||
|
||||
/** Reiter einer offenen Position (Henning, 21.10.2026: „kann ich zwischen den Reitern wechseln?“) */
|
||||
type Tab = "langtext" | "aufmass" | "kalk" | "preis" | "mehr";
|
||||
const TABS: Tab[] = ["langtext", "aufmass", "kalk", "preis", "mehr"];
|
||||
|
||||
interface Zustand {
|
||||
angebot: string;
|
||||
/** markierte Zeile (Position, Textzeile oder Titel): darunter wird eingefügt, ihre Abschnitte sind offen */
|
||||
/** offene Zeile (Position mit Reitern, Titel oder Text zum Bearbeiten) */
|
||||
aktiv: string | null;
|
||||
/** zugeklappte Abschnitte „<id>:<abschnitt>“ */
|
||||
zu: Set<string>;
|
||||
/** Langtext ohne Text sichtbar gemacht, oder mit Text ausgeblendet */
|
||||
langtextAn: Set<string>;
|
||||
langtextAus: Set<string>;
|
||||
reiter: "bausteine" | "leistungen" | "vorlagen" | "material" | "kalkulation";
|
||||
/** zuletzt offene Zeile: darunter wird eingefügt, auch nach „Fertig“ */
|
||||
ziel: string | null;
|
||||
/** aufgeklappte Gruppen langer Kostenzeilen „<id>:<kostenart>“ */
|
||||
auf: Set<string>;
|
||||
/** Seitenleiste: immer nur ein Panel */
|
||||
reiter: "bausteine" | "leistungen" | "ki" | "vorgaben" | "pruefung";
|
||||
/** im Reiter Leistungen: Leistungen, Mengenvorlagen oder Material */
|
||||
katalog: "leistungen" | "mengen" | "material";
|
||||
suche: string;
|
||||
/** Reiter Leistungen: Ordner-Filter */
|
||||
ordner: string;
|
||||
/** Reiter Material: Suche im Materialstamm und die Treffer */
|
||||
/** Material: Suche im Materialstamm und die Treffer */
|
||||
matSuche: string;
|
||||
matTreffer: Zeile[] | null;
|
||||
/** KI-Vorschlag aus den Leistungen der Stammdaten (0.18) */
|
||||
ki: { text: string; laeuft: boolean; fehler: string; vorschlaege: (KiVorschlag & { an: boolean })[] };
|
||||
kopf: boolean;
|
||||
/** Stand der offenen Position beim Öffnen, für „Abbrechen“ */
|
||||
vorher: { position: Zeile; kosten: Zeile[] } | null;
|
||||
}
|
||||
let zustand: Zustand | null = null;
|
||||
const zustandFuer = (id: string): Zustand => {
|
||||
if (zustand?.angebot !== id) zustand = { angebot: id, aktiv: null, zu: new Set(), langtextAn: new Set(), langtextAus: new Set(), reiter: "bausteine", suche: "", ordner: "", matSuche: "", matTreffer: null,
|
||||
ki: { text: "", laeuft: false, fehler: "", vorschlaege: [] }, kopf: false };
|
||||
if (zustand?.angebot !== id) zustand = { angebot: id, aktiv: null, ziel: null, auf: new Set(), reiter: "bausteine", katalog: "leistungen", suche: "", ordner: "", matSuche: "", matTreffer: null,
|
||||
ki: { text: "", laeuft: false, fehler: "", vorschlaege: [] }, vorher: null };
|
||||
return zustand;
|
||||
};
|
||||
|
||||
/** Die Position merkt sich ihren zuletzt offenen Reiter (in diesem Browser) */
|
||||
const TAB_SCHLUESSEL = "angebot-position-reiter";
|
||||
function gemerkteTabs(): Record<string, Tab> {
|
||||
try { return JSON.parse(lies(TAB_SCHLUESSEL) ?? "{}") as Record<string, Tab>; } catch { return {}; }
|
||||
}
|
||||
function tabVon(p: Zeile): Tab {
|
||||
const t = gemerkteTabs()[p.id];
|
||||
if (t && TABS.includes(t)) return t;
|
||||
return p.mit_kalkulation ? "kalk" : p.mit_aufmass ? "aufmass" : "langtext";
|
||||
}
|
||||
function merkeTab(pid: string, t: Tab): void {
|
||||
const alle = gemerkteTabs();
|
||||
delete alle[pid];
|
||||
alle[pid] = t;
|
||||
const schluessel = Object.keys(alle);
|
||||
for (const k of schluessel.slice(0, Math.max(0, schluessel.length - 300))) delete alle[k];
|
||||
merke(TAB_SCHLUESSEL, JSON.stringify(alle));
|
||||
}
|
||||
|
||||
export const angebotSeite = (id: string) => editor(id, null);
|
||||
|
||||
/** Großes Mengenblatt einer Position (Bilder 3 und 4) */
|
||||
@@ -148,6 +174,11 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
inhalt.replaceChildren(wurzel);
|
||||
|
||||
const zeichne = () => {
|
||||
// Stand der eben geöffneten Position für „Abbrechen“ festhalten
|
||||
const offen = z.aktiv ? d.positionen.find((x: Zeile) => x.id === z.aktiv && !x.textzeile) : null;
|
||||
if (!offen) z.vorher = null;
|
||||
else if (z.vorher?.position.id !== offen.id) z.vorher = { position: structuredClone(offen), kosten: structuredClone(d.kosten.filter((k: Zeile) => k.position_id === offen.id)) };
|
||||
if (z.aktiv) z.ziel = z.aktiv;
|
||||
// Fokus und gerade Getipptes über den Neuaufbau retten (gespeichert wird beim Verlassen eines Feldes)
|
||||
const fokus = document.activeElement as HTMLInputElement | null;
|
||||
const k = fokus?.dataset?.k;
|
||||
@@ -245,7 +276,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (!eingaben) return;
|
||||
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was, vorlage_id: v.id, nach_id: nachId, ...(inPosition ? { position_id: inPosition } : {}), eingaben });
|
||||
z.aktiv = r.id;
|
||||
z.zu.delete(`${r.id}:aufmass`);
|
||||
if (inPosition) merkeTab(r.id, "aufmass");
|
||||
return neuLaden(inPosition ? `Vorlage „${v.name}“ ist im Mengenblatt.` : `${v.art === "muster" ? "Leistung" : "Mengenvorlage"} „${v.kurztext || v.name}“ eingefügt.`);
|
||||
}
|
||||
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was, nach_id: nachId });
|
||||
@@ -283,16 +314,9 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
return neuLaden();
|
||||
};
|
||||
|
||||
/** Schalter unter der markierten Position (Bild 1): Langtext, Aufmaß, Kalkulation, Markieren */
|
||||
/** Aufmaß, Kalkulation und Markierung einer Position ein- und ausschalten */
|
||||
const schalter = async (pid: string, was: string) => {
|
||||
const p = pos(pid)!, r = d.ergebnis.positionen[pid];
|
||||
if (was === "langtext") {
|
||||
const sichtbar = p.langtext ? !z.langtextAus.has(pid) : z.langtextAn.has(pid);
|
||||
if (sichtbar) { z.langtextAus.add(pid); z.langtextAn.delete(pid); } else { z.langtextAus.delete(pid); z.langtextAn.add(pid); }
|
||||
zeichne();
|
||||
if (!sichtbar) wurzel.querySelector<HTMLTextAreaElement>(`[data-k="angebot-positionen:${pid}:langtext"]`)?.focus();
|
||||
return;
|
||||
}
|
||||
if (was === "aufmass") {
|
||||
if (p.mit_aufmass) await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: false, menge: r.menge });
|
||||
else {
|
||||
@@ -300,7 +324,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
const b = alsBlatt(p.aufmass);
|
||||
if (!b.werte.length && !b.listen.length && !b.zeilen.length) b.zeilen.push({ text: "", formel: zahlText(p.menge) });
|
||||
await api(`angebot-positionen/${pid}`, "PATCH", { mit_aufmass: true, aufmass: b });
|
||||
z.zu.delete(`${pid}:aufmass`);
|
||||
merkeTab(pid, "aufmass");
|
||||
}
|
||||
return neuLaden();
|
||||
}
|
||||
@@ -309,13 +333,36 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (p.mit_kalkulation) await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: false, ep_fest: r.ep });
|
||||
else {
|
||||
await api(`angebot-positionen/${pid}`, "PATCH", { mit_kalkulation: true, ep_fest: null });
|
||||
z.zu.delete(`${pid}:kalk`); z.zu.delete(`${pid}:verkauf`);
|
||||
merkeTab(pid, "kalk");
|
||||
}
|
||||
return neuLaden();
|
||||
}
|
||||
if (was === "markiert") { await api(`angebot-positionen/${pid}`, "PATCH", { markiert: !p.markiert }); return neuLaden(); }
|
||||
};
|
||||
|
||||
/** „Abbrechen“: Position und Kostenzeilen auf den Stand beim Öffnen zurücksetzen */
|
||||
const FELDER_P = ["kurztext", "langtext", "menge", "einheit", "art", "grundposition_id", "ep_fest", "mit_kalkulation", "mit_aufmass", "aufmass", "markiert"];
|
||||
const FELDER_K = ["kostenart", "lohnart", "beschreibung", "menge", "einheit", "ek", "faktor", "faktor_grund", "zuschlag_prozent", "bezug", "personen", "aktiv", "aus_vorlage", "reihenfolge"];
|
||||
const zahlOderNull = (v: unknown) => (v == null ? null : Number(v));
|
||||
const auswahlP = (p: Zeile) => ({ ...Object.fromEntries(FELDER_P.map((f) => [f, p[f] ?? null])), menge: Number(p.menge), ep_fest: zahlOderNull(p.ep_fest) });
|
||||
const auswahlK = (k: Zeile) => ({ ...Object.fromEntries(FELDER_K.map((f) => [f, k[f] ?? null])), menge: Number(k.menge), ek: zahlOderNull(k.ek), faktor: Number(k.faktor),
|
||||
zuschlag_prozent: zahlOderNull(k.zuschlag_prozent), personen: Number(k.personen ?? 1), reihenfolge: Number(k.reihenfolge) });
|
||||
const abbrechen = async () => {
|
||||
const v = z.vorher, jetzt = v && pos(v.position.id);
|
||||
z.aktiv = null;
|
||||
if (!v || !jetzt) return zeichne();
|
||||
const pAlt = auswahlP(v.position);
|
||||
const geaendertP = JSON.stringify(pAlt) !== JSON.stringify(auswahlP(jetzt));
|
||||
const kAlt = v.kosten.map(auswahlK), kJetzt = kostenVon(jetzt.id);
|
||||
const geaendertK = JSON.stringify(kAlt) !== JSON.stringify(kJetzt.map(auswahlK));
|
||||
if (geaendertP) await api(`angebot-positionen/${jetzt.id}`, "PATCH", pAlt);
|
||||
if (geaendertK) {
|
||||
for (const k of kJetzt) await api(`angebot-kosten/${k.id}`, "DELETE");
|
||||
for (const k of kAlt) await api("angebot-kosten", "POST", { position_id: jetzt.id, ...k });
|
||||
}
|
||||
return neuLaden(geaendertP || geaendertK ? `Änderungen an ${ordnung(d).oz[jetzt.id] ?? "der Position"} verworfen.` : "");
|
||||
};
|
||||
|
||||
zeichne();
|
||||
|
||||
wurzel.addEventListener("change", async (ev) => {
|
||||
@@ -401,23 +448,33 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (a === "aktiv") {
|
||||
if (z.aktiv === zid) return;
|
||||
z.aktiv = zid;
|
||||
return zeichne();
|
||||
zeichne();
|
||||
// in das angeklickte Feld springen (Menge, Einheit oder Kurztext)
|
||||
const f = (ev.target as HTMLElement).closest<HTMLElement>("[data-fokus]")?.dataset.fokus ?? "kurztext";
|
||||
const ziel = wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-positionen:${zid}:${f}"]`) ?? wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-titel:${zid}:bezeichnung"]`)
|
||||
?? wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-positionen:${zid}:kurztext"]`);
|
||||
ziel?.focus();
|
||||
return;
|
||||
}
|
||||
if (a.startsWith("b-")) {
|
||||
const pid = b.dataset.b!.split(":")[1]!;
|
||||
return await blattSpeichern(pid, (x) => blattAktion(x, a, b.dataset)).then(() => neuLaden());
|
||||
}
|
||||
if (a === "chip") return await schalter(zid, b.dataset.was!);
|
||||
if (a === "abschnitt") { const k = `${zid}:${b.dataset.was}`; z.zu.has(k) ? z.zu.delete(k) : z.zu.add(k); return zeichne(); }
|
||||
if (a === "tab") { merkeTab(zid, b.dataset.was as Tab); return zeichne(); }
|
||||
if (a === "kosten-auf") { const k = `${zid}:${b.dataset.was}`; z.auf.has(k) ? z.auf.delete(k) : z.auf.add(k); return zeichne(); }
|
||||
if (a === "fertig") { z.aktiv = null; return zeichne(); }
|
||||
if (a === "reiter") {
|
||||
z.reiter = b.dataset.was as Zustand["reiter"];
|
||||
if (a === "abbrechen") return await abbrechen();
|
||||
if (a === "reiter" || a === "katalog") {
|
||||
z.reiter = a === "katalog" ? "leistungen" : b.dataset.was as Zustand["reiter"];
|
||||
if (a === "katalog") z.katalog = b.dataset.was as Zustand["katalog"];
|
||||
zeichne();
|
||||
wurzel.querySelector<HTMLElement>(".am-reiter-karte")?.scrollIntoView({ block: "nearest" });
|
||||
const leiste = wurzel.querySelector<HTMLElement>(".am-leiste");
|
||||
leiste?.scrollIntoView({ block: "nearest" });
|
||||
leiste?.querySelector<HTMLInputElement>("input.suche")?.focus({ preventScroll: true });
|
||||
return;
|
||||
}
|
||||
if (a === "kopf") { z.kopf = !z.kopf; return zeichne(); }
|
||||
if (a === "neu") return await einfuegen(b.dataset.was!, z.aktiv);
|
||||
if (a === "neu") return await einfuegen(b.dataset.was!, z.aktiv ?? z.ziel);
|
||||
if (a === "ki") {
|
||||
z.ki.laeuft = true; z.ki.fehler = "";
|
||||
zeichne();
|
||||
@@ -432,7 +489,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (a === "ki-weg") { z.ki.vorschlaege = []; z.ki.fehler = ""; return zeichne(); }
|
||||
if (a === "ki-los") {
|
||||
// der Reihe nach unter die markierte Zeile, jede unter die vorige
|
||||
let nach = z.aktiv;
|
||||
let nach = z.aktiv ?? z.ziel;
|
||||
const gewaehlt = z.ki.vorschlaege.filter((v) => v.an);
|
||||
for (const v of gewaehlt) {
|
||||
const r = await api<Zeile>(`angebote/${id}/einfuegen`, "POST", { was: "vorlage", vorlage_id: v.id, nach_id: nach, ...(v.menge != null ? { menge: v.menge } : {}) });
|
||||
@@ -451,10 +508,11 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
await api("angebot-kosten", "POST", { position_id: p.id, kostenart: "material", beschreibung: art.bezeichnung, einheit: art.einheit ?? p.einheit ?? null,
|
||||
ek: art.ek == null ? null : Math.round(Number(art.ek) / Number(art.preiseinheit || 1)), bezug: blatt?.menge?.trim() || null, menge: 1,
|
||||
reihenfolge: kostenVon(p.id).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) });
|
||||
z.zu.delete(`${p.id}:kalk`);
|
||||
z.auf.add(`${p.id}:material`);
|
||||
merkeTab(p.id, "kalk");
|
||||
return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`);
|
||||
}
|
||||
if (a === "vorlage") return await einfuegen("vorlage", z.aktiv, zid, b.dataset.in);
|
||||
if (a === "vorlage") return await einfuegen("vorlage", z.aktiv ?? z.ziel, zid, b.dataset.in);
|
||||
if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; }
|
||||
if (a === "als-vorlage") return await alsVorlage(zid);
|
||||
if (a === "kosten-neu") {
|
||||
@@ -465,6 +523,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1,
|
||||
beschreibung: fahrt ? "Fahrt zur Baustelle" : null,
|
||||
bezug: fahrt ? null : blatt?.menge?.trim() || null, einheit: art === "lohn" ? "h" : fahrt ? "km" : p.einheit ?? null, reihenfolge: kostenVon(zid).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) });
|
||||
z.auf.add(`${zid}:${art}`);
|
||||
await neuLaden();
|
||||
wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-kosten:${k.id}:beschreibung"]`)?.focus();
|
||||
return;
|
||||
@@ -475,6 +534,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (!(await bestaetigen(p.textzeile ? "Textzeile löschen?" : "Position mit Mengenblatt und Kostenzeilen löschen?"))) return;
|
||||
await api(`angebot-positionen/${zid}`, "DELETE");
|
||||
if (z.aktiv === zid) z.aktiv = null;
|
||||
if (z.ziel === zid) z.ziel = null;
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "titel-weg") {
|
||||
@@ -553,7 +613,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Darstellung ----------
|
||||
// ---------- Darstellung (Dokumentansicht wie das spätere PDF, Henning 21.10.2026) ----------
|
||||
|
||||
type Feldoptionen = { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string; nurLesen?: boolean };
|
||||
const feldBau = (frei: boolean) => (k: string, wert: unknown, o: Feldoptionen = {}) =>
|
||||
@@ -562,22 +622,51 @@ const feldBau = (frei: boolean) => (k: string, wert: unknown, o: Feldoptionen =
|
||||
const auswahlBau = (frei: boolean) => (k: string, optionen: [string, string][], wert: string, titel: string) =>
|
||||
`<select data-k="${k}" aria-label="${esc(titel)}"${frei ? "" : " disabled"}>${optionenHtml(optionen, wert)}</select>`;
|
||||
const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false));
|
||||
const chip = (text: string, an: boolean, was: string, pid: string, frei: boolean) =>
|
||||
`<button class="chip${an ? " an" : ""}" data-a="chip" data-was="${was}" data-id="${pid}" aria-pressed="${an}"${frei || was === "langtext" ? "" : " disabled"}><span class="p" aria-hidden="true"></span>${text}</button>`;
|
||||
const wgp = (s: Zeile) => s.wagnis + s.gewinn + s.ausfall;
|
||||
/** Fließtext wie im Ausdruck: Feld ohne Rahmen, wächst mit dem Inhalt */
|
||||
const fliesstext = (k: string, wert: string | null | undefined, platz: string, frei: boolean, titel: string) =>
|
||||
`<textarea class="am-fliess" data-k="${k}" rows="${Math.max(2, String(wert ?? "").split("\n").length + 1)}" placeholder="${esc(platz)}" aria-label="${esc(titel)}"${frei ? "" : " disabled"}>${esc(wert ?? "")}</textarea>`;
|
||||
const ZEILEN_NAME: Record<string, string> = { lohn: "Lohnzeilen", material: "Materialzeilen", geraet: "Gerätezeilen", fahrt: "Fahrtzeilen", subunternehmer: "Subunternehmerzeilen", sonstiges: "sonstige Zeilen" };
|
||||
/** ab so vielen Zeilen einer Kostenart werden die übrigen eingeklappt */
|
||||
const GRUPPE_AB = 4, GRUPPE_SICHTBAR = 2;
|
||||
|
||||
/** Kostenzeilen einer Position (Bild 2, „Kalkulation (Kosten)“): Bezug × Ansatz × Personen = Menge der ganzen Position */
|
||||
function kostenTabelle(d: Zeile, p: Zeile, frei: boolean): string {
|
||||
/** Kostenzeilen einer Position: Bezug × Ansatz × Personen = Menge der ganzen Position. Lange Gruppen einer Kostenart sind eingeklappt. */
|
||||
function kostenTabelle(d: Zeile, p: Zeile, frei: boolean, auf?: Set<string>): string {
|
||||
const feld = feldBau(frei), auswahl = auswahlBau(frei);
|
||||
const s = d.saetze, r = d.ergebnis.positionen[p.id];
|
||||
const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id);
|
||||
const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id) as Zeile[];
|
||||
const menge = r.menge;
|
||||
let lohnStd = 0, summe = 0;
|
||||
const erg = (i: number) => r.kostenzeilen[i] ?? { kosten: 0, menge_gesamt: 0, aktiv: true, fehler: null };
|
||||
// je Kostenart: welche Zeilen bleiben sichtbar, wo steht die Klappzeile
|
||||
const versteckt = new Set<number>(), klappNach = new Map<number, string>(), zuNach = new Map<number, string>();
|
||||
if (auf) {
|
||||
for (const art of KOSTENARTEN) {
|
||||
const idx = zeilen.flatMap((k, i) => (k.kostenart === art ? [i] : []));
|
||||
if (idx.length < GRUPPE_AB) continue;
|
||||
if (auf.has(`${p.id}:${art}`)) { zuNach.set(idx.at(-1)!, art); continue; }
|
||||
const rest = idx.slice(GRUPPE_SICHTBAR).filter((i) => !erg(i).fehler);
|
||||
if (rest.length < 2) continue;
|
||||
rest.forEach((i) => versteckt.add(i));
|
||||
klappNach.set(idx.filter((i) => !versteckt.has(i)).at(-1)!, art);
|
||||
}
|
||||
}
|
||||
const klappZeile = (art: string, offen: boolean) => {
|
||||
if (offen) return `<tr class="am-klapp"><td colspan="11"><button class="verweis" data-a="kosten-auf" data-id="${p.id}" data-was="${art}">▴ ${ZEILEN_NAME[art]} einklappen</button></td></tr>`;
|
||||
const teil = [...versteckt].filter((i) => zeilen[i]!.kostenart === art);
|
||||
const std = teil.reduce((t, i) => t + (art === "lohn" && erg(i).aktiv ? erg(i).menge_gesamt : 0), 0);
|
||||
const eur = teil.reduce((t, i) => t + (erg(i).aktiv ? erg(i).kosten * menge : 0), 0);
|
||||
const namen = teil.map((i) => zeilen[i]!.beschreibung).filter(Boolean).slice(0, 3).join(", ");
|
||||
return `<tr class="am-klapp"><td colspan="11"><button class="verweis" data-a="kosten-auf" data-id="${p.id}" data-was="${art}">▸ ${teil.length} weitere ${ZEILEN_NAME[art]}${namen ? ` (${esc(namen)}${teil.length > 3 ? " …" : ""})` : ""}</button>
|
||||
<span class="hinweis-k">${std ? `${stdText(std)} · ` : ""}${euroGenau(eur)}</span></td></tr>`;
|
||||
};
|
||||
const rumpf = zeilen.map((k: Zeile, i: number) => {
|
||||
const z = r.kostenzeilen[i] ?? { kosten: 0, menge_gesamt: 0, aktiv: true, fehler: null };
|
||||
const z = erg(i);
|
||||
const lohn = k.kostenart === "lohn", fahrt = k.kostenart === "fahrt", mitPers = lohn || fahrt;
|
||||
if (lohn && z.aktiv) lohnStd += z.menge_gesamt;
|
||||
if (z.aktiv) summe += z.kosten * menge;
|
||||
const nach = klappNach.has(i) ? klappZeile(klappNach.get(i)!, false) : zuNach.has(i) ? klappZeile(zuNach.get(i)!, true) : "";
|
||||
if (versteckt.has(i)) return nach;
|
||||
// Fahrt: 2 × Strecke × Einsatztage × Fahrzeuge (Henning, 21.10.2026)
|
||||
const fahrtText = fahrt && !z.fehler ? `<span class="kz-rechnung">2 × ${esc(k.bezug ?? "")} km × ${zahlText(k.menge)} ${Number(k.menge) === 1 ? "Tag" : "Tage"}${Number(k.personen ?? 1) !== 1 ? ` × ${zahlText(k.personen)} Fahrzeuge` : ""}</span>` : "";
|
||||
return `<tr class="kz-${k.kostenart}${z.aktiv ? "" : " aus"}"><td>${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")}</td>
|
||||
@@ -590,13 +679,14 @@ function kostenTabelle(d: Zeile, p: Zeile, frei: boolean): string {
|
||||
<td>${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-ek", leer: "null", titel: fahrt ? "Kosten je km" : "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00", spalte: `ke-${p.id}` })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })}</td>
|
||||
<td class="zahl">${betrag(z.kosten * menge)}</td>
|
||||
<td class="kz-aus"><input type="checkbox" data-k="angebot-kosten:${k.id}:aktiv" data-typ="bool"${z.aktiv ? " checked" : ""} title="notwendig" aria-label="notwendig"${frei ? "" : " disabled"}>${frei ? `<button class="weg" data-a="kosten-weg" data-id="${k.id}" title="Kostenzeile löschen" aria-label="Kostenzeile löschen">×</button>` : ""}</td></tr>`;
|
||||
<td class="kz-aus"><input type="checkbox" data-k="angebot-kosten:${k.id}:aktiv" data-typ="bool"${z.aktiv ? " checked" : ""} title="notwendig" aria-label="notwendig"${frei ? "" : " disabled"}>${frei ? `<button class="weg" data-a="kosten-weg" data-id="${k.id}" title="Kostenzeile löschen" aria-label="Kostenzeile löschen">×</button>` : ""}</td></tr>${nach}`;
|
||||
}).join("");
|
||||
if (!frei && !zeilen.length) return '<p class="hinweis">Keine Kostenzeilen.</p>';
|
||||
return `<div class="kosten-rolle"><table class="kosten-tabelle am-t"><thead><tr><th>Art</th><th>Bezeichnung</th><th>Bezug</th><th class="zahl">Ansatz</th><th class="zahl">Pers.</th><th class="zahl">Menge</th><th>Lohnart / Einh.</th><th class="zahl">EK</th><th class="zahl">Faktor</th><th class="zahl">EK gesamt</th><th title="notwendig: abgewählte Zeilen zählen nicht">✓</th></tr></thead>
|
||||
<tbody>${rumpf}<tr class="summe"><td colspan="5">Kosten gesamt${menge > 0 ? ` (${euro(r.kosten_je_einheit)} je ${esc(p.einheit)})` : ""}</td><td class="zahl">${lohnStd ? `${zahlDeutsch(lohnStd, "h")} h` : ""}</td><td colspan="3"></td><td class="zahl">${betrag(summe)}</td><td></td></tr></tbody></table></div>
|
||||
${frei ? `<div class="knopfreihe">${KOSTENARTEN.map((x) => `<button class="neben klein" data-a="kosten-neu" data-art="${x}" data-id="${p.id}">+ ${KOSTENART_NAME[x]}</button>`).join("")}</div>` : ""}
|
||||
<p class="hinweis-k">Menge = Bezug × Ansatz × Personen, wie in deiner Urkalk. Der Bezug ist ein Kürzel aus dem Mengenblatt (z. B. HL); leer heißt je ${esc(p.einheit)} der Position. Fahrt: Bezug = Strecke einfach in km, Ansatz = Einsatztage, Pers. = Fahrzeuge; gerechnet wird 2 × Strecke × Tage. Abgewählte Zeilen (✓) bleiben stehen und zählen nicht.</p>`;
|
||||
${frei ? `<div class="knopfreihe">${KOSTENARTEN.map((x) => `<button class="neben klein" data-a="kosten-neu" data-art="${x}" data-id="${p.id}">+ ${KOSTENART_NAME[x]}</button>`).join("")}
|
||||
${auf ? '<button class="neben klein" data-a="katalog" data-was="material">+ aus Stammdaten</button>' : ""}</div>` : ""}
|
||||
<p class="hinweis-k">Menge = Bezug × Ansatz × Personen. Der Bezug ist ein Kürzel aus dem Aufmaß (z. B. HL); leer heißt je ${esc(p.einheit)}. Fahrt: Bezug = Strecke einfach, Ansatz = Einsatztage, Pers. = Fahrzeuge. Abgewählte Zeilen (✓) zählen nicht.</p>`;
|
||||
}
|
||||
|
||||
/** „Verkauf und Zuschläge“ je Kostenart der Position, mit „Preis anpassen“ (A21) */
|
||||
@@ -622,100 +712,137 @@ function verkaufTabelle(d: Zeile, p: Zeile, frei: boolean): string {
|
||||
<tbody>${rumpf || '<tr><td colspan="6" class="hinweis">Noch keine Kostenzeile.</td></tr>'}<tr class="summe"><td>Summe</td><td class="zahl">${euroGenau(ekS)}</td><td></td><td class="zahl">${euroGenau(zuS)}</td><td class="zahl">${euroGenau(wgS)}</td><td class="zahl">${euroGenau(vkS)}</td></tr></tbody></table></div>
|
||||
<div class="knopfreihe am-ep-zeile"><span>Einheitspreis kalkuliert <b>${euro(r.ep_kalkuliert)}</b> je ${esc(p.einheit)}${fest ? `, angepasst auf <b>${euro(r.ep)}</b>` : ""}; Gesamt ${zahlDeutsch(r.menge, p.einheit)} × ${euro(r.ep)} = <b>${euro(r.gb)}</b></span>
|
||||
<label class="am-anpassen">Preis anpassen auf ${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einheitspreis anpassen", platz: "– €" })}</label></div>
|
||||
<p class="hinweis-k">Leeres Zuschlagsfeld: Vorgabe des Angebots. Wagnis, Gewinn und Ausfall stellst du rechts unter „Vorgaben dieses Angebots“ ein.</p>`;
|
||||
<p class="hinweis-k">Leeres Zuschlagsfeld: Vorgabe des Angebots. Wagnis, Gewinn und Ausfall stellst du rechts im Reiter Vorgaben ein.</p>`;
|
||||
}
|
||||
|
||||
/** Aufmaß-Abschnitt in der Position (Bild 2 und 5) */
|
||||
/** Reiter Aufmaß in der offenen Position */
|
||||
function aufmassAbschnitt(d: Zeile, p: Zeile, frei: boolean): string {
|
||||
const b = alsBlatt(p.aufmass);
|
||||
const a = werteBlatt(b, umgebungVon(d.saetze));
|
||||
return `${blattHtml(b, a, { k: `blatt:${p.id}:`, frei, modus: "inline", einheit: p.einheit })}
|
||||
<div class="knopfreihe">${frei ? `<button class="neben klein" data-a="b-zeile-neu" data-b="blatt:${p.id}:">+ Zeile</button>
|
||||
<button class="neben klein am-betont" data-a="reiter" data-was="vorlagen">${b.vorlage ? "Vorlage wechseln →" : "Vorlage einfügen →"}</button>` : ""}
|
||||
<button class="neben klein am-betont" data-a="katalog" data-was="mengen">${b.vorlage ? "Vorlage wechseln →" : "Vorlage einfügen →"}</button>` : ""}
|
||||
<button class="neben klein" data-a="gross" data-id="${p.id}">Mengenblatt groß öffnen</button>
|
||||
<span class="hinweis-k">Jede Zeile darf rechnen (+ − * / Klammern, cos, wurzel …). Mit einer Vorlage kommen Kürzel und Bauteillisten dazu.</span></div>`;
|
||||
}
|
||||
|
||||
function abschnitt(z: Zustand, pid: string, was: string, titel: string, info: string, rumpf: string): string {
|
||||
const zu = z.zu.has(`${pid}:${was}`);
|
||||
return `<div class="abschnitt"><h4><button class="am-auf" data-a="abschnitt" data-id="${pid}" data-was="${was}" aria-expanded="${!zu}"><span class="zu" aria-hidden="true">${zu ? "▸" : "▾"}</span>${titel}</button><span class="info">${info}</span></h4>
|
||||
${zu ? "" : `<div class="rumpf">${rumpf}</div>`}</div>`;
|
||||
/** Ergebniszeile unter den Reitern: Kosten → mit Zuschlägen und W&G → EP → Überschuss */
|
||||
function ergebnisZeile(p: Zeile, r: Zeile): string {
|
||||
const je = `je ${esc(p.einheit)}`;
|
||||
if (!p.mit_kalkulation) return `Ohne Kalkulation: EP <b>${euro(r.ep)} ${je}</b> × ${zahlDeutsch(r.menge, p.einheit)} = <b>${euro(r.gb)}</b>`;
|
||||
const ueber = r.kosten_gesamt > 0 ? Math.round(((r.gb - r.kosten_gesamt) / r.kosten_gesamt) * 1000) / 10 : null;
|
||||
return `Kosten <b>${euro(r.kosten_gesamt)}</b>${r.stunden ? ` · ${stdText(r.stunden)}` : ""}
|
||||
<span class="pfeil">→</span> mit Zuschlägen und W&G <b>${euro(Math.round(r.ep_kalkuliert * r.menge))}</b>
|
||||
<span class="pfeil">→</span> EP <b>${euro(r.ep)} ${je}</b>${p.ep_fest != null ? ' <span class="marke-q kalk">angepasst</span>' : ""}${ueber !== null ? ` · Überschuss ${prozentText(ueber)}` : ""}`;
|
||||
}
|
||||
|
||||
function offenePosition(d: Zeile, z: Zustand, p: Zeile, frei: boolean): string {
|
||||
/** Die offene Position: Reiter Langtext | Aufmaß | Kalkulation | Zuschläge & Preis | Mehr, Wechsel jederzeit */
|
||||
function offenePosition(d: Zeile, oz: Record<string, string>, p: Zeile, frei: boolean): string {
|
||||
const feld = feldBau(frei), auswahl = auswahlBau(frei);
|
||||
const r = d.ergebnis.positionen[p.id];
|
||||
const teile: string[] = [];
|
||||
const langtext = p.langtext ? !z.langtextAus.has(p.id) : z.langtextAn.has(p.id);
|
||||
if (langtext) teile.push(abschnitt(z, p.id, "langtext", "Langtext", p.langtext && /\{[\p{L}_]/u.test(p.langtext) ? "{Kürzel} wird mit dem Mengenblatt ersetzt" : "",
|
||||
`<textarea data-k="angebot-positionen:${p.id}:langtext" rows="4" aria-label="Langtext"${frei ? "" : " disabled"}>${esc(p.langtext ?? "")}</textarea>`));
|
||||
if (p.mit_aufmass) {
|
||||
const b = alsBlatt(p.aufmass);
|
||||
teile.push(abschnitt(z, p.id, "aufmass", "Aufmaß und Mengenermittlung",
|
||||
`${b.vorlage ? `Vorlage <b>${esc(b.vorlage.name)}</b> · ` : b.werte.length ? "" : "frei, ohne Vorlage · "}Menge = ${b.menge?.trim() ? `<span class="am-kz-t">${esc(b.menge)}</span> ` : "Summe "}<b>${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}</b>${r.aufmass_fehler ? ` <span class="am-fehler">${esc(r.aufmass_fehler)}</span>` : ""}`,
|
||||
aufmassAbschnitt(d, p, frei)));
|
||||
const tab = tabVon(p);
|
||||
const knopf = (t: Tab, text: string, badge = "") => `<button role="tab" class="${tab === t ? "an" : ""}" aria-selected="${tab === t}" data-a="tab" data-id="${p.id}" data-was="${t}">${text}${badge ? ` <small>${badge}</small>` : ""}</button>`;
|
||||
const aus = '<small class="aus">aus</small>';
|
||||
let panel = "";
|
||||
if (tab === "langtext") {
|
||||
panel = `<textarea data-k="angebot-positionen:${p.id}:langtext" rows="${Math.max(4, String(p.langtext ?? "").split("\n").length + 1)}" aria-label="Langtext" placeholder="Ausführliche Beschreibung für den Kunden, z. B. Material, Güte, Ausführung"${frei ? "" : " disabled"}>${esc(p.langtext ?? "")}</textarea>
|
||||
${p.langtext && /\{[\p{L}_]/u.test(p.langtext) ? '<p class="hinweis-k">{Kürzel} wird mit dem Wert aus dem Aufmaß ersetzt.</p>' : ""}`;
|
||||
} else if (tab === "aufmass") {
|
||||
panel = p.mit_aufmass
|
||||
? `${r.aufmass_fehler ? `<p class="am-fehler">${esc(r.aufmass_fehler)}</p>` : ""}${aufmassAbschnitt(d, p, frei)}
|
||||
${frei ? `<p class="hinweis-k"><button class="verweis" data-a="chip" data-was="aufmass" data-id="${p.id}">Aufmaß ausschalten</button>, die Menge bleibt dann fest stehen.</p>` : ""}`
|
||||
: `<p class="hinweis">Die Menge steht oben direkt in der Zeile. Mit Aufmaß rechnest du sie aus Maßen, Formeln oder einer Mengenvorlage, und die Kalkulation rechnet mit.</p>
|
||||
${frei ? `<button class="neben" data-a="chip" data-was="aufmass" data-id="${p.id}">Aufmaß einschalten</button>` : ""}`;
|
||||
} else if (tab === "kalk") {
|
||||
panel = p.mit_kalkulation
|
||||
? `${kostenTabelle(d, p, frei, zustand?.auf ?? new Set())}
|
||||
${frei ? `<p class="hinweis-k"><button class="verweis" data-a="chip" data-was="kalkulation" data-id="${p.id}">Kalkulation ausschalten</button>, der Einheitspreis bleibt dann fest stehen.</p>` : ""}`
|
||||
: `<p class="hinweis">Der Einheitspreis steht oben direkt in der Zeile. Mit Kalkulation entsteht er aus Lohn, Material, Gerät, Fahrt und Sub mit deinen Zuschlägen.</p>
|
||||
${frei ? `<button class="neben" data-a="chip" data-was="kalkulation" data-id="${p.id}">Kalkulation einschalten</button>` : ""}`;
|
||||
} else if (tab === "preis") {
|
||||
panel = p.mit_kalkulation ? verkaufTabelle(d, p, frei)
|
||||
: `<label class="am-anpassen">Einheitspreis ${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einheitspreis", platz: "0,00" })} € je ${esc(p.einheit)}</label>
|
||||
<p class="hinweis-k">Ohne Kalkulation gibt es keine Zuschläge; der Preis gilt so, wie er hier steht.</p>`;
|
||||
} else {
|
||||
const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ" && !x.textzeile);
|
||||
panel = `<div class="am-mehr">
|
||||
<label>Positionsart ${auswahl(`angebot-positionen:${p.id}:art`, POSITIONSARTEN.map((x) => [x, POSITIONSART_NAME[x]]), p.art ?? "normal", "Positionsart")}</label>
|
||||
${p.art === "alternativ" ? `<label>Alternativ zu ${auswahl(`angebot-positionen:${p.id}:grundposition_id`, [["", "bitte wählen …"], ...grund.map((x: Zeile): [string, string] => [x.id, `${oz[x.id]} ${x.kurztext}`])], p.grundposition_id ?? "", "Grundposition")}</label>` : ""}
|
||||
<label class="am-radio"><input type="checkbox" data-k="angebot-positionen:${p.id}:markiert" data-typ="bool"${p.markiert ? " checked" : ""}${frei ? "" : " disabled"}> Zeile farbig markieren (nur für dich, nicht im Ausdruck)</label>
|
||||
<p class="hinweis-k">Alternativ- und Eventualpositionen stehen kursiv mit der Summe in Klammern und zählen nicht zur Angebotssumme. Bilder in Positionen kommen mit dem PDF-Ausdruck.</p>
|
||||
${frei ? `<div class="knopfreihe"><button class="neben klein" data-a="position-kopie" data-id="${p.id}">Kopieren</button><button class="neben klein gefahr" data-a="position-weg" data-id="${p.id}">Position löschen</button></div>` : ""}</div>`;
|
||||
}
|
||||
if (p.mit_kalkulation) {
|
||||
teile.push(abschnitt(z, p.id, "kalk", "Kalkulation (Kosten)", `Kosten <b>${euro(r.kosten_gesamt)}</b>${r.stunden ? ` · <b>${stdText(r.stunden)}</b>` : ""}`, kostenTabelle(d, p, frei)));
|
||||
const ueber = r.kosten_je_einheit > 0 ? Math.round(((r.ep - r.kosten_je_einheit) / r.kosten_je_einheit) * 1000) / 10 : null;
|
||||
teile.push(abschnitt(z, p.id, "verkauf", "Verkauf und Zuschläge", `EP <b>${euro(r.ep)}</b>${ueber !== null ? ` · Überschuss ${prozentText(ueber)}` : ""}`, verkaufTabelle(d, p, frei)));
|
||||
}
|
||||
if (!teile.length) return "";
|
||||
return `<div class="m-offen">${teile.join("")}
|
||||
<div class="m-fertig"><span>Alles wird sofort gespeichert.${p.art && p.art !== "normal" ? ` Positionsart: ${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}.` : ""}</span>
|
||||
<span><button class="neben" data-a="als-vorlage" data-id="${p.id}">Als Leistung speichern</button> <button class="haupt" data-a="fertig">Fertig</button></span></div></div>`;
|
||||
return `<div class="am-ed">
|
||||
<div class="am-etabs" role="tablist" aria-label="Position bearbeiten">${knopf("langtext", "Langtext", p.langtext ? "✓" : "")}
|
||||
${knopf("aufmass", "Aufmaß", p.mit_aufmass ? `${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}` : "")}${p.mit_aufmass ? "" : aus}
|
||||
${knopf("kalk", "Kalkulation", p.mit_kalkulation ? euroGenau(r.kosten_gesamt) : "")}${p.mit_kalkulation ? "" : aus}
|
||||
${knopf("preis", "Zuschläge & Preis")}${knopf("mehr", "Mehr")}</div>
|
||||
<div class="am-epanel" role="tabpanel">${panel}</div>
|
||||
<div class="am-erg">${ergebnisZeile(p, r)}</div>
|
||||
<div class="am-efuss"><span class="hinweis-k">Alles wird sofort gespeichert.</span>
|
||||
${frei ? `<button class="neben" data-a="als-vorlage" data-id="${p.id}">Als Leistung speichern</button><button class="neben" data-a="abbrechen" title="Änderungen an dieser Position seit dem Öffnen verwerfen">Abbrechen</button>` : ""}
|
||||
<button class="haupt" data-a="fertig">Fertig</button></div></div>`;
|
||||
}
|
||||
|
||||
const menue = (eintraege: [string, string, string, boolean?][]) => `<details class="am-menue"><summary class="punkte" aria-label="Weitere Aktionen" title="Weitere Aktionen">⋮</summary>
|
||||
<div class="am-menue-liste">${eintraege.map(([a, idw, text, aus]) => `<button data-a="${a}" data-id="${idw}"${aus ? " disabled" : ""}${a.endsWith("weg") ? ' class="gefahr"' : ""}>${text}</button>`).join("")}</div></details>`;
|
||||
|
||||
/** Kleine Marker hinter dem Kurztext statt Schaltern unter jeder Zeile */
|
||||
function marker(p: Zeile, r: Zeile): string {
|
||||
const m: string[] = [];
|
||||
if (p.art === "alternativ") m.push('<span class="mk art">Alternativ</span>');
|
||||
else if (p.art === "eventual" || p.art === "eventual_summe") m.push(`<span class="mk art">${p.art === "eventual" ? "Eventual" : "Eventual, einkalk."}</span>`);
|
||||
if (p.mit_aufmass) m.push(`<span class="mk${r.aufmass_fehler ? " fehler" : ""}">Aufmaß</span>`);
|
||||
if (p.mit_kalkulation) m.push(`<span class="mk">${p.ep_fest != null ? "Kalk. angepasst" : "Kalk."}</span>`);
|
||||
if (p.langtext) m.push('<span class="mk">Langtext</span>');
|
||||
return m.join("");
|
||||
}
|
||||
|
||||
function zeilenHtml(d: Zeile, z: Zustand, oz: Record<string, string>, p: Zeile, liste: Zeile[], j: number, frei: boolean): string {
|
||||
const feld = feldBau(frei), auswahl = auswahlBau(frei);
|
||||
const feld = feldBau(frei);
|
||||
const r = d.ergebnis.positionen[p.id];
|
||||
const aktiv = z.aktiv === p.id;
|
||||
const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler");
|
||||
const knoepfe = frei ? menue([["position-hoch", p.id, "Nach oben", j === 0], ["position-runter", p.id, "Nach unten", j === liste.length - 1], ["position-kopie", p.id, "Kopieren"],
|
||||
...(p.textzeile ? [] : [["als-vorlage", p.id, "Als Leistung speichern"] as [string, string, string]]), ["position-weg", p.id, "Löschen"]]) : "";
|
||||
const klassen = `${aktiv ? " aktiv" : ""}${!aktiv && z.ziel === p.id ? " ziel" : ""}`;
|
||||
if (p.textzeile) {
|
||||
return `<div class="am-zeile am-textzeile${aktiv ? " aktiv" : ""}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}"><div class="pos"></div>
|
||||
<div class="am-text-voll"><textarea data-k="angebot-positionen:${p.id}:kurztext" data-leer="pflicht" rows="2" aria-label="Text"${frei ? "" : " disabled"}>${esc(p.kurztext)}</textarea></div><div class="punkte-zelle">${knoepfe}</div></div>`;
|
||||
return `<div class="am-zeile am-textzeile${klassen}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}"><div class="pos"></div>
|
||||
<div class="am-text-voll">${aktiv ? `<textarea data-k="angebot-positionen:${p.id}:kurztext" data-leer="pflicht" rows="${Math.max(2, String(p.kurztext).split("\n").length + 1)}" aria-label="Text"${frei ? "" : " disabled"}>${esc(p.kurztext)}</textarea>`
|
||||
: `<div class="am-lese" data-fokus="kurztext">${esc(p.kurztext)}</div>`}</div><div class="punkte-zelle">${knoepfe}</div></div>`;
|
||||
}
|
||||
const blatt = p.mit_aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(d.saetze)) : null;
|
||||
const ersetzt = blatt ? textMitWerten(p.kurztext, blatt) : p.kurztext;
|
||||
const unter = [
|
||||
ersetzt !== p.kurztext ? `= ${esc(ersetzt)}` : "",
|
||||
p.art === "alternativ" ? `Alternativ${p.grundposition_id && oz[p.grundposition_id] ? ` zu ${esc(oz[p.grundposition_id])}` : ""}, zählt nicht zur Summe` : "",
|
||||
p.art === "eventual" ? "Eventualposition, zählt nicht zur Summe" : p.art === "eventual_summe" ? "Eventualposition, einkalkuliert" : "",
|
||||
].filter(Boolean);
|
||||
const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ" && !x.textzeile);
|
||||
const chips = aktiv ? `<div class="m-chips">${chip("Langtext", p.langtext ? !z.langtextAus.has(p.id) : z.langtextAn.has(p.id), "langtext", p.id, frei)}${chip("Aufmaß", !!p.mit_aufmass, "aufmass", p.id, frei)}
|
||||
${chip("Kalkulation", !!p.mit_kalkulation, "kalkulation", p.id, frei)}${chip("Markieren", !!p.markiert, "markiert", p.id, frei)}
|
||||
<span class="am-art">${auswahl(`angebot-positionen:${p.id}:art`, POSITIONSARTEN.map((x) => [x, POSITIONSART_NAME[x]]), p.art ?? "normal", "Positionsart")}</span>
|
||||
${p.art === "alternativ" ? `<span class="am-art">${auswahl(`angebot-positionen:${p.id}:grundposition_id`, [["", "Alternativ zu …"], ...grund.map((x: Zeile): [string, string] => [x.id, `${oz[x.id]} ${x.kurztext}`])], p.grundposition_id ?? "", "Grundposition")}</span>` : ""}</div>` : "";
|
||||
const zaehlt = r.zaehlt;
|
||||
const gb = zaehlt ? euro(r.gb) : `(${euro(r.gb)})`;
|
||||
const ep = formatEuro(r.ep, false);
|
||||
const kopf = `<div class="am-zeile pos-zeile${klassen}${zaehlt ? "" : " zaehlt-nicht"}${p.markiert ? " markiert" : ""}${fehler ? " mit-fehler" : ""}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}">
|
||||
<div class="pos">${esc(oz[p.id])}</div>`;
|
||||
if (!aktiv) {
|
||||
const unter = p.art === "alternativ" && p.grundposition_id && oz[p.grundposition_id] ? `Alternativ zu ${esc(oz[p.grundposition_id])}` : "";
|
||||
return `${kopf}<div class="z" data-fokus="menge">${zahlDeutsch(r.menge, p.einheit)}</div><div data-fokus="einheit">${esc(p.einheit)}</div>
|
||||
<div class="am-text" data-fokus="kurztext">${esc(ersetzt)}${marker(p, r)}${unter ? `<div class="m-unter">${unter}</div>` : ""}</div>
|
||||
<div class="z">${ep}</div><div class="z gb">${gb}</div><div class="punkte-zelle">${knoepfe}</div></div>`;
|
||||
}
|
||||
const menge = p.mit_aufmass
|
||||
? `<input class="zahl aus" value="${esc(zahlDeutsch(r.menge, p.einheit))}" readonly tabindex="-1" aria-label="Menge aus dem Aufmaß"><span class="marke-q${r.aufmass_fehler ? " fehler" : ""}">Aufmaß</span>`
|
||||
? `<input class="zahl aus" value="${esc(zahlDeutsch(r.menge, p.einheit))}" readonly tabindex="-1" aria-label="Menge aus dem Aufmaß" title="kommt aus dem Aufmaß">`
|
||||
: feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" });
|
||||
const ep = p.mit_kalkulation
|
||||
? `<input class="zahl aus" value="${esc(formatEuro(r.ep, false))}" readonly tabindex="-1" aria-label="Einheitspreis aus der Kalkulation"><span class="marke-q kalk">${p.ep_fest != null ? "angepasst" : "Kalkulation"}</span>`
|
||||
: `${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl", leer: "null", titel: "Einheitspreis", platz: "0,00", spalte: "ep" })}<span class="m-unter am-rechts">ohne Kalk.</span>`;
|
||||
return `<div class="am-zeile${aktiv ? " aktiv" : ""}${r.zaehlt ? "" : " zaehlt-nicht"}${p.markiert ? " markiert" : ""}${fehler ? " mit-fehler" : ""}" data-zeile="${p.id}" data-a="aktiv" data-id="${p.id}">
|
||||
<div class="pos">${esc(oz[p.id])}</div>
|
||||
<div class="am-menge">${menge}</div>
|
||||
const epFeld = p.mit_kalkulation ? `<div class="z am-ep-t" title="aus der Kalkulation">${ep}</div>`
|
||||
: `<div>${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl", leer: "null", titel: "Einheitspreis", platz: "0,00", spalte: "ep" })}</div>`;
|
||||
return `${kopf}<div>${menge}</div>
|
||||
<div>${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", titel: "Einheit", liste: "einheiten", spalte: "einheit" })}</div>
|
||||
<div class="am-text">${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${p.langtext && !aktiv ? '<span class="m-sym" title="mit Langtext">¶ Langtext</span>' : ""}
|
||||
${unter.length ? `<div class="m-unter">${unter.join(" · ")}</div>` : ""}${chips}</div>
|
||||
<div class="am-ep">${ep}</div>
|
||||
<div class="z gb">${r.zaehlt ? euro(r.gb) : `<span class="hinweis">(${euro(r.gb)})</span>`}</div>
|
||||
<div class="punkte-zelle">${knoepfe}</div></div>
|
||||
${aktiv ? offenePosition(d, z, p, frei) : ""}`;
|
||||
<div class="am-text">${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${ersetzt !== p.kurztext ? `<div class="m-unter">= ${esc(ersetzt)}</div>` : ""}</div>
|
||||
${epFeld}<div class="z gb">${gb}</div><div class="punkte-zelle">${knoepfe}</div></div>
|
||||
${offenePosition(d, oz, p, frei)}`;
|
||||
}
|
||||
|
||||
/** Musterpositionen oder Mengenvorlagen für die Seitenleiste */
|
||||
/** Leistungen, Mengenvorlagen oder Material für den Reiter Leistungen der Seitenleiste */
|
||||
function katalogListe(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: boolean, leistungen: Zeile[] = []): string {
|
||||
const frei = d.angebot.status === "entwurf";
|
||||
const aktivePos = z.aktiv && d.positionen.some((p: Zeile) => p.id === z.aktiv && !p.textzeile) ? z.aktiv : null;
|
||||
if (z.reiter === "leistungen" && !gross) return leistungenListe(z, leistungen, frei);
|
||||
if (z.reiter === "material" && !gross) return materialListe(z, !!aktivePos && frei);
|
||||
return vorlagenListeHtml(vorlagen, { art: z.reiter === "vorlagen" || gross ? "mengen" : "muster", suche: z.suche, ziel: z.reiter === "vorlagen" || gross ? aktivePos : null, frei });
|
||||
if (gross || z.katalog === "mengen") return vorlagenListeHtml(vorlagen, { art: "mengen", suche: z.suche, ziel: aktivePos, frei });
|
||||
if (z.katalog === "material") return materialListe(z, !!aktivePos && frei);
|
||||
return leistungenListe(z, leistungen, frei);
|
||||
}
|
||||
|
||||
/** Reiter Leistungen: die Leistungen der Stammdaten, nach Ordner gruppiert */
|
||||
@@ -750,8 +877,8 @@ function kiHtml(z: Zustand, leistungen: Zeile[]): string {
|
||||
const k = z.ki;
|
||||
const name = (id: string) => leistungen.find((l) => l.id === id);
|
||||
const an = k.vorschlaege.filter((v) => v.an).length;
|
||||
return `<details class="am-ki"${k.text || k.vorschlaege.length ? " open" : ""}><summary><b>KI-Vorschlag</b> <span class="hinweis-k">nur aus deinen Leistungen</span></summary>
|
||||
<textarea data-ki-text rows="3" placeholder="Was soll gemacht werden? z. B. Satteldach 10 × 12 m, 40° Neigung, Sparren neu, Aufdachdämmung, zwei Gauben" aria-label="Beschreibung der Arbeiten">${esc(k.text)}</textarea>
|
||||
return `<p class="hinweis-k">Beschreibe die Arbeiten. Claude schlägt passende Leistungen vor, nur aus deinen Leistungen in den Stammdaten.</p>
|
||||
<textarea data-ki-text rows="4" placeholder="z. B. Satteldach 10 × 12 m, 40° Neigung, Sparren neu, Aufdachdämmung, zwei Gauben" aria-label="Beschreibung der Arbeiten">${esc(k.text)}</textarea>
|
||||
<div class="am-ki-knoepfe"><button class="neben klein" data-a="ki"${k.laeuft ? " disabled" : ""}>${k.laeuft ? "Claude denkt nach …" : k.vorschlaege.length ? "Neu vorschlagen" : "Vorschlagen"}</button>
|
||||
${k.vorschlaege.length ? `<button class="verweis" data-a="ki-weg">verwerfen</button>` : ""}</div>
|
||||
${k.fehler ? `<p class="fehler">${esc(k.fehler)}</p>` : ""}
|
||||
@@ -761,93 +888,139 @@ function kiHtml(z: Zustand, leistungen: Zeile[]): string {
|
||||
<span class="mit-einheit"><input class="zahl" data-ki-menge="${i}" value="${v.menge == null ? "" : zahlText(v.menge)}" placeholder="Menge" inputmode="decimal" aria-label="Menge"> ${esc(l?.einheit ?? "")}</span></li>`;
|
||||
}).join("")}</ul>
|
||||
<button class="haupt klein" data-a="ki-los"${an ? "" : " disabled"}>${an} übernehmen</button>
|
||||
<p class="hinweis-k">Kommt unter die markierte Zeile, sonst ans Ende. Ohne Menge rechnet das Mengenblatt der Leistung.</p>` : ""}</details>`;
|
||||
<p class="hinweis-k">Kommt unter die markierte Zeile, sonst ans Ende. Ohne Menge rechnet das Mengenblatt der Leistung.</p>` : ""}`;
|
||||
}
|
||||
|
||||
function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], gross: string | null, leistungen: Zeile[] = []): string {
|
||||
const a = d.angebot, e = d.ergebnis, s = d.saetze;
|
||||
const frei = a.status === "entwurf";
|
||||
/** Vorgaben dieses Angebots: Sätze, Zuschläge, W&G, Mengen */
|
||||
function vorgabenHtml(d: Zeile, frei: boolean): string {
|
||||
const a = d.angebot, s = d.saetze;
|
||||
const feld = feldBau(frei);
|
||||
return `<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]}${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
|
||||
<span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")}
|
||||
<span class="t">Wagnis und Gewinn</span>
|
||||
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label>Gewinn<span class="mit-einheit">${feld("angebote:x:gewinn_prozent", zahlText(a.gewinn_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label>Ausfall<span class="mit-einheit">${feld("angebote:x:ausfall_prozent", zahlText(a.ausfall_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label title="Vorschlag für die Kostenart Fahrt">Fahrt je km<span class="mit-einheit">${feld("saetze:km:satz", euroFeld(s.kilometersatz ?? 50), { typ: "euro", klasse: "zahl w-euro" })}</span></label>
|
||||
<span class="t">Mengen</span>
|
||||
<label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div>
|
||||
<p class="hinweis-k">Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.</p>`;
|
||||
}
|
||||
|
||||
const pruefungListe = (d: Zeile) => (d.pruefung.length
|
||||
? `<ul class="pruefung">${d.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${p.position_id ? `<button class="verweis" data-a="pruefung" data-pos="${p.position_id}">${esc(p.text)}</button>` : esc(p.text)}</li>`).join("")}</ul>`
|
||||
: '<p class="hinweis">Keine Platzhalter, alle Positionen mit Menge, Einheit und Preis.</p>');
|
||||
|
||||
/** Rechte Leiste: Bausteine | Leistungen | KI | Vorgaben | Prüfung, immer nur ein Panel */
|
||||
function seitenleiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], leistungen: Zeile[]): string {
|
||||
const a = d.angebot, e = d.ergebnis;
|
||||
const frei = a.status === "entwurf";
|
||||
const auswahl = auswahlBau(frei);
|
||||
const ka = e.kostenarten;
|
||||
const staende = (a.staende ?? []) as Zeile[];
|
||||
const fehlerZahl = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length;
|
||||
const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv && !p.textzeile) : null;
|
||||
const { oz } = ordnung(d);
|
||||
const reiter = gross ? "vorlagen" : z.reiter;
|
||||
const reiterKnopf = (r: Zustand["reiter"], text: string) => `<button class="${reiter === r ? "an" : ""}" data-a="reiter" data-was="${r}" aria-pressed="${reiter === r}">${text}</button>`;
|
||||
const reiter = z.reiter;
|
||||
const knopf = (r: Zustand["reiter"], zeichen: string, text: string) => `<button role="tab" class="${reiter === r ? "an" : ""}" aria-selected="${reiter === r}" data-a="reiter" data-was="${r}"><b aria-hidden="true">${zeichen}</b>${text}</button>`;
|
||||
const baustein = (was: string, text: string) => `<div class="baustein"${frei ? ` draggable="true" data-zieh="${was}"` : ""}><span class="g" aria-hidden="true">⋮⋮</span>${text}${frei ? `<button class="plus" data-a="neu" data-was="${was}" aria-label="${text} einfügen" title="Unter der markierten Zeile einfügen">+</button>` : ""}</div>`;
|
||||
const katalog = reiter === "kalkulation" ? `<table class="kalk-tabelle"><thead><tr><th></th><th class="zahl">Kosten</th><th class="zahl">Zuschlag</th><th class="zahl">Verkauf</th></tr></thead><tbody>
|
||||
const kat = (k: Zustand["katalog"], text: string) => `<button class="chip-knopf${z.katalog === k ? " an" : ""}" data-a="katalog" data-was="${k}" aria-pressed="${z.katalog === k}">${text}</button>`;
|
||||
let panel: string;
|
||||
if (reiter === "bausteine") {
|
||||
panel = frei ? `${baustein("titel", "Titel")}${baustein("position", "Position")}${baustein("text", "Text")}
|
||||
<p class="hinweis-k">Ziehen oder + fügt unter der markierten Zeile ein. Fertige Positionen mit Texten und Kalkulation stehen unter <button class="verweis" data-a="reiter" data-was="leistungen">Leistungen</button>.</p>`
|
||||
: '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>';
|
||||
} else if (reiter === "leistungen") {
|
||||
const suche = z.katalog === "material"
|
||||
? `<input class="suche" type="search" data-mat-suche value="${esc(z.matSuche)}" placeholder="Artikel suchen …" aria-label="Artikel suchen">`
|
||||
: z.katalog === "mengen"
|
||||
? `<input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Mengenvorlage suchen">`
|
||||
: `<div class="am-suchreihe"><input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Leistung suchen …" aria-label="Leistung suchen">
|
||||
<select data-ordner-wahl aria-label="Ordner"><option value="">alle Ordner</option>${[...new Set(leistungen.map((l) => l.gruppe as string))].sort((x, y) => x.localeCompare(y, "de", { numeric: true })).map((o) => `<option value="${esc(o)}"${z.ordner === o ? " selected" : ""}>${esc(o)}</option>`).join("")}</select></div>`;
|
||||
const fuss = z.katalog === "material"
|
||||
? `${aktivePos ? `+ legt den Artikel als Materialzeile in die Kalkulation von ${esc(oz[aktivePos.id])}, mit dem EK von heute.` : "Öffne eine Position, dann kommt der Artikel als Materialzeile in ihre Kalkulation."} <a href="#stammdaten-material">Materialstamm</a>`
|
||||
: z.katalog === "mengen"
|
||||
? `${aktivePos ? `+ fügt die Vorlage ins Aufmaß von ${esc(oz[aktivePos.id])} ein.` : "Öffne eine Position, dann kommt die Vorlage in ihr Aufmaß. Sonst entsteht eine neue Position."} <a href="#stammdaten-mengen">Alle Mengenvorlagen</a>`
|
||||
: `Ziehen oder + fügt unter der markierten Zeile ein, mit Texten, Kalkulation und Aufmaß. <a href="#stammdaten">Alle Leistungen</a>`;
|
||||
panel = `<div class="am-kat-wahl" role="group" aria-label="Was suchen">${kat("leistungen", "Leistungen")}${kat("mengen", "Mengenvorlagen")}${kat("material", "Material")}</div>
|
||||
${suche}<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false, leistungen)}</div><p class="hinweis-k">${fuss}</p>`;
|
||||
} else if (reiter === "ki") {
|
||||
panel = frei ? kiHtml(z, leistungen) : '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>';
|
||||
} else if (reiter === "vorgaben") {
|
||||
panel = `<label class="am-beleg">Beleg ${auswahl("angebote:x:belegart", Object.entries(BELEGART), a.belegart, "Belegart")}</label>
|
||||
${vorgabenHtml(d, frei)}
|
||||
<h3 class="am-h">Kalkulation nach Kostenart</h3>
|
||||
<table class="kalk-tabelle"><thead><tr><th></th><th class="zahl">Kosten</th><th class="zahl">Zuschlag</th><th class="zahl">Verkauf</th></tr></thead><tbody>
|
||||
${([...KOSTENARTEN, "ohne"] as const).filter((x) => x === "lohn" || x === "material" || ka[x].kosten || ka[x].verkauf).map((x) => `<tr><td>${KOSTENART_NAME[x]}</td><td class="zahl">${euro(ka[x].kosten)}</td>
|
||||
<td class="zahl">${euro(ka[x].zuschlag)}<span class="unter">${prozentText(ka[x].prozent)}</span></td><td class="zahl">${euro(ka[x].verkauf)}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td>Summe</td><td class="zahl">${euro(e.kosten)}</td><td class="zahl">${euro(e.netto - e.kosten)}</td><td class="zahl">${euro(e.netto)}</td></tr></tfoot></table>`
|
||||
: reiter === "bausteine" ? `${frei ? `${baustein("titel", "Titel")}${baustein("position", "Position")}${baustein("text", "Text")}<p class="hinweis-k">Ziehen oder + fügt unter der markierten Zeile ein. Fertige Positionen mit Texten und Kalkulation stehen unter „Leistungen“.</p>` : '<p class="hinweis-k">Das Angebot ist nicht mehr im Entwurf.</p>'}`
|
||||
: reiter === "leistungen" ? `<div class="am-suchreihe"><input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Leistung suchen …" aria-label="Leistung suchen">
|
||||
<select data-ordner-wahl aria-label="Ordner"><option value="">alle Ordner</option>${[...new Set(leistungen.map((l) => l.gruppe as string))].sort((x, y) => x.localeCompare(y, "de", { numeric: true })).map((o) => `<option value="${esc(o)}"${z.ordner === o ? " selected" : ""}>${esc(o)}</option>`).join("")}</select></div>
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false, leistungen)}</div>
|
||||
<p class="hinweis-k">Ziehen oder + fügt unter der markierten Zeile ein, mit Texten, Kalkulation und Mengenblatt. <a href="#stammdaten">Alle Leistungen</a></p>
|
||||
${frei ? kiHtml(z, leistungen) : ""}`
|
||||
: reiter === "material" ? `<input class="suche" type="search" data-mat-suche value="${esc(z.matSuche)}" placeholder="Artikel suchen …" aria-label="Artikel suchen">
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, false)}</div>
|
||||
<p class="hinweis-k">${aktivePos ? `+ legt den Artikel als Materialzeile in die Kalkulation von ${esc(oz[aktivePos.id])}, mit dem EK von heute.` : "Markiere eine Position, dann kommt der Artikel als Materialzeile in ihre Kalkulation."} <a href="#stammdaten-material">Materialstamm</a></p>`
|
||||
: `<input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Suchen">
|
||||
<div class="am-katalog-liste">${katalogListe(d, z, vorlagen, !!gross)}</div>
|
||||
<p class="hinweis-k">${aktivePos ? `+ fügt die Vorlage ins Mengenblatt von ${esc(oz[aktivePos.id])} ein.` : "Markiere eine Position, dann kommt die Vorlage in ihr Mengenblatt. Ohne Markierung entsteht eine neue Position."}
|
||||
<a href="#stammdaten-mengen">Alle Mengenvorlagen</a></p>`;
|
||||
return `<aside class="angebot-seite m-seite">
|
||||
<section class="karte summen"><dl>
|
||||
<dt>Netto</dt><dd>${euro(e.netto)}</dd><dt>USt</dt><dd>${euro(e.ust)}</dd><dt class="brutto">Brutto</dt><dd class="brutto">${euro(e.brutto)}</dd>
|
||||
<dt>Stunden</dt><dd>${stdText(e.stunden)}</dd><dt>Kosten</dt><dd>${euro(e.kosten)}</dd>
|
||||
<dt>Möglicher Überschuss</dt><dd>${e.kosten ? `${euro(e.netto - e.kosten)} <small>(${prozentText(e.ueberschuss_prozent)})</small>` : "–"}</dd>
|
||||
${e.stundensatz_verkauf ? `<dt>Verkauf je Lohnstunde</dt><dd>${euro(e.stundensatz_verkauf)}</dd>` : ""}
|
||||
${e.arbeitskosten_brutto ? `<dt title="§ 35a EStG, für Privatkunden">Arbeitskosten brutto</dt><dd>${euro(e.arbeitskosten_brutto)}</dd>` : ""}</dl></section>
|
||||
<section class="karte am-reiter-karte">${gross ? "<h3>Mengenvorlagen</h3>" : `<div class="reiter-k" role="group" aria-label="Seitenleiste">${reiterKnopf("bausteine", "Bausteine")}${reiterKnopf("leistungen", "Leistungen")}${reiterKnopf("vorlagen", "Mengen")}${reiterKnopf("material", "Material")}${reiterKnopf("kalkulation", "Kalk.")}</div>`}${katalog}</section>
|
||||
<section class="karte"><details class="am-vorgaben"${gross ? " open" : ""}><summary><h3>Vorgaben dieses Angebots</h3></summary>
|
||||
<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]}${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
|
||||
<span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")}
|
||||
<span class="t">Wagnis und Gewinn</span>
|
||||
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label>Gewinn<span class="mit-einheit">${feld("angebote:x:gewinn_prozent", zahlText(a.gewinn_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label>Ausfall<span class="mit-einheit">${feld("angebote:x:ausfall_prozent", zahlText(a.ausfall_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label title="Vorschlag für die Kostenart Fahrt">Fahrt je km<span class="mit-einheit">${feld("saetze:km:satz", euroFeld(s.kilometersatz ?? 50), { typ: "euro", klasse: "zahl w-euro" })}</span></label>
|
||||
<span class="t">Mengen</span>
|
||||
<label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div>
|
||||
<p class="hinweis-k">Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.</p></details></section>
|
||||
<section class="karte"><h3>Prüfung ${fehlerZahl ? `<span class="marke schlecht">${fehlerZahl}</span>` : '<span class="marke gut">in Ordnung</span>'}</h3>
|
||||
${d.pruefung.length ? `<ul class="pruefung">${d.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${p.position_id ? `<button class="verweis" data-a="pruefung" data-pos="${p.position_id}">${esc(p.text)}</button>` : esc(p.text)}</li>`).join("")}</ul>` : '<p class="hinweis">Keine Platzhalter, alle Positionen mit Menge, Einheit und Preis.</p>'}</section>
|
||||
${staende.length ? `<section class="karte"><h3>Festgeschriebene Stände</h3><ul class="staende">${staende.map((x) => `<li>${x.anlass === "auftrag" ? "Auftrag" : "Versand"} am ${dat(String(x.am).slice(0, 10))}: ${euro(x.netto)} netto${x.von ? ` <small class="hinweis">${esc(x.von)}</small>` : ""}</li>`).join("")}</ul></section>` : ""}
|
||||
</aside>`;
|
||||
<tfoot><tr><td>Summe</td><td class="zahl">${euro(e.kosten)}</td><td class="zahl">${euro(e.netto - e.kosten)}</td><td class="zahl">${euro(e.netto)}</td></tr></tfoot></table>
|
||||
<dl class="am-kennzahlen">${e.stundensatz_verkauf ? `<dt>Verkauf je Lohnstunde</dt><dd>${euro(e.stundensatz_verkauf)}</dd>` : ""}
|
||||
${e.arbeitskosten_brutto ? `<dt title="§ 35a EStG, für Privatkunden">Arbeitskosten brutto (§ 35a)</dt><dd>${euro(e.arbeitskosten_brutto)}</dd>` : ""}</dl>
|
||||
${staende.length ? `<h3 class="am-h">Festgeschriebene Stände</h3><ul class="staende">${staende.map((x) => `<li>${x.anlass === "auftrag" ? "Auftrag" : "Versand"} am ${dat(String(x.am).slice(0, 10))}: ${euro(x.netto)} netto${x.von ? ` <small class="hinweis">${esc(x.von)}</small>` : ""}</li>`).join("")}</ul>` : ""}`;
|
||||
} else {
|
||||
panel = pruefungListe(d);
|
||||
}
|
||||
const n = d.pruefung.length;
|
||||
return `<aside class="karte am-leiste">
|
||||
<div class="am-ltabs" role="tablist" aria-label="Seitenleiste">${knopf("bausteine", "+", "Bausteine")}${knopf("leistungen", "⌕", "Leistungen")}${knopf("ki", "✦", "KI")}${knopf("vorgaben", "⚙", "Vorgaben")}${knopf("pruefung", "!", `Prüfung${n ? ` (${n})` : ""}`)}</div>
|
||||
<div class="am-lpanel" role="tabpanel">${panel}</div></aside>`;
|
||||
}
|
||||
|
||||
function kopfHtml(d: Zeile, z: Zustand, meldung: string): string {
|
||||
/** Seitenleiste beim großen Mengenblatt: Summen der Position, Mengenvorlagen, Vorgaben */
|
||||
function grossLeiste(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], pid: string): string {
|
||||
const frei = d.angebot.status === "entwurf";
|
||||
return `<section class="karte am-leiste"><h3>Mengenvorlagen</h3><input class="suche" type="search" data-suche value="${esc(z.suche)}" placeholder="Mengenvorlage suchen …" aria-label="Suchen">
|
||||
<div class="am-katalog-liste">${vorlagenListeHtml(vorlagen, { art: "mengen", suche: z.suche, ziel: pid, frei })}</div>
|
||||
<p class="hinweis-k">+ fügt die Vorlage in dieses Mengenblatt ein. <a href="#stammdaten-mengen">Alle Mengenvorlagen</a></p></section>
|
||||
<section class="karte"><details class="am-vorgaben" open><summary><h3>Vorgaben dieses Angebots</h3></summary>${vorgabenHtml(d, frei)}</details></section>`;
|
||||
}
|
||||
|
||||
/** Summen als feste Leiste unten */
|
||||
function summenLeiste(d: Zeile): string {
|
||||
const e = d.ergebnis;
|
||||
const fehler = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length, n = d.pruefung.length;
|
||||
const ueber = e.netto - e.kosten;
|
||||
return `<div class="am-summenleiste" role="status" aria-label="Summen">
|
||||
<div><span>Netto</span><b>${euro(e.netto)}</b></div><div><span>Brutto</span><b>${euro(e.brutto)}</b></div>
|
||||
<div><span>Stunden</span><b>${stdText(e.stunden)}</b></div><div><span>Kosten</span><b>${euro(e.kosten)}</b></div>
|
||||
<div class="${e.kosten ? (ueber >= 0 ? "gut" : "schlecht") : ""}"><span>Überschuss</span><b>${e.kosten ? `${euro(ueber)} · ${prozentText(e.ueberschuss_prozent)}` : "–"}</b></div>
|
||||
<button class="am-pruef${fehler ? " schlecht" : ""}" data-a="reiter" data-was="pruefung"><span>Prüfung</span><b>${n ? `${n} ${n === 1 ? "Hinweis" : "Hinweise"}` : "in Ordnung"}</b></button></div>`;
|
||||
}
|
||||
|
||||
/** Kopfleiste mit Zurück, Nummer, Status und Knöpfen */
|
||||
function titelleiste(d: Zeile, meldung: string): string {
|
||||
const a = d.angebot;
|
||||
const frei = a.status === "entwurf";
|
||||
const feld = feldBau(frei), auswahl = auswahlBau(frei);
|
||||
const knoepfe = {
|
||||
entwurf: `<button class="haupt" data-a="versenden">Als versendet markieren</button><button class="neben" data-a="annehmen">Annehmen</button>`,
|
||||
versendet: `<button class="haupt" data-a="annehmen">Annehmen</button><button class="neben" data-a="ablehnen">Abgelehnt</button><button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
entwurf: `<button class="neben" data-a="annehmen">Annehmen</button><button class="haupt" data-a="versenden">Als versendet markieren</button>`,
|
||||
versendet: `<button class="neben" data-a="ablehnen">Abgelehnt</button><button class="neben" data-a="bearbeiten">Wieder bearbeiten</button><button class="haupt" data-a="annehmen">Annehmen</button>`,
|
||||
abgelehnt: `<button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
}[a.status as string] ?? "";
|
||||
return `<div class="kopf angebot-kopf am-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)}</span></h1>${angebotMarke(a)}
|
||||
<span class="kopf-knoepfe">${knoepfe}${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}</span></div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
|
||||
<section class="karte am-kopfdaten"><div class="am-kopfzeile">
|
||||
<span><b>Empfänger</b>${a.bauherr_name ? `${esc(a.bauherr_name)}${a.bauherr_firma ? `, ${esc(a.bauherr_firma)}` : ""}` : '<span class="fehler">kein Bauherr eingetragen</span>'}</span>
|
||||
<span><b>Projekt</b><a href="#projekt-${a.projekt_id}">${esc(a.projekt_nummer)} ${esc(a.projekt_name)}</a></span>
|
||||
<span class="am-betreff"><b>Betreff</b>${esc(a.betreff || "–")}</span>
|
||||
<span><b>Datum</b>${dat(a.datum)}</span><span><b>Bindefrist</b>${dat(a.bindefrist) || "–"}</span>
|
||||
<button class="neben am-rechts" data-a="kopf" aria-expanded="${z.kopf}">Kopfdaten und Texte ${z.kopf ? "▴" : "▾"}</button></div>
|
||||
${frei ? "" : `<p class="hinweis">Festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}.</p>`}
|
||||
${z.kopf ? `<div class="angebot-angaben am-kopf-felder">
|
||||
<label class="breit">Betreff${feld("angebote:x:betreff", a.betreff ?? "", { platz: `z. B. ${a.projekt_name}` })}</label>
|
||||
<label>Beleg${auswahl("angebote:x:belegart", Object.entries(BELEGART), a.belegart, "Belegart")}</label>
|
||||
<label>Datum<input type="date" data-k="angebote:x:datum" data-leer="pflicht" value="${esc(a.datum)}"${frei ? "" : " disabled"}></label>
|
||||
<label>Bindefrist bis<input type="date" data-k="angebote:x:bindefrist" value="${esc(a.bindefrist ?? "")}"${frei ? "" : " disabled"}></label>
|
||||
<label class="breit">Einleitung<textarea data-k="angebote:x:kopftext" rows="2"${frei ? "" : " disabled"}>${esc(a.kopftext ?? "")}</textarea></label>
|
||||
<label class="breit">Schlusstext<textarea data-k="angebote:x:schlusstext" rows="3"${frei ? "" : " disabled"}>${esc(a.schlusstext ?? "")}</textarea></label>
|
||||
<p class="hinweis breit">{bindefrist} wird im Angebot durch das Datum ersetzt.</p></div>` : ""}</section>`;
|
||||
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)} · ${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}
|
||||
<span class="kopf-knoepfe">${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}</span></div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}`;
|
||||
}
|
||||
|
||||
/** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */
|
||||
function briefkopf(d: Zeile, z: Zustand): string {
|
||||
const a = d.angebot;
|
||||
const frei = a.status === "entwurf";
|
||||
const feld = feldBau(frei);
|
||||
const ort = [a.baustelle_strasse, [a.baustelle_plz, a.baustelle_ort].filter(Boolean).join(" ")].filter(Boolean).join(", ");
|
||||
const empf = a.bauherr_name ? `<b>${esc(a.bauherr_name)}</b>${a.bauherr_firma ? `<br>${esc(a.bauherr_firma)}` : ""}` : '<span class="fehler">kein Bauherr eingetragen</span>';
|
||||
const festText = frei ? "" : `<p class="hinweis am-fest">Festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}.</p>`;
|
||||
// solange eine Position offen ist, nur eine Zeile
|
||||
if (z.aktiv && d.positionen.some((p: Zeile) => p.id === z.aktiv && !p.textzeile)) {
|
||||
return `${festText}<button class="am-kopf-zu" data-a="fertig" title="Position schließen und Kopf zeigen">▸ Kopf: ${esc(a.bauherr_name ?? "ohne Empfänger")} · ${esc(a.betreff || a.projekt_name)} · ${dat(a.datum)}</button>`;
|
||||
}
|
||||
return `${festText}<div class="am-brief">
|
||||
<div class="am-f am-empf"><span class="l">Empfänger</span><div class="am-box">${empf}</div><a class="hinweis-k" href="#projekt-${a.projekt_id}">im Projekt ändern</a></div>
|
||||
<div class="am-f am-daten"><label><span class="l">Datum</span><input type="date" data-k="angebote:x:datum" data-leer="pflicht" value="${esc(a.datum)}"${frei ? "" : " disabled"}></label>
|
||||
<label><span class="l">Gültig bis (Bindefrist)</span><input type="date" data-k="angebote:x:bindefrist" value="${esc(a.bindefrist ?? "")}"${frei ? "" : " disabled"}></label></div>
|
||||
<label class="am-f"><span class="l">Betreff</span>${feld("angebote:x:betreff", a.betreff ?? "", { platz: `z. B. ${a.projekt_name}`, titel: "Betreff" })}</label>
|
||||
<div class="am-f"><span class="l">Leistungsort</span><div class="am-box">${ort ? esc(ort) : '<span class="hinweis">Baustelle im Projekt eintragen</span>'}</div></div></div>
|
||||
${fliesstext("angebote:x:kopftext", a.kopftext, "Einleitung, z. B. Sehr geehrte Damen und Herren, vielen Dank für Ihre Anfrage …", frei, "Einleitung")}`;
|
||||
}
|
||||
|
||||
const datenlisten = (b: Blatt | null) => `<datalist id="einheiten">${EINHEITEN.map((x) => `<option value="${x}">`).join("")}</datalist>${kuerzelListe("am-kuerzel", b ?? leeresBlatt())}`;
|
||||
@@ -858,24 +1031,35 @@ function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string,
|
||||
const feld = feldBau(frei);
|
||||
const { oz, gruppen } = ordnung(d);
|
||||
const aktivePos = z.aktiv ? d.positionen.find((p: Zeile) => p.id === z.aktiv) : null;
|
||||
const lv = gruppen.map((g, gi) => `${g.titel ? `<div class="am-zeile titel${z.aktiv === g.titel.id ? " aktiv" : ""}" data-zeile="${g.titel.id}" data-a="aktiv" data-id="${g.titel.id}">
|
||||
<div class="pos">${esc(oz[g.titel.id])}</div><div class="bez">${feld(`angebot-titel:${g.titel.id}:bezeichnung`, g.titel.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" })}</div>
|
||||
<div class="z gb">${euro(e.titel[g.titel.id])}</div>
|
||||
<div class="punkte-zelle">${frei ? menue([["titel-hoch", g.titel.id, "Nach oben", gi === (gruppen[0]!.titel ? 0 : 1)], ["titel-runter", g.titel.id, "Nach unten", gi === gruppen.length - 1], ["titel-weg", g.titel.id, "Löschen"]]) : ""}</div></div>` : ""}
|
||||
${g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("")}`).join("");
|
||||
return `${datenlisten(aktivePos?.mit_aufmass ? alsBlatt(aktivePos.aufmass) : null)}${kopfHtml(d, z, meldung)}
|
||||
const lv = gruppen.map((g, gi) => {
|
||||
if (!g.titel) return g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("");
|
||||
const t = g.titel, offen = z.aktiv === t.id;
|
||||
return `<div class="am-zeile titel${offen ? " aktiv" : ""}${!offen && z.ziel === t.id ? " ziel" : ""}" data-zeile="${t.id}" data-a="aktiv" data-id="${t.id}">
|
||||
<div class="pos">${esc(oz[t.id])}</div><div class="bez">${offen ? feld(`angebot-titel:${t.id}:bezeichnung`, t.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" }) : `<span class="am-lese">${esc(t.bezeichnung)}</span>`}</div>
|
||||
<div class="z gb">${euro(e.titel[t.id])}</div>
|
||||
<div class="punkte-zelle">${frei ? menue([["titel-hoch", t.id, "Nach oben", gi === (gruppen[0]!.titel ? 0 : 1)], ["titel-runter", t.id, "Nach unten", gi === gruppen.length - 1], ["titel-weg", t.id, "Löschen"]]) : ""}</div></div>
|
||||
${g.positionen.map((p, j) => zeilenHtml(d, z, oz, p, g.positionen, j, frei)).join("")}`;
|
||||
}).join("");
|
||||
const satz = d.ust_satz ?? 19;
|
||||
return `${datenlisten(aktivePos?.mit_aufmass ? alsBlatt(aktivePos.aufmass) : null)}${titelleiste(d, meldung)}
|
||||
<div class="angebot-raster am-raster">
|
||||
<section class="karte am-lv">
|
||||
<div class="am-zeile kopfzeile"><div>Pos.</div><div class="z">Menge</div><div>Einheit</div><div>Beschreibung</div><div class="z">EP</div><div class="z">Gesamt</div><div></div></div>
|
||||
${lv}
|
||||
${d.positionen.length ? "" : '<p class="hinweis leer am-leer">Lege Titel (z. B. „Dachstuhl“) und Positionen an, oder ziehe rechts eine Leistung hinein.</p>'}
|
||||
${frei ? `<div class="m-neu"><button class="verweis" data-a="neu" data-was="position">+ Position</button><button class="verweis" data-a="neu" data-was="titel">+ Titel</button>
|
||||
<button class="verweis" data-a="neu" data-was="text">+ Text</button><button class="verweis" data-a="reiter" data-was="leistungen">+ aus Leistungen</button>
|
||||
${aktivePos || z.aktiv ? '<span class="hinweis-k">kommt unter die markierte Zeile</span>' : ""}</div>` : ""}
|
||||
<div class="m-summe"><span>Netto <b>${euro(e.netto)}</b></span><span>Brutto <b>${euro(e.brutto)}</b></span></div>
|
||||
<section class="karte am-blatt">
|
||||
${briefkopf(d, z)}
|
||||
<div class="am-lv">
|
||||
<div class="am-zeile kopfzeile"><div>Pos.</div><div class="z">Menge</div><div>Einh.</div><div>Beschreibung</div><div class="z">EP</div><div class="z">Gesamt</div><div></div></div>
|
||||
${lv}
|
||||
${d.positionen.length || d.titel.length ? "" : '<p class="hinweis leer am-leer">Lege Titel (z. B. „Dachstuhl“) und Positionen an, oder ziehe rechts eine Leistung hinein.</p>'}
|
||||
${frei ? `<div class="m-neu"><button class="verweis" data-a="neu" data-was="position">+ Position</button><button class="verweis" data-a="neu" data-was="titel">+ Titel</button>
|
||||
<button class="verweis" data-a="neu" data-was="text">+ Text</button><button class="verweis" data-a="katalog" data-was="leistungen">+ aus Stammdaten</button>
|
||||
${z.aktiv ?? z.ziel ? '<span class="hinweis-k">kommt unter die markierte Zeile</span>' : ""}</div>` : ""}
|
||||
</div>
|
||||
<div class="am-summe"><div><span>Nettosumme</span><b>${euro(e.netto)}</b></div><div><span>zzgl. ${String(satz).replace(".", ",")} % USt</span><span>${euro(e.ust)}</span></div>
|
||||
<div class="b"><span>Bruttosumme</span><span>${euro(e.brutto)}</span></div></div>
|
||||
${fliesstext("angebote:x:schlusstext", a.schlusstext, "Schlusstext, z. B. Zahlungsbedingungen und Grüße. {bindefrist} wird durch das Datum ersetzt.", frei, "Schlusstext")}
|
||||
</section>
|
||||
${seitenleiste(d, z, vorlagen, null, leistungen)}
|
||||
</div>`;
|
||||
${seitenleiste(d, z, vorlagen, leistungen)}
|
||||
</div>
|
||||
${summenLeiste(d)}`;
|
||||
}
|
||||
|
||||
/** Großes Mengenblatt (Bilder 3 und 4): alle Eingaben, Formeln und Listen, darunter die Zeitansätze */
|
||||
@@ -902,6 +1086,6 @@ function mengenblattHtml(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldun
|
||||
<div class="am-seite-gross">
|
||||
<section class="karte summen"><dl><dt>Menge der Position</dt><dd><b>${zahlDeutsch(r.menge, p.einheit)} ${esc(p.einheit)}</b></dd>
|
||||
<dt>Einheitspreis</dt><dd>${euro(r.ep)}</dd><dt>Gesamt</dt><dd>${euro(r.gb)}</dd>${r.stunden ? `<dt>Stunden</dt><dd>${stdText(r.stunden)}</dd>` : ""}</dl></section>
|
||||
${seitenleiste(d, z, vorlagen, pid).replace(/^<aside class="angebot-seite m-seite">|<\/aside>$/g, "")}
|
||||
${grossLeiste(d, z, vorlagen, pid)}
|
||||
</div></div>`;
|
||||
}
|
||||
|
||||
107
src/web/app.ts
107
src/web/app.ts
@@ -15,6 +15,7 @@ import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngebot } from "./angebote.js";
|
||||
import { vorlageSeite } from "./mengenblatt.js";
|
||||
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js";
|
||||
|
||||
|
||||
// ---------- Reiter ----------
|
||||
@@ -526,111 +527,6 @@ async function terminplan(): Promise<void> {
|
||||
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] });
|
||||
}
|
||||
|
||||
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
|
||||
// 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" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option><option value="liste">Einzelne Zahlungen</option></select>
|
||||
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
|
||||
${ansicht === "liste" ? "" : '<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>'}`;
|
||||
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
|
||||
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
|
||||
a.value = ansicht;
|
||||
n.value = String(anzahl);
|
||||
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
|
||||
// „Einzelne Zahlungen“: dieselben Wochen, aber jede Zahlung als Zeile zum Sortieren und Filtern
|
||||
const einzeln = ansicht === "liste";
|
||||
if (einzeln) ansicht = "woche";
|
||||
const [perioden, projekte, einst] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
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>`);
|
||||
}
|
||||
|
||||
const heuteD = heute();
|
||||
if (einzeln) {
|
||||
// Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung
|
||||
let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : startsaldo;
|
||||
const posten = perioden.flatMap((p) => p.posten as Zeile[])
|
||||
.sort((x, y) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag))
|
||||
.map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.betrag) }));
|
||||
inhalt.append(liste({
|
||||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||||
zeilenKlasse: (x) => (x.datum < heuteD ? "vorbei" : ""),
|
||||
spalten: [
|
||||
{ id: "datum", titel: "Fällig am", art: "datum", wert: (x) => dat(x.datum), sortWert: (x) => x.datum },
|
||||
{ id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
|
||||
{ id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" },
|
||||
{ id: "projekt", titel: "Projekt", wert: (x) => (x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (x) => `<span class="${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</span>`, sortWert: (x) => x.betrag, klasse: "zahl" },
|
||||
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => x.stand, klasse: "zahl optional" },
|
||||
],
|
||||
zeilen: posten,
|
||||
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
const zeile = (x: Zeile) => {
|
||||
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
|
||||
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
|
||||
<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"]];
|
||||
const LK_FELDER: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
|
||||
@@ -813,6 +709,7 @@ async function uebersicht(): Promise<void> {
|
||||
: '<p class="hinweis">Alles im grünen Bereich.</p>'}</section>
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz)}</section>
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
|
||||
${u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : ""}
|
||||
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div></section>`;
|
||||
inhalt.appendChild(raster);
|
||||
|
||||
|
||||
447
src/web/liquiditaet.ts
Normal file
447
src/web/liquiditaet.ts
Normal file
@@ -0,0 +1,447 @@
|
||||
// Liquidität (Henning, 21.10.2026, Entwurf liquiditaet/entwurf): drei Reiter. „Lage“ zeigt frei verfügbar heute, Ampel
|
||||
// und einen Satz, wann es am knappsten wird, die Kurve je Woche und was reinkommt und rausgeht. „Monatsplan“ ist die
|
||||
// Tabelle je Monat (oder Woche) zum Aufklappen, „Alle Zahlungen“ jede Zahlung als Zeile. Der Zeitraum gilt für alle drei.
|
||||
|
||||
import { type Zeile, MONATSNAMEN, api, dat, esc, euro, heute, inhalt, lies, merke, seite } from "./ui.js";
|
||||
import { kalenderwoche } from "./gantt.js";
|
||||
import { AUGE, AUGE_ZU, ansichtMerken, gespeicherteAnsicht, liste } from "./liste.js";
|
||||
import { lage } from "../domain/lage.js";
|
||||
import type { Periode } from "../domain/liquiditaet.js";
|
||||
import { tageZwischen } from "../domain/datum.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
|
||||
type Reiter = "lage" | "monat" | "alle";
|
||||
type Zeitraum = "4w" | "6w" | "3m";
|
||||
const WOCHEN: Record<Zeitraum, number> = { "4w": 4, "6w": 6, "3m": 13 };
|
||||
const MONATE: Record<Zeitraum, number> = { "4w": 2, "6w": 2, "3m": 3 };
|
||||
const ZEIT_TEXT: Record<Zeitraum, string> = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monaten" };
|
||||
const ZEIT_KNOPF: Record<Zeitraum, string> = { "4w": "4 Wochen", "6w": "6 Wochen", "3m": "3 Monate" };
|
||||
/** so viele Zeilen je Liste, der Rest hinter „weitere anzeigen“ */
|
||||
const SICHTBAR = 4;
|
||||
|
||||
const gespeichert = <T extends string>(schluessel: string, erlaubt: readonly T[], vorgabe: T): T => {
|
||||
const w = lies(schluessel);
|
||||
return erlaubt.includes(w as T) ? (w as T) : vorgabe;
|
||||
};
|
||||
let reiter: Reiter = gespeichert("liqui-reiter", ["lage", "monat", "alle"] as const, "lage");
|
||||
let zeitraum: Zeitraum = gespeichert("liqui-zeitraum", ["4w", "6w", "3m"] as const, "3m");
|
||||
let raster: "monat" | "woche" = "monat";
|
||||
let liquiOffen = new Set<string>();
|
||||
let gewaehlt: string | null = null;
|
||||
const mehr = { ein: false, aus: false };
|
||||
|
||||
export async function liquiditaetSeite(): Promise<void> {
|
||||
const leiste = seite("Liquidität");
|
||||
leiste.classList.add("liqui-leiste");
|
||||
leiste.innerHTML = `<div class="liqui-zeit" role="group" aria-label="Zeitraum"><span class="hinweis">Zeitraum:</span>${(Object.keys(WOCHEN) as Zeitraum[]).map((z) =>
|
||||
`<button class="chip-knopf${z === zeitraum ? " an" : ""}" data-zeitraum="${z}" aria-pressed="${z === zeitraum}">${ZEIT_KNOPF[z]}</button>`).join("")}</div>
|
||||
<div class="liqui-reiter" role="tablist">${([["lage", "Lage"], ["monat", "Monatsplan"], ["alle", "Alle Zahlungen"]] as [Reiter, string][]).map(([r, t]) =>
|
||||
`<button role="tab" class="${r === reiter ? "haupt" : "neben"}" data-reiter="${r}" aria-selected="${r === reiter}">${t}</button>`).join("")}</div>`;
|
||||
leiste.onclick = (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-zeitraum], [data-reiter]");
|
||||
if (!b) return;
|
||||
if (b.dataset.zeitraum) { zeitraum = b.dataset.zeitraum as Zeitraum; merke("liqui-zeitraum", zeitraum); gewaehlt = null; }
|
||||
if (b.dataset.reiter) { reiter = b.dataset.reiter as Reiter; merke("liqui-reiter", reiter); }
|
||||
void liquiditaetSeite();
|
||||
};
|
||||
if (reiter === "lage") await lageZeigen();
|
||||
else if (reiter === "monat") await planZeigen();
|
||||
else await alleZeigen();
|
||||
}
|
||||
|
||||
// ---------- Lage ----------
|
||||
|
||||
const kw = (d: string) => `KW ${kalenderwoche(d)}`;
|
||||
/** auf der Lage in ganzen Euro wie im Entwurf */
|
||||
const glatt = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €");
|
||||
const postenText = (p: Zeile, namen?: Map<string, string>) =>
|
||||
`${esc(p.bezeichnung)}${p.projekt ? ` · ${esc(p.projekt)}${namen?.get(p.projekt) ? ` ${esc(namen.get(p.projekt))}` : ""}` : ""}`;
|
||||
|
||||
/** Karte oben: frei verfügbar, Ampel, Satz und Grund. Auch auf der Startseite (Block 3) */
|
||||
export function lageKopfHtml(d: Zeile, zeitText: string): string {
|
||||
const l = d.lage;
|
||||
const chip = l.ampel === "rot" ? ["rot", "Achtung: Konto im Minus"] : l.ampel === "gelb" ? ["gelb", "Knapp: unter der Mindestgrenze"] : ["gruen", "Alles im grünen Bereich"];
|
||||
const mg = d.mindestgrenze as number;
|
||||
let satz = "Im Zeitraum ist keine Zahlung geplant.";
|
||||
if (l.tief) {
|
||||
const wann = l.tief.von <= heute() ? `diese Woche (${kw(l.tief.von)})` : kw(l.tief.von);
|
||||
const vergleich = mg > 0 || l.abstand < 0
|
||||
? `, also <b>${glatt(Math.abs(l.abstand))}</b> ${l.abstand >= 0 ? "über" : "unter"} deiner Mindestgrenze von ${glatt(mg)}` : "";
|
||||
satz = `In den nächsten <b>${esc(zeitText)}</b> wird es am knappsten ${l.tief.von <= heute() ? "" : "in "}<b>${wann}</b> mit <b class="${l.tief.kontostand < 0 ? "fehler" : ""}">${glatt(l.tief.kontostand)}</b>${vergleich}.`;
|
||||
}
|
||||
const grund = (l.grund as Zeile[]).length
|
||||
? `Grund: ${(l.grund as Zeile[]).map((p) => `${postenText(p)} ${glatt(-p.betrag)}`).join(" und ")}${l.danach ? `, bevor ${postenText(l.danach)} kommt` : ""}.` : "";
|
||||
const stand = d.kontostandDatum ? `Kontostand vom ${dat(d.kontostandDatum)}` : '<a href="#daten">Kontostand noch nicht eingetragen</a>';
|
||||
return `<section class="karte liqui-lage ${chip[0]}">
|
||||
<div class="liqui-frei"><span class="hinweis">Frei verfügbar heute</span><b class="gross${l.frei < 0 ? " fehler" : ""}">${glatt(l.frei)}</b>
|
||||
<span class="hinweis">Kontostand ${glatt(d.kontostand)} − Mindestgrenze ${glatt(mg)} · ${stand}</span></div>
|
||||
<div class="liqui-satz"><span class="ampel-chip ${chip[0]}">${chip[1]}</span><p>${satz}</p>${grund ? `<p class="hinweis">${grund}</p>` : ""}</div></section>`;
|
||||
}
|
||||
|
||||
/** Liniendiagramm je Woche: Kontostand als Fläche, Einnahmen und Ausgaben je Woche, Mindestgrenze, tiefster Punkt */
|
||||
function kurveSvg(d: Zeile, platz: number, was?: Zeile[]): string {
|
||||
const wochen = d.wochen as Zeile[];
|
||||
if (!wochen.length) return '<p class="hinweis">Keine Wochen im Zeitraum.</p>';
|
||||
// so breit wie die Karte, damit die Schrift überall gleich groß bleibt
|
||||
const B = Math.max(340, Math.round(platz)), H = B < 600 ? 220 : 260, L = 56, R = 12, O = 22, U = 30;
|
||||
const stand = [d.kontostand as number, ...wochen.map((w) => w.kontostand as number)];
|
||||
const ein = wochen.map((w) => w.einnahmen as number), aus = wochen.map((w) => -(w.ausgaben as number));
|
||||
const mg = d.mindestgrenze as number;
|
||||
// Was wäre, wenn: Kontostand der Variante als zweite, gestrichelte Linie
|
||||
const wasStand = was ? [d.kontostand as number, ...was.map((w) => w.kontostand as number)] : [];
|
||||
const roh = { min: Math.min(0, ...stand, ...wasStand), max: Math.max(1, mg, ...stand, ...wasStand, ...ein, ...aus) };
|
||||
// runde Schritte: 1, 2 oder 5 mal Zehnerpotenz, etwa vier Linien
|
||||
const grob = (roh.max - roh.min) / 4;
|
||||
const p10 = 10 ** Math.floor(Math.log10(grob));
|
||||
const schritt = [1, 2, 5, 10].map((f) => f * p10).find((s) => s >= grob)!;
|
||||
const ymin = Math.floor(roh.min / schritt) * schritt, ymax = Math.ceil(roh.max / schritt) * schritt;
|
||||
const n = wochen.length;
|
||||
const x = (i: number) => L + (i * (B - L - R)) / n;
|
||||
const y = (v: number) => O + ((ymax - v) * (H - O - U)) / (ymax - ymin || 1);
|
||||
const linien: string[] = [];
|
||||
for (let v = ymin; v <= ymax + 1; v += schritt) {
|
||||
linien.push(`<line class="gitter${v === 0 ? " null" : ""}" x1="${L}" x2="${B - R}" y1="${y(v)}" y2="${y(v)}"/><text class="achse" x="${L - 8}" y="${y(v) + 4}" text-anchor="end">${glatt(v).replace(" €", "")}</text>`);
|
||||
}
|
||||
const pfad = (werte: number[], ab: number) => werte.map((v, i) => `${x(i + ab).toFixed(1)},${y(v).toFixed(1)}`).join(" ");
|
||||
const standPkt = pfad(stand, 0);
|
||||
const basis = y(Math.max(ymin, 0));
|
||||
let ti = 1;
|
||||
stand.forEach((v, i) => { if (i > 0 && v < stand[ti]!) ti = i; });
|
||||
const jede = Math.max(1, Math.ceil(n / Math.max(2, Math.floor(B / 140))));
|
||||
const breite = (B - L - R) / n;
|
||||
const spalten = wochen.map((w, i) => `<rect class="woche-ziel${w.von === gewaehlt ? " an" : ""}" data-woche="${w.von}" tabindex="0" role="button"
|
||||
aria-label="${kw(w.von)}: Kontostand ${glatt(w.kontostand)}, Einnahmen ${glatt(w.einnahmen)}, Ausgaben ${glatt(-w.ausgaben)}"
|
||||
x="${x(i + 1) - breite / 2}" y="${O}" width="${breite}" height="${H - O - U}"><title>${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis).slice(0, 6)}
|
||||
Kontostand am Ende: ${glatt(w.kontostand)}
|
||||
Einnahmen: ${glatt(w.einnahmen)} · Ausgaben: ${glatt(-w.ausgaben)}</title></rect>`).join("");
|
||||
const beschriftung = wochen.map((w, i) => ((i + 1) % jede === 0 || i === n - 1 ? `<text class="achse" x="${x(i + 1)}" y="${H - 8}" text-anchor="${i === n - 1 ? "end" : "middle"}">${kw(w.von)}</text>` : "")).join("");
|
||||
const tx = x(ti), ty = y(stand[ti]!);
|
||||
const rechtsBuendig = tx > B - 170;
|
||||
return `<svg class="liqui-svg" viewBox="0 0 ${B} ${H}" role="img" aria-label="Kontostand je Woche, tiefster Punkt ${glatt(stand[ti]!)} in ${kw(wochen[ti - 1]!.von)}">
|
||||
${linien.join("")}
|
||||
${mg > 0 ? `<rect class="grenz-flaeche" x="${L}" y="${y(mg)}" width="${B - L - R}" height="${Math.max(0, basis - y(mg))}"/><line class="grenze" x1="${L}" x2="${B - R}" y1="${y(mg)}" y2="${y(mg)}"/>
|
||||
<text class="grenz-text" x="${B - R - 4}" y="${y(mg) - 6}" text-anchor="end">Mindestgrenze ${glatt(mg)}</text>` : ""}
|
||||
<polygon class="stand-flaeche" points="${standPkt} ${x(n).toFixed(1)},${basis} ${x(0)},${basis}"/>
|
||||
<polyline class="ein-linie" points="${pfad(ein, 1)}"/>
|
||||
<polyline class="aus-linie" points="${pfad(aus, 1)}"/>
|
||||
<polyline class="stand-linie" points="${standPkt}"/>
|
||||
${was ? `<polyline class="was-linie" points="${pfad(wasStand, 0)}"/>` : ""}
|
||||
${stand.slice(1).map((v, i) => `<circle class="stand-punkt${wochen[i]!.von === gewaehlt ? " an" : ""}" cx="${x(i + 1)}" cy="${y(v)}" r="4"/>`).join("")}
|
||||
<circle class="heute-punkt" cx="${x(0)}" cy="${y(stand[0]!)}" r="5"/><text class="heute-text" x="${x(0) + 8}" y="${y(stand[0]!) - 8}">heute</text>
|
||||
<circle class="tief-punkt" cx="${tx}" cy="${ty}" r="7"/><text class="tief-text" x="${rechtsBuendig ? tx - 10 : tx + 10}" y="${ty + (ty > H - U - 30 ? -12 : 20)}" text-anchor="${rechtsBuendig ? "end" : "start"}">tiefster Punkt ${glatt(stand[ti]!)}</text>
|
||||
${beschriftung}${spalten}</svg>`;
|
||||
}
|
||||
|
||||
/** Zahlungen der angeklickten Woche unter der Kurve */
|
||||
function wocheHtml(w: Zeile | undefined, namen: Map<string, string>): string {
|
||||
if (!w) return "";
|
||||
const posten = [...(w.posten as Zeile[])].sort((a, b) => (a.datum < b.datum ? -1 : a.datum > b.datum ? 1 : a.betrag - b.betrag));
|
||||
return `<div class="liqui-woche"><div class="karte-kopf"><h3>${kw(w.von)} · ${dat(w.von).slice(0, 6)} – ${dat(w.bis)}</h3><button class="neben" data-a="woche-zu">Schließen</button></div>
|
||||
${posten.length ? `<table class="liqui-posten"><tbody>${posten.map((p) => `<tr><td>${dat(p.datum).slice(0, 6)}</td><td class="text">${postenText(p, namen)}</td>
|
||||
<td class="zahl ${p.betrag < 0 ? "aus" : "ein"}">${glatt(p.betrag)}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td></td><td>Saldo der Woche · Kontostand danach ${glatt(w.kontostand)}</td><td class="zahl">${glatt(w.saldo)}</td></tr></tfoot></table>`
|
||||
: '<p class="hinweis">In dieser Woche ist keine Zahlung geplant.</p>'}</div>`;
|
||||
}
|
||||
|
||||
async function lageZeigen(): Promise<void> {
|
||||
const n = WOCHEN[zeitraum];
|
||||
const [d, projekte] = await Promise.all([api<Zeile>(`liquiditaet/lage?wochen=${n}&heute=${heute()}`), api<Zeile[]>("projekte")]);
|
||||
const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string]));
|
||||
const wochen = d.wochen as Zeile[];
|
||||
const bereich = document.createElement("div");
|
||||
bereich.className = "liqui-seite";
|
||||
inhalt.append(bereich);
|
||||
let ansicht = gespeicherteAnsicht(AUS_SCHLUESSEL);
|
||||
const zeichne = () => {
|
||||
const ausSet = new Set(ansicht.aus);
|
||||
const zeilen = { ein: zeilenVon("ein", wochen), aus: zeilenVon("aus", wochen) };
|
||||
const v = variante(d);
|
||||
bereich.innerHTML = (v ? probeBand(d, v, zeilen) : "") + lageKopfHtml(d, ZEIT_TEXT[zeitraum])
|
||||
+ `<section class="karte liqui-kurve"><div class="karte-kopf"><h2>Kontostand, Einnahmen und Ausgaben · nächste ${ZEIT_KNOPF[zeitraum]}</h2>
|
||||
<button class="neben zahnrad" data-a="grenze" aria-label="Mindestgrenze einstellen" title="Mindestgrenze einstellen">⚙ Mindestgrenze</button></div>
|
||||
<div id="l-grenze" hidden></div>
|
||||
<div class="kurve-huelle">${kurveSvg(d, bereich.clientWidth - 34, v?.wochen)}</div>
|
||||
<div class="kurve-legende"><span><i class="k-stand"></i>Kontostand</span><span><i class="k-ein"></i>Einnahmen je Woche</span><span><i class="k-aus"></i>Ausgaben je Woche</span><span><i class="k-grenze"></i>Mindestgrenze</span>${v ? '<span><i class="k-was"></i>Was wäre, wenn</span>' : ""}</div>
|
||||
<p class="hinweis">Woche anklicken: Zahlungen dieser Woche. Mindestgrenze: ${d.mindestgrenzeArt === "fest" ? `fester Betrag ${glatt(d.mindestgrenze)}` : `1 Monat laufende Kosten (${glatt(d.laufendMonat)})`}.</p>
|
||||
${wocheHtml(wochen.find((w) => w.von === gewaehlt), namen)}</section>
|
||||
<div class="liqui-modus" role="group" aria-label="Modus der Listen"><span class="hinweis">Modus:</span>
|
||||
<button class="chip-knopf${modus === "aus" ? " an" : ""}" data-modus="aus" aria-pressed="${modus === "aus"}">👁 Ausblenden</button>
|
||||
<button class="chip-knopf${modus === "was" ? " an was" : ""}" data-modus="was" aria-pressed="${modus === "was"}">🧪 Was wäre, wenn</button>
|
||||
<span class="hinweis-k">${modus === "was" ? "Haken weg = probeweise ohne diesen Posten. Datum anklicken = probeweise verschieben. Nichts wird gespeichert." : "Das Auge blendet eine Zeile nur aus der Liste aus; Kurve und Satz rechnen weiter mit."}</span></div>
|
||||
<div class="liqui-zwei">${listeHtml("ein", zeilen.ein, namen, ausSet, d)}${listeHtml("aus", zeilen.aus, namen, ausSet, d)}</div>`;
|
||||
};
|
||||
zeichne();
|
||||
bereich.onclick = (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const w = t.closest<SVGElement>("[data-woche]");
|
||||
if (w) { gewaehlt = gewaehlt === w.dataset.woche ? null : w.dataset.woche!; return zeichne(); }
|
||||
const m = t.closest<HTMLElement>("[data-mehr]");
|
||||
if (m) { const k = m.dataset.mehr as "ein" | "aus"; mehr[k] = !mehr[k]; return zeichne(); }
|
||||
const knopf = t.closest<HTMLElement>("[data-modus], [data-ausblenden], [data-zeige-aus], [data-alle-ein], [data-a=probe-weg], [data-verschieben]");
|
||||
if (knopf?.dataset.modus) { modus = knopf.dataset.modus as "aus" | "was"; return zeichne(); }
|
||||
if (knopf?.dataset.ausblenden) {
|
||||
const k = knopf.dataset.ausblenden;
|
||||
ansicht = { ...ansicht, aus: ansicht.aus.includes(k) ? ansicht.aus.filter((x) => x !== k) : [...ansicht.aus, k] };
|
||||
ansichtMerken(AUS_SCHLUESSEL, ansicht);
|
||||
return zeichne();
|
||||
}
|
||||
if (knopf?.dataset.zeigeAus) { const k = knopf.dataset.zeigeAus as "ein" | "aus"; zeigeAus[k] = !zeigeAus[k]; return zeichne(); }
|
||||
if (knopf?.dataset.alleEin) {
|
||||
const art = knopf.dataset.alleEin as "ein" | "aus";
|
||||
const keys = new Set(zeilenVon(art, wochen).map((z) => z.key));
|
||||
ansicht = { ...ansicht, aus: ansicht.aus.filter((x) => !keys.has(x)) };
|
||||
ansichtMerken(AUS_SCHLUESSEL, ansicht);
|
||||
zeigeAus[art] = false;
|
||||
return zeichne();
|
||||
}
|
||||
if (knopf?.dataset.a === "probe-weg") { probe.clear(); return zeichne(); }
|
||||
if (knopf?.dataset.verschieben) {
|
||||
// Datum probeweise verschieben: kleines Datumsfeld an Ort und Stelle
|
||||
const k = knopf.dataset.verschieben;
|
||||
const alt = knopf.dataset.datum!;
|
||||
const feld = document.createElement("input");
|
||||
feld.type = "date";
|
||||
feld.className = "liqui-datum";
|
||||
feld.value = probe.get(k)?.datum ?? alt;
|
||||
feld.setAttribute("aria-label", "Probeweise verschieben auf");
|
||||
knopf.replaceWith(feld);
|
||||
feld.focus();
|
||||
try { feld.showPicker?.(); } catch { /* nicht überall erlaubt */ }
|
||||
const fertig = () => {
|
||||
const p = { ...(probe.get(k) ?? {}) };
|
||||
if (feld.value && feld.value !== alt) p.datum = feld.value; else delete p.datum;
|
||||
if (p.weg || p.datum) probe.set(k, p); else probe.delete(k);
|
||||
zeichne();
|
||||
};
|
||||
feld.addEventListener("change", fertig);
|
||||
feld.addEventListener("blur", fertig);
|
||||
return;
|
||||
}
|
||||
if (t.closest("[data-a=woche-zu]")) { gewaehlt = null; return zeichne(); }
|
||||
if (t.closest("[data-a=grenze]")) grenzeBearbeiten(bereich.querySelector<HTMLElement>("#l-grenze")!, d);
|
||||
};
|
||||
bereich.onchange = (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (el.dataset.probe === undefined) return;
|
||||
const k = el.dataset.probe;
|
||||
const p = { ...(probe.get(k) ?? {}) };
|
||||
if (el.checked) delete p.weg; else p.weg = true;
|
||||
if (p.weg || p.datum) probe.set(k, p); else probe.delete(k);
|
||||
zeichne();
|
||||
};
|
||||
bereich.onkeydown = (ev) => {
|
||||
const w = (ev.target as Element).closest?.<SVGElement>("[data-woche]");
|
||||
if (w && (ev.key === "Enter" || ev.key === " ")) { ev.preventDefault(); gewaehlt = w.dataset.woche!; zeichne(); }
|
||||
};
|
||||
}
|
||||
|
||||
// ---------- Ausblenden und „Was wäre, wenn“ (Henning, 21.10.2026) ----------
|
||||
|
||||
const AUS_SCHLUESSEL = "liquiditaet-lage";
|
||||
/** Modus der Listen und die probeweisen Änderungen; nichts davon wird gespeichert, beim Verlassen der Seite ist es weg */
|
||||
let modus: "aus" | "was" = "aus";
|
||||
const probe = new Map<string, { weg?: boolean; datum?: string }>();
|
||||
const zeigeAus = { ein: false, aus: false };
|
||||
addEventListener("hashchange", () => { if (!location.hash.startsWith("#liquiditaet")) { probe.clear(); modus = "aus"; } });
|
||||
|
||||
interface ListenZeile { key: string; datum: string; ueberfaelligSeit?: string; gestellt?: boolean; bezeichnung: string; projekt?: string; betrag: number; anzahl: number; einzeln?: string[] }
|
||||
|
||||
/** Schlüssel einer Zahlung, bleibt über Neuladen gleich; laufende Kosten eines Monats sind eine Zeile */
|
||||
const postenKey = (p: Zeile): string => (p.gruppe === "Laufende Kosten" && p.betrag < 0 ? `lk|${String(p.datum).slice(0, 7)}`
|
||||
: `${p.gruppe}|${p.projekt ?? ""}|${p.bezeichnung}|${p.ueberfaelligSeit ?? p.datum}`);
|
||||
|
||||
/** Zeilen für „Kommt rein“ oder „Geht raus“: Überfälliges oben, dann nach Datum; laufende Kosten je Monat in einer Zeile */
|
||||
function zeilenVon(art: "ein" | "aus", wochen: Zeile[]): ListenZeile[] {
|
||||
const h = heute();
|
||||
const posten = wochen.flatMap((w) => w.posten as Zeile[]).filter((p) => (art === "ein" ? p.betrag > 0 : p.betrag < 0) && !(p.bezahlt && p.datum < h));
|
||||
const nachKey = new Map<string, ListenZeile>();
|
||||
for (const p of posten) {
|
||||
const key = postenKey(p);
|
||||
const z = nachKey.get(key);
|
||||
if (z) { z.betrag += p.betrag; z.anzahl++; z.einzeln?.push(p.bezeichnung); continue; }
|
||||
const lk = key.startsWith("lk|");
|
||||
nachKey.set(key, { key, datum: p.datum, ueberfaelligSeit: p.ueberfaelligSeit, gestellt: p.gestellt, projekt: p.projekt, betrag: p.betrag, anzahl: 1,
|
||||
bezeichnung: lk ? `Laufende Kosten ${MONATSNAMEN[Number(String(p.datum).slice(5, 7)) - 1]}` : p.bezeichnung, ...(lk ? { einzeln: [p.bezeichnung] } : {}) });
|
||||
}
|
||||
return [...nachKey.values()].sort((a, b) => (a.ueberfaelligSeit ? 0 : 1) - (b.ueberfaelligSeit ? 0 : 1)
|
||||
|| (a.ueberfaelligSeit ?? a.datum).localeCompare(b.ueberfaelligSeit ?? b.datum) || a.betrag - b.betrag);
|
||||
}
|
||||
|
||||
/** Die Wochen noch einmal mit den probeweisen Änderungen gerechnet: weggelassen, verschoben (vor dem Zeitraum = erste Woche, danach = raus) */
|
||||
function variante(d: Zeile): { wochen: Zeile[]; lage: Zeile } | null {
|
||||
if (!probe.size) return null;
|
||||
const wochen = d.wochen as Zeile[];
|
||||
if (!wochen.length) return null;
|
||||
const alle: Zeile[] = [];
|
||||
for (const w of wochen) for (const p of w.posten as Zeile[]) {
|
||||
const x = probe.get(postenKey(p));
|
||||
if (x?.weg) continue;
|
||||
alle.push(x?.datum ? { ...p, datum: x.datum } : p);
|
||||
}
|
||||
let stand = d.kontostand as number;
|
||||
const neu = wochen.map((w, i) => {
|
||||
const posten = alle.filter((p) => p.datum <= w.bis);
|
||||
for (const p of posten) alle.splice(alle.indexOf(p), 1);
|
||||
const einnahmen = posten.filter((p) => p.betrag > 0).reduce((s, p) => s + p.betrag, 0);
|
||||
const ausgaben = posten.filter((p) => p.betrag < 0).reduce((s, p) => s + p.betrag, 0);
|
||||
stand += einnahmen + ausgaben;
|
||||
return { ...w, posten, einnahmen, ausgaben, saldo: einnahmen + ausgaben, kontostand: stand };
|
||||
});
|
||||
return { wochen: neu, lage: lage(neu as Periode[], d.kontostand, d.mindestgrenze) };
|
||||
}
|
||||
|
||||
/** Gelbes Band oben: was probeweise geändert ist und wo der tiefste Punkt dann liegt */
|
||||
function probeBand(d: Zeile, v: { lage: Zeile }, zeilen: { ein: ListenZeile[]; aus: ListenZeile[] }): string {
|
||||
const alle = [...zeilen.ein, ...zeilen.aus];
|
||||
const teile = [...probe.entries()].map(([k, x]) => {
|
||||
const z = alle.find((y) => y.key === k);
|
||||
if (!z) return "";
|
||||
const name = `${esc(z.bezeichnung)} ${glatt(Math.abs(z.betrag))}`;
|
||||
return x.weg ? `${name} rausgenommen` : `${name} auf ${dat(x.datum!).slice(0, 6)} verschoben`;
|
||||
}).filter(Boolean);
|
||||
const t = v.lage.tief, alt = d.lage.tief;
|
||||
const satz = t ? `Tiefster Punkt dann <b>${kw(t.von)} mit ${glatt(t.kontostand)}</b>${alt ? ` statt ${glatt(alt.kontostand)}` : ""}.` : "";
|
||||
return `<div class="liqui-probe" role="status"><span class="symbol" aria-hidden="true">🧪</span>
|
||||
<div><b>Was wäre, wenn</b> ist an: ${teile.join(", ") || "keine Änderung"}.<br>${satz} Nichts davon ist gespeichert.</div>
|
||||
<button class="neben" data-a="probe-weg">Zurücksetzen</button></div>`;
|
||||
}
|
||||
|
||||
/** „Kommt rein“ oder „Geht raus“ mit Auge (Ausblenden) oder Haken und Datum (Was wäre, wenn) */
|
||||
function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map<string, string>, ausSet: Set<string>, d: Zeile): string {
|
||||
const h = heute();
|
||||
const was = modus === "was";
|
||||
const versteckt = alle.filter((z) => ausSet.has(z.key));
|
||||
const posten = alle.filter((z) => !ausSet.has(z.key) || zeigeAus[art]);
|
||||
const ueber = posten.filter((p) => p.ueberfaelligSeit).length;
|
||||
const sichtbar = mehr[art] ? posten.length : Math.max(SICHTBAR, ueber);
|
||||
const summe = (l: ListenZeile[]) => l.reduce((s, p) => s + p.betrag, 0);
|
||||
const wochen = d.wochen as Zeile[];
|
||||
const ende = wochen.at(-1)?.bis ?? h;
|
||||
const probeSumme = alle.reduce((s, z) => { const x = probe.get(z.key); return s + (x?.weg || (x?.datum && x.datum > ende) ? 0 : z.betrag); }, 0);
|
||||
const zeile = (p: ListenZeile) => {
|
||||
const seit = p.ueberfaelligSeit;
|
||||
const tage = seit ? tageZwischen(seit, h) : 0;
|
||||
const tag = seit ? ` <span class="tag-ueber">${p.gestellt ? `${tage} ${tage === 1 ? "Tag" : "Tage"} überfällig` : "Rechnung fehlt"}</span>` : "";
|
||||
const titel = p.einzeln ? ` title="${esc(p.einzeln.join(", "))}"` : "";
|
||||
const x = probe.get(p.key), weg = ausSet.has(p.key);
|
||||
const datumText = seit ? `seit ${dat(seit).slice(0, 6)}` : dat(p.datum).slice(0, 6);
|
||||
const datum = was
|
||||
? `<button class="liqui-dat" data-verschieben="${esc(p.key)}" data-datum="${p.datum}" title="Probeweise verschieben">${datumText}</button>${x?.datum ? ` → <span class="tag-probe">${dat(x.datum).slice(0, 6)}</span>` : ""}`
|
||||
: datumText;
|
||||
const vorne = was
|
||||
? `<input type="checkbox" data-probe="${esc(p.key)}"${x?.weg ? "" : " checked"} aria-label="${esc(p.bezeichnung)} probeweise mitrechnen" title="Haken weg = probeweise ohne diesen Posten">`
|
||||
: `<button class="auge" data-ausblenden="${esc(p.key)}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden (zählt weiter mit)"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button>`;
|
||||
return `<tr class="${seit ? "ueber" : ""}${x?.weg ? " probe-weg" : ""}${x?.datum ? " probe-dat" : ""}${weg ? " ausgeblendet" : ""}"${titel}><td class="vorne">${vorne}</td><td class="datum">${datum}</td>
|
||||
<td class="text">${postenText(p, namen)}${p.anzahl > 1 ? ` <small class="hinweis">(${p.anzahl})</small>` : ""}${tag}</td><td class="zahl ${art}">${glatt(p.betrag)}</td></tr>`;
|
||||
};
|
||||
const rest = posten.slice(sichtbar);
|
||||
const probeText = probe.size && probeSumme !== summe(alle) ? ` <small class="probe-summe">(probeweise ${glatt(probeSumme)})</small>` : "";
|
||||
return `<section class="karte liqui-liste"><h2>${art === "ein" ? "Kommt rein" : "Geht raus"} <span class="hinweis">· nächste ${ZEIT_KNOPF[zeitraum]}</span></h2>
|
||||
${alle.length ? `<table class="liqui-posten"><tbody>${posten.slice(0, sichtbar).map(zeile).join("")}
|
||||
${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `<tr class="mehr"><td></td><td></td><td colspan="2"><button class="verweis" data-mehr="${art}" aria-expanded="${mehr[art]}">${mehr[art] ? "▴ weniger anzeigen" : `▾ ${rest.length} weitere anzeigen (${glatt(summe(rest))})`}</button></td></tr>` : ""}
|
||||
${versteckt.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="2">${versteckt.length} ${versteckt.length === 1 ? "Zeile" : "Zeilen"} ausgeblendet · <button class="verweis" data-zeige-aus="${art}">${zeigeAus[art] ? "wieder verbergen" : "einblenden"}</button>${zeigeAus[art] ? ` · <button class="verweis" data-alle-ein="${art}">alle wieder einblenden</button>` : ""} <span class="hinweis">(zählt weiter mit)</span></td></tr>` : ""}</tbody>
|
||||
<tfoot><tr><td></td><td></td><td>Summe aller ${alle.length}${probeText}</td><td class="zahl ${art}">${glatt(summe(alle))}</td></tr></tfoot></table>`
|
||||
: `<p class="hinweis">${art === "ein" ? "Im Zeitraum kommt nichts rein." : "Im Zeitraum geht nichts raus."}</p>`}</section>`;
|
||||
}
|
||||
|
||||
/** Zahnrad: Mindestgrenze automatisch (1 Monat laufende Kosten) oder fester Betrag */
|
||||
function grenzeBearbeiten(ziel: HTMLElement, d: Zeile): void {
|
||||
if (!ziel.hidden) { ziel.hidden = true; return; }
|
||||
const fest = d.mindestgrenzeArt === "fest";
|
||||
ziel.hidden = false;
|
||||
ziel.innerHTML = `<form class="liqui-grenze">
|
||||
<label class="schalter"><input type="radio" name="art" value="auto"${fest ? "" : " checked"}> Automatisch: 1 Monat laufende Kosten <b>${glatt(d.laufendMonat)}</b>${d.laufendMonat ? "" : ' <span class="hinweis">(noch keine laufenden Kosten erfasst)</span>'}</label>
|
||||
<label class="schalter"><input type="radio" name="art" value="fest"${fest ? " checked" : ""}> Fester Betrag <input name="betrag" inputmode="decimal" value="${d.festerBetrag ? euro(d.festerBetrag).replace(" €", "") : ""}" placeholder="z. B. 6.000" aria-label="Fester Betrag in Euro"> €</label>
|
||||
<p class="hinweis">Später kommen die Töpfe dazu (Stufe 5), dann ist das Ziel 6 Monate laufende Kosten.</p>
|
||||
<p class="fehler" id="l-grenze-fehler"></p>
|
||||
<div class="knoepfe"><button type="button" class="neben" data-a="grenze-zu">Abbrechen</button><button class="haupt">Speichern</button></div></form>`;
|
||||
const f = ziel.querySelector("form")!;
|
||||
f.querySelector<HTMLInputElement>("[name=betrag]")!.onfocus = () => { f.querySelector<HTMLInputElement>("[value=fest]")!.checked = true; };
|
||||
f.querySelector<HTMLButtonElement>("[data-a=grenze-zu]")!.onclick = (ev) => { ev.stopPropagation(); ziel.hidden = true; };
|
||||
f.onsubmit = async (ev) => {
|
||||
ev.preventDefault();
|
||||
const art = (f.querySelector<HTMLInputElement>("[name=art]:checked")?.value ?? "auto") as "auto" | "fest";
|
||||
let betrag = d.festerBetrag as number;
|
||||
try {
|
||||
if (art === "fest") betrag = parseEuro(f.querySelector<HTMLInputElement>("[name=betrag]")!.value);
|
||||
if (betrag < 0) throw new Error("Bitte einen Betrag ab 0 € eingeben.");
|
||||
const e = await api<Zeile>("einstellungen");
|
||||
await api("einstellungen", "PUT", { ...e, mindestgrenzeArt: art, mindestreserve: betrag });
|
||||
void liquiditaetSeite();
|
||||
} catch (err) {
|
||||
f.querySelector("#l-grenze-fehler")!.textContent = (err as Error).message === "Leerer Betrag" ? "Bitte einen Betrag eingeben." : (err as Error).message;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// ---------- Monatsplan und alle Zahlungen ----------
|
||||
|
||||
async function planZeigen(): Promise<void> {
|
||||
const anzahl = raster === "monat" ? MONATE[zeitraum] : WOCHEN[zeitraum];
|
||||
const [perioden, projekte] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=${raster}&anzahl=${anzahl}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"),
|
||||
]);
|
||||
const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string]));
|
||||
const zeitText = (p: Zeile) => (raster === "woche" ? `${kw(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)}`);
|
||||
const h = heute();
|
||||
const kopf = document.createElement("div");
|
||||
kopf.className = "liqui-plan-kopf";
|
||||
const alleOffen = perioden.length > 0 && perioden.every((p) => liquiOffen.has(p.von));
|
||||
kopf.innerHTML = `<div role="group" aria-label="Raster"><button class="${raster === "monat" ? "haupt" : "neben"}" data-raster="monat">Monate</button><button class="${raster === "woche" ? "haupt" : "neben"}" data-raster="woche">Wochen</button></div>
|
||||
<button class="neben" data-a="alle">${alleOffen ? "Alle zuklappen" : "Alle Zahlungen aufklappen"}</button>`;
|
||||
kopf.onclick = (ev) => {
|
||||
const b = ev.target as HTMLElement;
|
||||
if (b.dataset.raster) { raster = b.dataset.raster as "monat" | "woche"; void liquiditaetSeite(); }
|
||||
if (b.dataset.a === "alle") { liquiOffen = alleOffen ? new Set() : new Set(perioden.map((p) => p.von)); void liquiditaetSeite(); }
|
||||
};
|
||||
const zeile = (x: Zeile) => `<tr class="posten${x.datum < h && !x.ueberfaelligSeit ? " vorbei" : ""}"><td>${x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)}</td>
|
||||
<td>${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter">${esc(x.gruppe)}</span></td>
|
||||
<td class="optional">${x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.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>${raster === "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(zeitText(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);
|
||||
void liquiditaetSeite();
|
||||
});
|
||||
inhalt.append(kopf, tab);
|
||||
}
|
||||
|
||||
async function alleZeigen(): Promise<void> {
|
||||
const [perioden, projekte, einst] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=${WOCHEN[zeitraum]}&start=${heute()}&offene=1`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string]));
|
||||
const h = heute();
|
||||
// Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung
|
||||
let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : Number(einst.startsaldo ?? 0);
|
||||
const posten = perioden.flatMap((p) => p.posten as Zeile[])
|
||||
.sort((x, y) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag))
|
||||
.map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.betrag) }));
|
||||
inhalt.append(liste({
|
||||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||||
zeilenKlasse: (x) => (x.ueberfaelligSeit ? "ueber" : x.datum < h ? "vorbei" : ""),
|
||||
spalten: [
|
||||
{ id: "datum", titel: "Fällig am", art: "datum", wert: (x) => (x.ueberfaelligSeit ? `seit ${dat(x.ueberfaelligSeit)}` : dat(x.datum)), sortWert: (x) => x.ueberfaelligSeit ?? x.datum },
|
||||
{ id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}${x.ueberfaelligSeit ? ` <span class="tag-ueber">${x.gestellt ? "überfällig" : "Rechnung fehlt"}</span>` : ""}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
|
||||
{ id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" },
|
||||
{ id: "projekt", titel: "Projekt", wert: (x) => (x.projekt ? `${esc(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (x) => `<span class="${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</span>`, sortWert: (x) => x.betrag, klasse: "zahl" },
|
||||
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => x.stand, klasse: "zahl optional" },
|
||||
],
|
||||
zeilen: posten,
|
||||
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -338,20 +338,91 @@ dl.werte dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums;
|
||||
.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); }
|
||||
/* Liquidität (Henning, 21.10.2026): Reiter Lage / Monatsplan / Alle Zahlungen, Zeitraum 4 Wochen bis 3 Monate */
|
||||
.liqui-leiste .hinweis { margin-left: 0; }
|
||||
.liqui-zeit { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
|
||||
.chip-knopf { padding: 5px 12px; border: 1px solid var(--linie); border-radius: 99px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; cursor: pointer; }
|
||||
.chip-knopf.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
|
||||
.liqui-reiter { display: flex; gap: 6px; margin-left: auto; flex-wrap: wrap; }
|
||||
.liqui-seite { display: grid; gap: 14px; }
|
||||
.liqui-lage { display: grid; grid-template-columns: minmax(200px, auto) 1fr; gap: 10px 28px; align-items: center; border-left: 6px solid var(--gut-text); }
|
||||
.liqui-lage.gelb { border-left-color: var(--eingabe-linie); }
|
||||
.liqui-lage.rot { border-left-color: var(--warn); }
|
||||
.karte .karte.liqui-lage { border-top: 0; border-right: 0; border-bottom: 0; border-radius: 0; padding: 4px 0 4px 14px; margin-bottom: 12px; }
|
||||
.liqui-frei { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
|
||||
.liqui-frei .gross { font-size: 30px; font-weight: 700; font-variant-numeric: tabular-nums; line-height: 1.15; }
|
||||
.liqui-frei .hinweis { font-size: 13px; }
|
||||
.liqui-satz { min-width: 0; }
|
||||
.liqui-satz p { margin: 6px 0 0; font-size: 15px; text-wrap: pretty; }
|
||||
.liqui-satz p.hinweis { font-size: 14px; }
|
||||
.ampel-chip { display: inline-block; padding: 3px 10px; border-radius: 99px; font-size: 12px; font-weight: 600; background: var(--gut-bg); color: var(--gut-text); }
|
||||
.ampel-chip.gelb { background: var(--eingabe-bg); color: var(--eingabe-text); }
|
||||
.ampel-chip.rot { background: var(--warnung-bg); color: var(--warnung-text); }
|
||||
.liqui-kurve h2, .liqui-liste h2 { font-size: 15px; margin: 0; }
|
||||
.liqui-kurve .zahnrad { white-space: nowrap; }
|
||||
.kurve-huelle { overflow-x: auto; }
|
||||
.liqui-svg { display: block; width: 100%; height: auto; overflow: visible; }
|
||||
.liqui-svg .gitter { stroke: var(--linie); stroke-width: 1; vector-effect: non-scaling-stroke; }
|
||||
.liqui-svg .gitter.null { stroke: var(--leise); }
|
||||
.liqui-svg text { font-size: 11px; fill: var(--leise); }
|
||||
.liqui-svg .grenz-flaeche { fill: var(--warnung-bg); opacity: 0.7; }
|
||||
.liqui-svg .grenze { stroke: var(--warn); stroke-width: 1.5; stroke-dasharray: 6 4; vector-effect: non-scaling-stroke; }
|
||||
.liqui-svg .grenz-text { fill: var(--warn); }
|
||||
.liqui-svg .stand-flaeche { fill: var(--akzent); opacity: 0.08; }
|
||||
.liqui-svg .stand-linie { fill: none; stroke: var(--akzent); stroke-width: 3; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
|
||||
.liqui-svg .ein-linie { fill: none; stroke: var(--gut-text); stroke-width: 2; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
|
||||
.liqui-svg .aus-linie { fill: none; stroke: var(--warn); stroke-width: 2; stroke-dasharray: 6 3; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
|
||||
.liqui-svg .stand-punkt { fill: var(--fl); stroke: var(--akzent); stroke-width: 2; vector-effect: non-scaling-stroke; }
|
||||
.liqui-svg .stand-punkt.an { fill: var(--akzent); }
|
||||
.liqui-svg .heute-punkt { fill: var(--akzent); }
|
||||
.liqui-svg .heute-text { fill: var(--akzent); font-weight: 700; }
|
||||
.liqui-svg .tief-punkt { fill: var(--fl); stroke: var(--holz); stroke-width: 3; vector-effect: non-scaling-stroke; }
|
||||
.liqui-svg .tief-text { fill: var(--holz); font-weight: 700; }
|
||||
.liqui-svg .woche-ziel { fill: transparent; cursor: pointer; }
|
||||
.liqui-svg .woche-ziel:hover, .liqui-svg .woche-ziel.an { fill: var(--akzent); fill-opacity: 0.07; }
|
||||
.liqui-svg .woche-ziel:focus-visible { outline: none; fill: var(--akzent); fill-opacity: 0.12; }
|
||||
.kurve-legende { display: flex; flex-wrap: wrap; gap: 6px 16px; font-size: 12px; color: var(--leise); margin-top: 4px; }
|
||||
.kurve-legende i { display: inline-block; width: 18px; height: 0; border-top: 3px solid; vertical-align: middle; margin-right: 5px; }
|
||||
.kurve-legende .k-stand { border-color: var(--akzent); }
|
||||
.kurve-legende .k-ein { border-color: var(--gut-text); }
|
||||
.kurve-legende .k-aus { border-color: var(--warn); border-top-style: dashed; }
|
||||
.kurve-legende .k-grenze { border-color: var(--warn); border-top-width: 2px; border-top-style: dotted; }
|
||||
.liqui-kurve > .hinweis { margin: 4px 0 0; font-size: 12px; }
|
||||
.liqui-woche { margin-top: 10px; padding: 10px 12px; background: var(--bg); border-radius: 8px; }
|
||||
.liqui-woche h3 { font-size: 14px; margin: 0; }
|
||||
.liqui-grenze { display: grid; gap: 8px; padding: 10px 12px; margin-bottom: 8px; background: var(--bg); border-radius: 8px; }
|
||||
.liqui-grenze .schalter { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
|
||||
.liqui-grenze input[name=betrag] { width: 110px; padding: 6px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.liqui-grenze .knoepfe { display: flex; gap: 8px; justify-content: flex-end; }
|
||||
.liqui-grenze p { margin: 0; }
|
||||
.liqui-zwei { display: grid; grid-template-columns: 1fr 1fr; gap: 14px; }
|
||||
.liqui-posten { width: 100%; border-collapse: collapse; margin-top: 6px; table-layout: fixed; }
|
||||
.liqui-posten td { padding: 7px 4px; border-top: 1px solid var(--linie); font-size: 14px; vertical-align: top; }
|
||||
.liqui-posten td.datum, .liqui-posten td:first-child { width: 86px; white-space: nowrap; color: var(--leise); }
|
||||
.liqui-posten td.text { overflow-wrap: break-word; }
|
||||
.liqui-posten td.zahl { width: 112px; text-align: right; white-space: nowrap; font-variant-numeric: tabular-nums; font-weight: 600; }
|
||||
.liqui-posten .ein { color: var(--gut-text); }
|
||||
.liqui-posten .aus { color: var(--warn); }
|
||||
.liqui-posten tr.ueber td { background: var(--warnung-bg); }
|
||||
.liqui-posten tr.ueber td.datum { color: var(--warnung-text); }
|
||||
.liqui-posten tr.mehr td { border-top: 1px dashed var(--linie); }
|
||||
.liqui-posten tr.mehr button { text-decoration: none; font-weight: 600; }
|
||||
.liqui-posten tfoot td { border-top: 2px solid var(--linie); font-weight: 700; }
|
||||
.tag-ueber { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 6px; border-radius: 4px; background: var(--warnung-bg); color: var(--warn); white-space: nowrap; }
|
||||
tr.ueber .tag-ueber { background: var(--fl); }
|
||||
.liqui-plan-kopf { display: flex; gap: 8px; justify-content: space-between; flex-wrap: wrap; margin-bottom: 10px; }
|
||||
.liqui-plan-kopf > div { display: flex; gap: 6px; }
|
||||
@media (max-width: 900px) {
|
||||
.liqui-lage { grid-template-columns: 1fr; }
|
||||
.liqui-zwei { grid-template-columns: 1fr; }
|
||||
.liqui-reiter { margin-left: 0; }
|
||||
}
|
||||
@media (max-width: 500px) {
|
||||
.liqui-posten td.datum, .liqui-posten td:first-child { width: 62px; font-size: 13px; white-space: normal; }
|
||||
.liqui-posten td.zahl { width: 84px; }
|
||||
.liqui-posten td { padding-inline: 2px; }
|
||||
.liqui-frei .gross { font-size: 26px; }
|
||||
}
|
||||
.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); }
|
||||
@@ -1116,3 +1187,151 @@ tr.sd-gewaehlt td { background: var(--akzent-hell); }
|
||||
.am-ki-liste .mit-einheit { flex: none; display: flex; align-items: center; gap: 4px; font-size: 12.5px; color: var(--leise); }
|
||||
.am-ki-liste .mit-einheit input { width: 5em; padding: 4px 6px; }
|
||||
button.haupt.klein { padding: 6px 12px; font-size: 14px; }
|
||||
|
||||
/* Angebot als Dokument (Henning, 21.10.2026): Kopf und Texte wie im Ausdruck, ruhige Zeilen, offene Position mit Reitern,
|
||||
rechts eine Leiste mit Reitern, Summen als feste Leiste unten */
|
||||
.angebot-raster.am-raster:has(> .am-blatt) { grid-template-columns: minmax(0, 1fr) 330px; }
|
||||
body:has(.am-summenleiste) #test-leiste { bottom: calc(80px + env(safe-area-inset-bottom, 0px)); }
|
||||
.am-blatt { padding: 24px 28px; display: flex; flex-direction: column; gap: 10px; min-width: 0; }
|
||||
.am-brief { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(0, 1fr); gap: 12px 22px; }
|
||||
.am-f { display: flex; flex-direction: column; gap: 3px; min-width: 0; font-size: 14px; }
|
||||
.am-f .l { font-size: 12px; color: var(--leise); }
|
||||
.am-box { border: 1px solid var(--linie); border-radius: 7px; padding: 7px 10px; background: var(--titel-bg); min-height: 36px; }
|
||||
.am-empf .hinweis-k { align-self: flex-start; }
|
||||
.am-daten { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
|
||||
.am-daten label { display: flex; flex-direction: column; gap: 3px; min-width: 0; }
|
||||
.am-blatt input, .am-blatt select, .am-blatt textarea { width: 100%; min-width: 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; }
|
||||
textarea.am-fliess { border: 1px dashed transparent !important; background: transparent !important; resize: vertical; line-height: 1.5; font-size: 14.5px !important; padding: 8px 10px; }
|
||||
textarea.am-fliess:hover { border-color: var(--linie) !important; }
|
||||
textarea.am-fliess:focus { border-style: solid !important; border-color: var(--akzent) !important; background: var(--fl) !important; }
|
||||
textarea.am-fliess::placeholder { color: var(--leise); font-style: italic; }
|
||||
.am-kopf-zu { align-self: flex-start; background: none; border: 0; color: var(--leise); font: inherit; font-size: 13px; cursor: pointer; padding: 2px 0; text-align: left; }
|
||||
.am-kopf-zu:hover { color: var(--akzent); }
|
||||
.am-fest { margin: 0; font-size: 13px; }
|
||||
.am-blatt .am-lv { overflow: visible; margin-top: 6px; }
|
||||
.am-blatt .am-zeile { padding: 8px 6px; grid-template-columns: 66px 82px 54px minmax(0, 1fr) 88px 106px 28px; gap: 8px; }
|
||||
.am-blatt .am-zeile.titel { grid-template-columns: 66px minmax(0, 1fr) 106px 28px; }
|
||||
.am-blatt .am-zeile.am-textzeile { grid-template-columns: 66px minmax(0, 1fr) 28px; }
|
||||
main:has(.am-blatt) { max-width: 1560px; }
|
||||
.am-blatt .am-zeile.kopfzeile { font-size: 11.5px; text-transform: uppercase; letter-spacing: .04em; background: var(--titel-bg); border-bottom: 2px solid var(--linie); }
|
||||
.am-zeile.pos-zeile:not(.aktiv), .am-zeile.titel:not(.aktiv), .am-zeile.am-textzeile:not(.aktiv) { cursor: pointer; }
|
||||
.am-zeile.pos-zeile:not(.aktiv) > div, .am-zeile.titel:not(.aktiv) .bez { padding-top: 2px; }
|
||||
.am-zeile.pos-zeile:not(.aktiv) .pos, .am-zeile.titel:not(.aktiv) .pos { padding-top: 3px; }
|
||||
.am-zeile.pos-zeile:not(.aktiv) .gb, .am-zeile.titel:not(.aktiv) .gb { padding-top: 2px; }
|
||||
.am-zeile:not(.aktiv):not(.kopfzeile):hover { background: color-mix(in srgb, var(--akzent-hell) 30%, var(--fl)); }
|
||||
.am-zeile.titel:not(.aktiv):hover { background: color-mix(in srgb, var(--akzent-hell) 30%, var(--titel-bg)); }
|
||||
.am-zeile.zaehlt-nicht:not(.aktiv) > div:not(.punkte-zelle) { font-style: italic; color: var(--leise); }
|
||||
.am-zeile.ziel { box-shadow: inset 3px 0 0 color-mix(in srgb, var(--akzent) 45%, transparent); }
|
||||
.am-zeile.aktiv.pos-zeile { box-shadow: none; outline: 2px solid var(--akzent); outline-offset: -2px; border-radius: 8px 8px 0 0; background: var(--fl); }
|
||||
.am-zeile .am-lese { white-space: pre-wrap; overflow-wrap: anywhere; }
|
||||
.am-textzeile .am-lese { font-style: italic; color: var(--leise); }
|
||||
.am-ep-t { padding-top: 8px; font-variant-numeric: tabular-nums; }
|
||||
.am-zeile .punkte-zelle details.am-menue > summary { opacity: 0; }
|
||||
.am-zeile:hover .punkte-zelle details.am-menue > summary, .am-zeile.aktiv .punkte-zelle details.am-menue > summary, details.am-menue[open] > summary, details.am-menue > summary:focus-visible { opacity: 1; }
|
||||
.mk { display: inline-block; font-size: 11px; border-radius: 4px; padding: 0 5px; margin-left: 6px; vertical-align: 1px; color: var(--akzent); background: var(--akzent-hell); font-style: normal; white-space: nowrap; }
|
||||
.mk.fehler { color: var(--warn); background: var(--warnung-bg); }
|
||||
.mk.art { color: var(--leise); background: var(--titel-bg); border: 1px solid var(--linie); }
|
||||
.am-ed { border: 2px solid var(--akzent); border-top: 0; border-radius: 0 0 10px 10px; margin: 0 0 12px; background: var(--fl); display: flex; flex-direction: column; min-width: 0; }
|
||||
.am-etabs { display: flex; flex-wrap: wrap; align-items: center; gap: 2px; background: var(--titel-bg); border-bottom: 1px solid var(--linie); padding: 0 10px; }
|
||||
.am-etabs button { background: none; border: 0; font: inherit; font-size: 14px; color: var(--leise); padding: 9px 12px; cursor: pointer; white-space: nowrap; }
|
||||
.am-etabs button.an { color: var(--akzent); font-weight: 600; box-shadow: inset 0 -2px 0 var(--akzent); background: var(--fl); }
|
||||
.am-etabs button small { font-size: 11px; background: var(--akzent-hell); color: var(--akzent); border-radius: 8px; padding: 0 6px; margin-left: 3px; font-weight: 600; }
|
||||
.am-etabs small.aus { font-size: 11px; color: var(--leise); margin: 0 6px 0 -8px; }
|
||||
.am-epanel { padding: 12px 14px; display: flex; flex-direction: column; gap: 8px; min-width: 0; }
|
||||
.am-epanel textarea { resize: vertical; line-height: 1.45; }
|
||||
.am-epanel > p { margin: 0; }
|
||||
.am-epanel > button.neben { align-self: flex-start; }
|
||||
.am-erg { margin: 0 14px; background: var(--akzent-hell); color: var(--text); border-radius: 8px; padding: 9px 12px; font-size: 14px; line-height: 1.6; }
|
||||
.am-erg .pfeil { color: var(--akzent); margin: 0 4px; }
|
||||
.am-efuss { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; padding: 10px 14px 12px; }
|
||||
.am-efuss .hinweis-k { margin-right: auto; }
|
||||
table.am-t tr.am-klapp td { background: var(--titel-bg); padding: 5px 8px; }
|
||||
table.am-t tr.am-klapp .verweis { font-size: 13px; text-decoration: none; text-align: left; }
|
||||
table.am-t tr.am-klapp .hinweis-k { margin-left: 8px; }
|
||||
.am-mehr { display: flex; flex-direction: column; gap: 10px; max-width: 560px; }
|
||||
.am-mehr > label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); }
|
||||
.am-mehr > label.am-radio { flex-direction: row; align-items: center; gap: 8px; color: var(--text); font-size: 14px; }
|
||||
.am-mehr > label.am-radio input { width: auto; }
|
||||
.am-mehr p { margin: 0; }
|
||||
button.neben.gefahr { color: var(--warn); }
|
||||
.am-blatt .m-neu { padding: 10px 6px; }
|
||||
.am-summe { margin: 14px 0 4px auto; width: min(340px, 100%); display: flex; flex-direction: column; gap: 4px; font-size: 14.5px; font-variant-numeric: tabular-nums; }
|
||||
.am-summe > div { display: flex; justify-content: space-between; gap: 12px; }
|
||||
.am-summe .b { font-weight: 700; border-top: 1px solid var(--linie); padding-top: 6px; }
|
||||
.am-leiste { position: sticky; top: 12px; padding: 0; display: flex; flex-direction: column; min-width: 0; }
|
||||
.am-ltabs { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); border-bottom: 1px solid var(--linie); }
|
||||
.am-ltabs button { background: none; border: 0; font: inherit; font-size: 11px; color: var(--leise); padding: 9px 2px 8px; cursor: pointer; display: flex; flex-direction: column; align-items: center; gap: 2px; min-width: 0; white-space: nowrap; }
|
||||
.am-ltabs button b { font-size: 16px; font-weight: 400; line-height: 1.1; }
|
||||
.am-ltabs button.an { color: var(--akzent); font-weight: 600; box-shadow: inset 0 -2px 0 var(--akzent); }
|
||||
.am-lpanel { padding: 12px; display: flex; flex-direction: column; gap: 6px; min-width: 0; max-height: calc(100vh - 170px); overflow-y: auto; }
|
||||
.am-lpanel textarea { width: 100%; resize: vertical; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; }
|
||||
.am-lpanel .am-katalog-liste { max-height: none; }
|
||||
.am-kat-wahl { display: flex; gap: 6px; flex-wrap: wrap; }
|
||||
.am-kat-wahl .chip-knopf { font-size: 13px; padding: 4px 10px; }
|
||||
.am-beleg { display: flex; align-items: center; justify-content: space-between; gap: 8px; font-size: 13px; }
|
||||
.am-beleg select { width: auto !important; }
|
||||
dl.am-kennzahlen { display: grid; grid-template-columns: 1fr auto; gap: 4px 10px; margin: 6px 0 0; font-size: 13.5px; }
|
||||
dl.am-kennzahlen dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; }
|
||||
.am-summenleiste { position: sticky; bottom: 0; z-index: 15; margin: 18px -28px -22px; background: var(--leiste); color: #fff; display: flex; flex-wrap: wrap; gap: 8px 32px; align-items: center;
|
||||
padding: 11px 28px calc(11px + env(safe-area-inset-bottom, 0px)); font-size: 14px; }
|
||||
.am-summenleiste > * > span { display: block; color: var(--leiste-text); font-size: 12px; }
|
||||
.am-summenleiste b { font-size: 16.5px; font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
.am-summenleiste .gut b { color: #8fe0b0; }
|
||||
.am-summenleiste .schlecht b { color: #ffb4ab; }
|
||||
.am-summenleiste .am-pruef { margin-left: auto; background: none; border: 0; color: #fff; font: inherit; text-align: right; cursor: pointer; padding: 0; }
|
||||
.am-summenleiste .am-pruef.schlecht b { color: #ffb4ab; }
|
||||
@media (max-width: 1100px) {
|
||||
.am-leiste { position: static; }
|
||||
.am-lpanel { max-height: none; }
|
||||
}
|
||||
@media (max-width: 800px) {
|
||||
.am-blatt { padding: 16px 12px; }
|
||||
.am-brief { grid-template-columns: 1fr; }
|
||||
.am-summenleiste { margin: 14px -16px -16px; padding-inline: 16px; gap: 6px 18px; }
|
||||
.am-summenleiste b { font-size: 14.5px; }
|
||||
.am-blatt .am-zeile.kopfzeile { display: none; }
|
||||
body:has(.am-summenleiste) #test-leiste { bottom: calc(118px + env(safe-area-inset-bottom, 0px)); }
|
||||
.am-blatt .am-zeile.pos-zeile { grid-template-columns: 58px minmax(0, 1fr) minmax(0, .7fr) minmax(0, 1fr) minmax(0, 1.1fr);
|
||||
grid-template-areas: "pos text text text menu" "pos menge einh ep gb"; row-gap: 4px; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(1) { grid-area: pos; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(2) { grid-area: menge; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(3) { grid-area: einh; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(4) { grid-area: text; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(5) { grid-area: ep; display: block; text-align: right; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(6) { grid-area: gb; display: block; }
|
||||
.am-blatt .am-zeile.pos-zeile > :nth-child(7) { grid-area: menu; justify-self: end; }
|
||||
.am-blatt .am-zeile.pos-zeile:not(.aktiv) > :nth-child(2), .am-blatt .am-zeile.pos-zeile:not(.aktiv) > :nth-child(3) { color: var(--leise); font-size: 13px; }
|
||||
.am-blatt .am-zeile.titel { grid-template-columns: 58px minmax(0, 1fr) auto 26px; }
|
||||
.am-blatt .am-zeile.titel .gb { display: block; }
|
||||
.am-blatt .am-zeile.am-textzeile { grid-template-columns: 58px minmax(0, 1fr) 26px; }
|
||||
.am-zeile .punkte-zelle details.am-menue > summary { opacity: 1; }
|
||||
.am-etabs { padding: 0 4px; }
|
||||
.am-etabs button { padding: 8px 8px; font-size: 13px; }
|
||||
.am-epanel { padding: 10px 8px; }
|
||||
.am-erg { margin: 0 8px; }
|
||||
.am-efuss { padding: 10px 8px; }
|
||||
}
|
||||
|
||||
/* Liquidität: Ausblenden und „Was wäre, wenn“ (Henning, 21.10.2026) */
|
||||
:root { --probe-bg: #fff6dc; --probe-linie: #f0d98a; --probe-text: #7a4f00; --probe-kurve: #9a6200; }
|
||||
@media (prefers-color-scheme: dark) { :root:not([data-theme="light"]) { --probe-bg: #3a2f12; --probe-linie: #6e5a1f; --probe-text: #f5d98a; --probe-kurve: #e0b050; } }
|
||||
:root[data-theme="dark"] { --probe-bg: #3a2f12; --probe-linie: #6e5a1f; --probe-text: #f5d98a; --probe-kurve: #e0b050; }
|
||||
.liqui-probe { display: flex; align-items: center; gap: 12px; background: var(--probe-bg); border: 1px solid var(--probe-linie); color: var(--probe-text); border-radius: 10px; padding: 10px 14px; margin-bottom: 14px; font-size: 14px; line-height: 1.5; }
|
||||
.liqui-probe > div { flex: 1; min-width: 0; }
|
||||
.liqui-probe .symbol { font-size: 18px; }
|
||||
.liqui-svg .was-linie { fill: none; stroke: var(--probe-kurve); stroke-width: 2.5; stroke-dasharray: 7 4; vector-effect: non-scaling-stroke; stroke-linejoin: round; }
|
||||
.kurve-legende .k-was { border-color: var(--probe-kurve); border-top-style: dashed; }
|
||||
.liqui-modus { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin: 4px 0 10px; }
|
||||
.liqui-modus .chip-knopf { font-size: 13px; padding: 4px 11px; }
|
||||
.liqui-modus .chip-knopf.an.was { background: var(--probe-bg); border-color: var(--probe-kurve); color: var(--probe-text); }
|
||||
.liqui-posten td.vorne { width: 30px; padding-right: 0; }
|
||||
.liqui-posten td.vorne input { width: 16px; height: 16px; margin: 2px 0 0; }
|
||||
.liqui-posten tr.ausgeblendet td:not(.vorne) { opacity: .5; }
|
||||
.liqui-posten tr.probe-weg td { background: var(--probe-bg); }
|
||||
.liqui-posten tr.probe-weg td.text, .liqui-posten tr.probe-weg td.zahl { text-decoration: line-through; color: var(--leise); }
|
||||
.liqui-posten tr.aus-hinweis td { color: var(--leise); font-size: 13px; }
|
||||
.liqui-posten td.datum { white-space: normal; }
|
||||
.liqui-dat { background: none; border: 0; padding: 0; font: inherit; color: inherit; cursor: pointer; text-decoration: underline dotted; text-underline-offset: 3px; }
|
||||
.tag-probe { display: inline-block; font-size: 11px; font-weight: 600; padding: 1px 5px; border-radius: 4px; background: var(--probe-bg); border: 1px solid var(--probe-linie); color: var(--probe-text); }
|
||||
input.liqui-datum { width: 100%; font: inherit; font-size: 13px; padding: 2px 4px; border: 1px solid var(--akzent); border-radius: 6px; background: var(--fl); color: var(--text); }
|
||||
.probe-summe { font-weight: 400; color: var(--probe-text); }
|
||||
|
||||
@@ -161,6 +161,21 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
|
||||
});
|
||||
|
||||
it("Liquidität Lage: Mindestgrenze automatisch oder fest (Zahnrad)", async () => {
|
||||
const l = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
|
||||
expect(l.wochen).toHaveLength(6);
|
||||
expect(l.mindestgrenzeArt).toBe("auto");
|
||||
expect(l.mindestgrenze).toBe(l.laufendMonat);
|
||||
expect(l.lage.frei).toBe(l.kontostand - l.mindestgrenze);
|
||||
const e = (await app.inject("/api/einstellungen")).json();
|
||||
const r = await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, mindestgrenzeArt: "fest", mindestreserve: 600_000 } });
|
||||
expect(r.statusCode, r.body).toBe(200);
|
||||
const l2 = (await app.inject("/api/liquiditaet/lage?wochen=6&heute=2026-10-21")).json();
|
||||
expect(l2.mindestgrenze).toBe(600_000);
|
||||
expect(l2.lage.frei).toBe(l2.kontostand - 600_000);
|
||||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
|
||||
});
|
||||
|
||||
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
|
||||
const t = (await app.inject("/api/terminplan")).json();
|
||||
expect(t.vorgaenge).toHaveLength(13);
|
||||
@@ -1062,6 +1077,9 @@ describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => {
|
||||
|
||||
const voll = await hole(`angebote/${a.id}/voll`);
|
||||
expect(voll.ergebnis.stunden).toBe(44);
|
||||
// Dokumentansicht: USt-Satz für die Summe und Leistungsort aus dem Projekt
|
||||
expect(voll.ust_satz).toBe(19);
|
||||
expect(voll.angebot).toHaveProperty("baustelle_ort");
|
||||
expect(voll.ergebnis.netto).toBe(voll.ergebnis.titel[t1.id] + voll.ergebnis.titel[t2.id]);
|
||||
expect(voll.pruefung.map((x: { text: string }) => x.text)).toEqual(expect.arrayContaining([
|
||||
expect.stringContaining("kein Bauherr"), expect.stringContaining("„Stk.“ bitte als „St“"),
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { liquiditaet, periodenGrenzen, termineLaufend, projektBewegungen, type ProjektPlan } from "../src/domain/liquiditaet.js";
|
||||
import { faelligkeit, zeitraumVon } from "../src/domain/umsatzsteuer.js";
|
||||
import { lage, laufendJeMonat } from "../src/domain/lage.js";
|
||||
|
||||
describe("Umsatzsteuer-Fälligkeit", () => {
|
||||
it("10. des Folgemonats, Wochenende verschiebt auf Montag", () => {
|
||||
@@ -138,3 +139,39 @@ describe("Projekt nach V70-Regeln", () => {
|
||||
expect(projektBewegungen({ ...plan, zeitraum: undefined })).toEqual({ einnahmen: plan.zahlungen, ausgaben: plan.kosten });
|
||||
});
|
||||
});
|
||||
|
||||
describe("Lage der Liquidität (Henning, 21.10.2026)", () => {
|
||||
const daten = {
|
||||
einnahmen: [
|
||||
{ projekt: "P-26-014", bezeichnung: "1. Rate", netto: 1_000_000, termin: "2026-09-20", zahlungszielTage: 14, gestellt: true },
|
||||
{ projekt: "P-26-014", bezeichnung: "alte Rate", netto: 500_000, termin: "2026-09-01", zahlungszielTage: 14, bezahlt: true },
|
||||
{ projekt: "P-26-014", bezeichnung: "2. Rate", netto: 2_000_000, termin: "2026-11-16", zahlungszielTage: 14 },
|
||||
],
|
||||
ausgaben: [{ projekt: "P-26-014", bezeichnung: "Holz", art: "material" as const, netto: 1_200_000, termin: "2026-10-26", zahlungszielTage: 7 }],
|
||||
laufend: [
|
||||
{ bezeichnung: "Miete", betrag: 300_000, rhythmus: "monatlich" as const, start: "2026-01-01" },
|
||||
{ bezeichnung: "Versicherung", betrag: 120_000, rhythmus: "jaehrlich" as const, start: "2026-03-01" },
|
||||
],
|
||||
};
|
||||
const v = { ansicht: "woche" as const, start: "2026-10-21", anzahl: 13, startsaldo: 2_000_000, offeneAb: "2026-10-21" };
|
||||
|
||||
it("offene Einnahmen mit vergangenem Zahltag sind überfällig und zählen heute; bezahlte nicht", () => {
|
||||
const w = liquiditaet(daten, v);
|
||||
const alle = w.flatMap((p) => p.posten);
|
||||
const rate = alle.find((p) => p.bezeichnung === "1. Rate")!;
|
||||
expect(rate).toMatchObject({ datum: "2026-10-21", ueberfaelligSeit: "2026-10-04", gestellt: true });
|
||||
expect(alle.find((p) => p.bezeichnung === "alte Rate")).toBeUndefined();
|
||||
// ohne offeneAb bleibt es wie bisher
|
||||
expect(liquiditaet(daten, { ...v, offeneAb: undefined }).flatMap((p) => p.posten).find((p) => p.bezeichnung === "1. Rate")).toBeUndefined();
|
||||
});
|
||||
|
||||
it("Mindestgrenze aus den laufenden Kosten, Tiefpunkt mit Grund", () => {
|
||||
expect(laufendJeMonat(daten.laufend, "2026-10-21")).toBe(310_000);
|
||||
const w = liquiditaet(daten, v);
|
||||
const l = lage(w, 2_000_000, 310_000);
|
||||
expect(l.frei).toBe(1_690_000);
|
||||
expect(l.tief!.kontostand).toBe(Math.min(...w.map((p) => p.kontostand)));
|
||||
expect(l.grund[0]?.bezeichnung).toBe("Holz");
|
||||
expect(l.ampel).toBe(l.tief!.kontostand < 0 ? "rot" : l.tief!.kontostand < 310_000 ? "gelb" : "gruen");
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user