Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5c1688aba5 | ||
|
|
337d3bee21 | ||
|
|
7fe2f9094e | ||
|
|
3f64143ee1 |
34
CHANGELOG.md
34
CHANGELOG.md
@@ -2,6 +2,40 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.52.0 (09.11.2026)
|
||||
|
||||
- Angebote: Unter den Summen steht der Zahlungsplan. Vorgeschlagen wird er nach der Angebotssumme aus der Staffel unter Einstellungen › Vorlagen; je Angebot lassen sich Raten umbenennen, Anteile und Fälligkeit ändern, Raten hinzufügen oder entfernen. „Vorschlag wiederherstellen“ geht zurück zur Staffel. Die letzte Rate ist die Schlussrechnung und bekommt den Rest. Nach dem Versand ist der Plan festgeschrieben und steht mit Anteil und Bruttobetrag im Angebot.
|
||||
- Angebot annehmen: Ein eigener Zahlungsplan des Angebots gilt fürs Projekt, solange es noch keine Raten hat; die Raten entstehen mit Terminen wie bisher automatisch. Ohne eigenen Plan gilt die Staffel nach dem Auftragswert.
|
||||
- Eine Kopie eines Angebots übernimmt dessen Zahlungsplan.
|
||||
|
||||
## 0.51.0 (09.11.2026)
|
||||
|
||||
- Zahlungsplan: Die Zahl der Raten richtet sich nach dem Auftragswert (netto). Unter 10.000 € eine Schlussrechnung nach Abnahme (100 %), von 10.000 bis unter 20.000 € zwei Raten (50 % nach Abbund und Richten, 50 % Schlussrechnung nach Abnahme), ab 20.000 € die vier Raten 30/40/20/10 wie bisher.
|
||||
- Einstellungen › Vorlagen: Grenzen, Raten, Anteile und Fälligkeit (bei Auftrag, nach Abbund und Richten, nach den Restarbeiten, nach der Abnahme) je Stufe änderbar, Stufen hinzufügen oder entfernen. Die letzte Rate ist immer die Schlussrechnung und bekommt den Rest.
|
||||
- Automatische Zahlungspläne, an denen noch nichts von Hand geändert ist, passen sich an: Ändert sich der Auftragswert über eine Grenze oder die Staffel, werden die noch geplanten Raten neu angelegt. Gestellte oder von Hand geänderte Pläne bleiben, wie sie sind.
|
||||
|
||||
## 0.50.1 (08.11.2026)
|
||||
|
||||
- Testversion: Findet die Adresssuche keine eigene Adresse, sagt sie jetzt, warum. Neue Adressen aus der Karte (OpenStreetMap) kommen nur vom Server, die Testversion darf keine Verbindung nach außen aufbauen.
|
||||
|
||||
## 0.50.0 (08.11.2026)
|
||||
|
||||
Umsetzung der UX-Prüfung (freigegeben von Henning am 08.11.2026).
|
||||
|
||||
- Übersicht am PC: Zahlenleiste oben mit Morgen, Überfällig, Brennt und Geld bis. Die Warnungen zeigen Vorgänge im Verzug, überfällige Raten und den fehlenden Kontostand; jede Zeile führt zum Ziel. „n Aufgaben überfällig“ steht nicht mehr doppelt unter den Warnungen. Aufgaben gruppiert nach Überfällig, Nächste 7 Tage und Später. In „Wer macht was“ ist der nächste Arbeitstag hervorgehoben, der Freitag als Reserve markiert, und ein Klick auf einen Einsatz öffnet den Vorgang im Terminplan. Die Geld-Karte nennt den Zeitraum und rechnet wie die Liquidität, mit Umsatzsteuer.
|
||||
- Übersicht am Handy: Band mit drei Zahlen (Einsätze am nächsten Arbeitstag, überfällig, Geld bis TT.MM.), darunter die Karte „Brennt“ mit großen Zeilen zum Antippen. Größere Haken (24 px in 44 px Fläche). Der Hinweis „Testversion“ verdeckt die Liste nicht mehr.
|
||||
- Menü am PC: acht Hauptpunkte mit Unterpunkten (Projekte: Angebote, Rechnungen, Stammdaten; Personal: Mitarbeiter, Zeiterfassung; Betrieb: Liquidität, Laufende Kosten, Jahresfinanzplanung, BWA; Einstellungen: Benutzer, Vorlagen, Daten und Sicherung). „Testversion“ steht in der Seitenleiste.
|
||||
- Neue Seite Rechnungen: alle gestellten und bezahlten Raten mit Nummer, Projekt, Datum, Fälligkeit, Betrag und Status, mit Summe.
|
||||
- Einstellungen: eine Seite mit Reitern Benutzer, Vorlagen, Daten und Sicherung, Programmteile, Anbindungen. Eigener Knopf „Datei wählen …“.
|
||||
- Projektfarben: Rot ist keine Projektfarbe mehr (Holzbraun statt Rot), damit Rot nur Warnungen bedeutet.
|
||||
- Projektliste: Schnellwahl Laufend, Anfragen und Angebote, Gewährleistung, Archiv, Alle. Nummer als erste Spalte, Kunde nur einmal, Ort ausgeblendet. Statusfarben: Anfrage grau, Angebot holz-hell, Auftrag blau.
|
||||
- Projektseite am PC: Brotkrumen, Geld-Stand und Abschnitte wie am Handy, Kachel „Fehlt noch“, Verweise „im Terminplan zeigen“ und „in Liquidität zeigen“. Aufgaben zeigen nur offene, „n erledigte anzeigen“ blendet den Rest ein. Rechnungen mit einer Marke. Reiter „Berichte“ heißt „Bautagebuch“.
|
||||
- Liquidität: Lage-Satz mit Zeitraum und Überschuss, „Kontostand eintragen“ als Verweis. Umschalter „Modus“ entfällt, „Zählt“ heißt „In Rechnung“, Spaltenköpfe normal geschrieben, Projektnummern führen zum Projekt.
|
||||
- Projekt am Handy: zwei große Knöpfe „Anrufen“ (Ansprechpartner Baustelle, sonst Kunde) und „Navigation“ zur Baustelle; fehlt Nummer oder Adresse, sind sie ausgegraut mit Hinweis.
|
||||
- Terminplan am Handy: Vorgänge im Verzug markiert („im Verzug: 25 % statt 100 %“), „1 Mann“ statt „1 P.“, am Freitag „Reserve. Nur dieser Termin ist für Freitag fest eingeplant.“, ab Samstag öffnet die nächste KW. Die Auslastung zählt Mo–Do: „Woche voll: 32 von 32 Std. (Mo–Do)“, im Gantt am PC genauso.
|
||||
- Handy allgemein: Tippziele mindestens 44 px (Haken, Chips, Reiter), kein Auge mehr auf den Karten (Wischen blendet weiter aus), genug Abstand unten, damit der schwebende Knopf die letzte Karte nicht verdeckt.
|
||||
- Behoben: Das heutige Datum wird nach Ortszeit bestimmt, nicht nach UTC.
|
||||
|
||||
## 0.49.0 (08.11.2026)
|
||||
|
||||
- Angebote und weitere Dokumente: Der Empfänger steht als vollständige Anschrift. Ist der Kunde eine Firma, Behörde oder WEG, kommt darunter „z. Hd. Herrn/Frau Titel Name“: der Ansprechpartner mit „Haupt“ im Projekt, sonst der Hauptansprechpartner (★) des Kunden. Personen stehen als „Herrn Dipl.-Ing. Jan Petersen“.
|
||||
|
||||
@@ -48,7 +48,7 @@ cd deploy
|
||||
|
||||
1. Server mit Docker und git; ein Reverse Proxy (HAProxy) mit TLS leitet an `APP_ADRESSE:APP_PORT` aus `.env` weiter.
|
||||
2. Repository von git.deichnet.com auf den Server klonen, `deploy/.env.beispiel` nach `deploy/.env` kopieren und ausfüllen.
|
||||
3. `cd deploy && ./update.sh 0.49.0` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`.
|
||||
3. `cd deploy && ./update.sh 0.52.0` baut das Image und startet Programm, Datenbank und Sicherung (`docker compose up -d`). Die Daten liegen in `deploy/data/db` und `deploy/data/backup`. HTTPS macht der vorhandene HAProxy; er setzt `X-Forwarded-Proto: https`.
|
||||
4. Beim ersten Aufruf fragt das Programm nach dem Inhaber und dem Einrichtungscode (aus `.env` oder `docker compose logs app | grep Einrichtungscode`). Alle weiteren Zugänge legt der Inhaber unter „Benutzer“ an.
|
||||
|
||||
Sicherung: jede Nacht und vor jedem Update, 30 Tage aufbewahrt, Kopie per WebDAV in die Nextcloud.
|
||||
|
||||
@@ -1,20 +1,23 @@
|
||||
<title>Betrieb Testversion</title>
|
||||
<link rel="icon" type="image/png" href="/*FAVICON*/">
|
||||
<style>/*STYLES*/
|
||||
#test-leiste { position: fixed; z-index: 50; right: calc(12px + env(safe-area-inset-right, 0px)); bottom: calc(12px + env(safe-area-inset-bottom, 0px));
|
||||
max-width: min(420px, calc(100vw - 24px)); background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 10px;
|
||||
padding: 7px 12px; font-size: 13px; box-shadow: 0 2px 10px rgb(0 0 0 / 0.12); display: flex; gap: 8px; align-items: baseline; }
|
||||
#test-leiste b { color: var(--holz); white-space: nowrap; }
|
||||
#test-zustand.ok { color: var(--leise); }
|
||||
#test-zustand.fehler { color: var(--warn); }
|
||||
/* UX-Prüfung (08.11.2026): in der Seitenleiste statt über dem Inhalt */
|
||||
#test-leiste { display: flex; flex-wrap: wrap; gap: 2px 8px; align-items: baseline; font-size: 12px; color: var(--leiste-text); padding: 6px 8px; margin-top: 6px;
|
||||
border-top: 1px solid rgb(255 255 255 / 0.12); }
|
||||
#test-leiste b { color: #e0b98a; white-space: nowrap; }
|
||||
#test-zustand.ok { color: var(--leiste-text); }
|
||||
@media (max-width: 640px) {
|
||||
#test-leiste { order: 5; margin: 0 0 0 auto; border: 0; padding: 0 2px; flex-direction: column; align-items: flex-end; gap: 0; font-size: 11px; max-width: 45vw; text-align: right; }
|
||||
}
|
||||
#test-zustand.fehler { color: #ffb4a8; }
|
||||
</style>
|
||||
<aside id="seitenleiste">
|
||||
<div id="marke"><img src="/*LOGO*/" alt="Holzbau Schaarschmidt"></div>
|
||||
<nav id="reiter"></nav>
|
||||
<div id="wer"></div>
|
||||
<span id="version"></span>
|
||||
<div id="test-leiste" role="status"><b>Testversion</b><span id="test-zustand">Programm wird geladen …</span></div>
|
||||
</aside>
|
||||
<main id="inhalt"></main>
|
||||
<div id="dialog-huelle" hidden></div>
|
||||
<div id="test-leiste" role="status"><b>Testversion</b><span id="test-zustand">Programm wird geladen …</span></div>
|
||||
<script type="module">/*APP*/</script>
|
||||
|
||||
@@ -32,6 +32,7 @@ import m027 from "../src/server/migrations/027_zaehlt.sql";
|
||||
import m028 from "../src/server/migrations/028_kontakte_abgleich.sql";
|
||||
import m029 from "../src/server/migrations/029_kontakte_neu.sql";
|
||||
import m030 from "../src/server/migrations/030_prioritaet.sql";
|
||||
import m031 from "../src/server/migrations/031_zahlungsplan_angebot.sql";
|
||||
|
||||
const MIGRATIONEN: [string, string][] = [
|
||||
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004],
|
||||
@@ -59,6 +60,7 @@ const MIGRATIONEN: [string, string][] = [
|
||||
["028_kontakte_abgleich.sql", m028],
|
||||
["029_kontakte_neu.sql", m029],
|
||||
["030_prioritaet.sql", m030],
|
||||
["031_zahlungsplan_angebot.sql", m031],
|
||||
];
|
||||
|
||||
export async function starte(db: PGlite, v70?: unknown) {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# Kopieren nach .env und ausfüllen. Die Datei bleibt nur auf dem Server.
|
||||
# Name des Images, das update.sh aus dem Git-Tag baut
|
||||
IMAGE=betrieb
|
||||
APP_VERSION=0.49.0
|
||||
APP_VERSION=0.52.0
|
||||
# Hier lauscht das Programm für den HAProxy (Adresse des Docker-Rechners im VPN)
|
||||
APP_ADRESSE=100.64.0.8
|
||||
APP_PORT=33181
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.49.0",
|
||||
"version": "0.52.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
// Projektfarben: eigene Farbe des Projekts, sonst reihum nach der Reihenfolge im Terminplan.
|
||||
// Terminplan, Handy und Übersicht nehmen dieselbe Farbe (Henning, 23.10.2026).
|
||||
export const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
|
||||
export const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#7a4a24", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
|
||||
|
||||
/** alle = Projekte des Terminplans in ihrer Reihenfolge; gezählt werden nur die nicht abgeschlossenen (wie der Terminplan ohne Filter), abgeschlossene sind grau */
|
||||
export function projektFarbe(p: { id: string; farbe?: string | null }, alle: { id: string; status?: string }[]): string {
|
||||
if (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "")) return p.farbe!;
|
||||
// Rot ist keine Projektfarbe mehr, es steht für Warnungen (UX-Prüfung, 08.11.2026): Holzbraun dunkel statt #c53030
|
||||
if (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "")) return p.farbe!.toLowerCase() === "#c53030" ? "#7a4a24" : p.farbe!;
|
||||
const i = alle.filter((x) => x.status !== "abgeschlossen").findIndex((x) => x.id === p.id);
|
||||
return i < 0 ? "#718096" : FARBEN[i % FARBEN.length]!;
|
||||
}
|
||||
|
||||
@@ -106,14 +106,39 @@ export function zahlungsplanBetraege(auftragssumme: Cent, raten: Rate[]): Cent[]
|
||||
return [...vorne, auftragssumme - summe(vorne)];
|
||||
}
|
||||
|
||||
/** Standard-Zahlungsplan bei neuen Projekten (Henning, 17.10.2026), je Projekt änderbar. */
|
||||
export const STANDARD_ZAHLUNGSPLAN: { bezeichnung: string; prozent: number }[] = [
|
||||
{ bezeichnung: "Anzahlung bei Auftrag", prozent: 30 },
|
||||
{ bezeichnung: "Abschlag nach Abbund und Richten", prozent: 40 },
|
||||
{ bezeichnung: "Abschlag nach Fertigstellung der Restarbeiten", prozent: 20 },
|
||||
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 10 },
|
||||
/** Wann eine Rate fällig wird: bei Auftrag, nach Abbund und Richten, nach den Restarbeiten oder nach der Abnahme */
|
||||
export type RatenZiel = "auftrag" | "richten" | "rest" | "schluss";
|
||||
export interface PlanRate { bezeichnung: string; prozent: number; ziel: RatenZiel }
|
||||
/** Ab diesem Auftragswert (netto, Cent) gilt die Stufe; die höchste passende gewinnt */
|
||||
export interface ZahlungsStufe { ab: Cent; raten: PlanRate[] }
|
||||
|
||||
/** Standard-Zahlungsplan bei großen Projekten (Henning, 17.10.2026), je Projekt änderbar. */
|
||||
export const STANDARD_ZAHLUNGSPLAN: PlanRate[] = [
|
||||
{ bezeichnung: "Anzahlung bei Auftrag", prozent: 30, ziel: "auftrag" },
|
||||
{ bezeichnung: "Abschlag nach Abbund und Richten", prozent: 40, ziel: "richten" },
|
||||
{ bezeichnung: "Abschlag nach Fertigstellung der Restarbeiten", prozent: 20, ziel: "rest" },
|
||||
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 10, ziel: "schluss" },
|
||||
];
|
||||
|
||||
/**
|
||||
* Anzahl der Raten nach Auftragswert (Henning, 09.11.2026): unter 10.000 € eine Rate, 10.000–20.000 € zwei,
|
||||
* darüber vier. Grenzen und Aufteilung unter Einstellungen › Vorlagen änderbar.
|
||||
*/
|
||||
export const STANDARD_STAFFEL: ZahlungsStufe[] = [
|
||||
{ ab: 0, raten: [{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 100, ziel: "schluss" }] },
|
||||
{ ab: 1_000_000, raten: [
|
||||
{ bezeichnung: "Abschlag nach Abbund und Richten", prozent: 50, ziel: "richten" },
|
||||
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 50, ziel: "schluss" },
|
||||
] },
|
||||
{ ab: 2_000_000, raten: STANDARD_ZAHLUNGSPLAN },
|
||||
];
|
||||
|
||||
/** Die Raten der Stufe, die zum Auftragswert passt; ohne passende Stufe die kleinste */
|
||||
export function ratenFuer(auftragssumme: Cent, staffel: ZahlungsStufe[] = STANDARD_STAFFEL): PlanRate[] {
|
||||
const stufen = [...(staffel.length ? staffel : STANDARD_STAFFEL)].sort((a, b) => a.ab - b.ab);
|
||||
return ([...stufen].reverse().find((s) => s.ab <= auftragssumme) ?? stufen[0]!).raten;
|
||||
}
|
||||
|
||||
export interface ZahlungsVorschlag {
|
||||
bezeichnung: string;
|
||||
art: "anzahlung" | "abschlag" | "schluss";
|
||||
@@ -130,8 +155,10 @@ export interface ZahlungsVorschlag {
|
||||
*/
|
||||
export function schlageZahlungsplanVor(
|
||||
auftragssumme: Cent, vorgaenge: { id: string; name: string; anfang: Datum; ende: Datum }[], heute: Datum,
|
||||
raten: PlanRate[] = STANDARD_ZAHLUNGSPLAN,
|
||||
): ZahlungsVorschlag[] {
|
||||
const betraege = zahlungsplanBetraege(auftragssumme, STANDARD_ZAHLUNGSPLAN);
|
||||
if (!raten.length) return [];
|
||||
const betraege = zahlungsplanBetraege(auftragssumme, raten);
|
||||
const vs = [...vorgaenge].sort((a, b) => (a.ende < b.ende ? -1 : a.ende > b.ende ? 1 : 0));
|
||||
const letzter = (muster: RegExp) => [...vs].reverse().find((v) => muster.test(v.name));
|
||||
const schluss = letzter(/abnahme/i) ?? vs.at(-1);
|
||||
@@ -139,7 +166,12 @@ export function schlageZahlungsplanVor(
|
||||
const vorSchluss = schluss ? vs.filter((v) => v.ende < schluss.ende && (!richten || v.ende > richten.ende)).at(-1) ?? schluss : undefined;
|
||||
const anzahlung = vs.length ? (heute < vs[0]!.anfang ? heute : vs[0]!.anfang) : heute;
|
||||
const an = (v: { id: string; ende: Datum } | undefined) => ({ vorgang_id: v?.id ?? null, termin: v?.ende ?? heute });
|
||||
const arten = ["anzahlung", "abschlag", "abschlag", "schluss"] as const;
|
||||
const ziele = [{ vorgang_id: null, termin: anzahlung }, an(richten), an(vorSchluss), an(schluss)];
|
||||
return STANDARD_ZAHLUNGSPLAN.map((r, i) => ({ bezeichnung: r.bezeichnung, art: arten[i]!, netto: betraege[i]!, ...ziele[i]! }));
|
||||
const ziele: Record<RatenZiel, { vorgang_id: string | null; termin: Datum }> = {
|
||||
auftrag: { vorgang_id: null, termin: anzahlung }, richten: an(richten), rest: an(vorSchluss), schluss: an(schluss),
|
||||
};
|
||||
// die letzte Rate ist immer die Schlussrechnung: sie bekommt den Rest
|
||||
return raten.map((r, i) => ({
|
||||
bezeichnung: r.bezeichnung, netto: betraege[i]!, ...ziele[r.ziel],
|
||||
art: i === raten.length - 1 ? "schluss" : r.ziel === "auftrag" ? "anzahlung" : "abschlag",
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -100,7 +100,7 @@ export interface Woche {
|
||||
/**
|
||||
* T16: je Woche die Stunden, für die das Team eingeplant ist (je Vorgang und Tag das Soll der Person, Urlaub nicht
|
||||
* abgezogen, damit Einplanung im Urlaub als Überplanung auffällt), gegen die verfügbaren Stunden (Urlaub abgezogen).
|
||||
* Ein freigegebener Freitag zählt nur für die Leute, die an diesem Vorgang eingeteilt sind, geplant und verfügbar.
|
||||
* Gerechnet wird nur über die Arbeitstage der Firma (Mo–Do); freigegebene Freitage bleiben außen vor.
|
||||
*/
|
||||
export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: { id: string; start?: Datum; start_teil?: number | null; anfang: Datum; ende: Datum; dauer: number; freitage?: Datum[] | null }[],
|
||||
besetzungen: KapBesetzung[], p: Personaldaten, woche: Arbeitswoche): Woche[] {
|
||||
@@ -110,18 +110,15 @@ export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: {
|
||||
// Vierteltage: an jedem Tag zählt nur der Teil, den der Vorgang belegt
|
||||
const anteile = new Map([...vById.values()].map((v) => [v.id, tagesAnteile(v.anfang, Number(v.dauer), wocheVon(v, woche), v.start === v.anfang ? Number(v.start_teil ?? 0) : 0)]));
|
||||
const wochen = new Map<Datum, Woche>();
|
||||
const extra = new Set(vorgaenge.flatMap((v) => v.freitage ?? []));
|
||||
// die Auslastung rechnet nur die Arbeitswoche (Mo–Do); ein freigegebener Freitag ist Reserve und zählt nicht mit
|
||||
// (UX-Prüfung, Henning 08.11.2026: „Woche voll: 32 von 32 Std. (Mo–Do)“)
|
||||
for (let d = von; d <= bis; d = plusTage(d, 1)) {
|
||||
const firmentag = istArbeitstag(d, woche);
|
||||
if (!firmentag && !extra.has(d)) continue;
|
||||
// am freigegebenen Freitag nur die Vorgänge, die ihn freigegeben haben, und deren Leute
|
||||
const dabei = firmentag ? null : new Set(eigene.filter((b) => vById.get(b.vorgang_id)?.freitage?.includes(d)).map((b) => b.kontakt_id!));
|
||||
if (dabei && !dabei.size) continue;
|
||||
if (!firmentag) continue;
|
||||
const ab = montagDerWoche(d);
|
||||
let w = wochen.get(ab);
|
||||
if (!w) wochen.set(ab, (w = { ab, geplant: 0, verfuegbar: 0, personen: team.map((kontakt_id) => ({ kontakt_id, geplant: 0, verfuegbar: 0 })) }));
|
||||
for (const pers of w.personen) {
|
||||
if (dabei && !dabei.has(pers.kontakt_id)) continue;
|
||||
const f = freiAm(p, pers.kontakt_id, d);
|
||||
pers.verfuegbar += f;
|
||||
w.verfuegbar += f;
|
||||
@@ -129,7 +126,6 @@ export function auslastung(von: Datum, bis: Datum, team: string[], vorgaenge: {
|
||||
for (const b of eigene) {
|
||||
const v = vById.get(b.vorgang_id);
|
||||
if (!v || v.anfang > d || v.ende < d) continue;
|
||||
if (!firmentag && !v.freitage?.includes(d)) continue;
|
||||
const h = sollStunden(p.modelle, b.kontakt_id!, d, p.stundenProTag) * (Number(b.personen) > 0 ? Number(b.personen) : 1) * (anteile.get(v.id)!.get(d) ?? 0);
|
||||
w.personen.find((x) => x.kontakt_id === b.kontakt_id)!.geplant += h;
|
||||
w.geplant += h;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// 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 Datum, plusMonate, plusTage } from "./datum.js";
|
||||
import type { Cent } from "./geld.js";
|
||||
import type { LaufendeKosten, Periode, Posten } from "./liquiditaet.js";
|
||||
|
||||
@@ -60,3 +60,13 @@ export function lage(wochen: Periode[], kontostand: Cent, mindestgrenze: Cent):
|
||||
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 };
|
||||
}
|
||||
|
||||
/** Übersicht „Geld bis TT.MM.“ (UX-Prüfung, Henning 08.11.2026): die nächsten vier Wochen ab heute, gerechnet wie die
|
||||
* Liquidität (Einnahmen − Projektkosten − laufende Kosten − Umsatzsteuer); überfällige Einnahmen zählen mit. */
|
||||
export function geldAbHeute(wochen: Periode[], heute: Datum) {
|
||||
const bis = plusTage(heute, 27);
|
||||
const posten = wochen.flatMap((w) => w.posten).filter((p) => (p.ueberfaelligSeit || p.datum >= heute) && p.datum <= bis);
|
||||
const summe = (g: Posten["gruppe"]) => posten.filter((p) => p.gruppe === g).reduce((s, p) => s + p.betrag, 0);
|
||||
const einnahmen = summe("Projekteinnahmen"), projektkosten = 0 - summe("Projektkosten"), laufend = 0 - summe("Laufende Kosten"), ust = 0 - summe("Umsatzsteuer");
|
||||
return { von: heute, bis, einnahmen, projektkosten, laufend, ust, betrag: einnahmen - projektkosten - laufend - ust };
|
||||
}
|
||||
|
||||
@@ -12,21 +12,22 @@ export interface Aufgabe {
|
||||
erledigt_am?: string | null;
|
||||
}
|
||||
|
||||
/** V70: „Diese Woche“ (fällig bis Sonntag), „Noch nicht abgearbeitet“ (überfällig), „Langfristig“ (später oder ohne Datum). */
|
||||
/** UX-Prüfung (Henning, 08.11.2026): „Überfällig“, „Nächste 7 Tage“ (heute bis heute + 6), „Später“ (danach, ohne Datum
|
||||
* oder als langfristig markiert). */
|
||||
export function aufgabenGruppen<T extends Aufgabe>(aufgaben: T[], heute: Datum) {
|
||||
const sonntag = plusTage(heute, (7 - wochentag(heute)) % 7);
|
||||
const g = { dieseWoche: [] as T[], ueberfaellig: [] as T[], langfristig: [] as T[] };
|
||||
const bis = plusTage(heute, 6);
|
||||
const g = { ueberfaellig: [] as T[], naechste7: [] as T[], spaeter: [] as T[] };
|
||||
for (const a of aufgaben) {
|
||||
if (a.erledigt_am) continue;
|
||||
const d = a.faellig_am;
|
||||
if (d && d < heute) g.ueberfaellig.push(a);
|
||||
else if (d && d <= sonntag && !a.langfristig) g.dieseWoche.push(a);
|
||||
else g.langfristig.push(a);
|
||||
else if (d && d <= bis && !a.langfristig) g.naechste7.push(a);
|
||||
else g.spaeter.push(a);
|
||||
}
|
||||
const nachDatum = (a: T, b: T) => (a.faellig_am ?? "9999") < (b.faellig_am ?? "9999") ? -1 : (a.faellig_am ?? "9999") > (b.faellig_am ?? "9999") ? 1 : a.text.localeCompare(b.text, "de");
|
||||
g.dieseWoche.sort(nachDatum);
|
||||
g.naechste7.sort(nachDatum);
|
||||
g.ueberfaellig.sort(nachDatum);
|
||||
g.langfristig.sort(nachDatum);
|
||||
g.spaeter.sort(nachDatum);
|
||||
return g;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation. Anlegen mit festgeschriebenen Sätzen (A36),
|
||||
// Versandprüfung (A14), Kalkulationsstand beim Versand und bei Auftrag (A19), „Angebot annehmen“ macht aus dem
|
||||
// Projekt den Auftrag mit Abschnitten, Vorgängen und Zahlungsplan (A4, P9).
|
||||
import { type PlanRate, ratenFuer, zahlungsplanBetraege } from "../domain/geld.js";
|
||||
import { empfaengerLaden } from "./empfaenger.js";
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
@@ -62,7 +63,11 @@ export async function ladeAngebot(c: Pick<Pool, "query">, id: string, e: Einstel
|
||||
const ergebnis = berechneAngebot({ ust_satz: e.ust.satz }, titel, positionen, kosten, saetze);
|
||||
// Anschrift mit z. Hd. und Briefanrede (0.49); festgeschrieben gilt der Stand vom Versand
|
||||
const empfaenger = await empfaengerLaden(c, angebot.projekt_id);
|
||||
return { angebot, titel, positionen, kosten, saetze, ergebnis, empfaenger };
|
||||
// Zahlungsplan im Angebot (Henning, 09.11.2026): eigene Raten oder Vorschlag aus der Staffel nach der Angebotssumme
|
||||
const zpRaten: PlanRate[] = angebot.zahlungsplan ?? ratenFuer(ergebnis.netto, e.zahlungsStaffel);
|
||||
const zpNetto = zahlungsplanBetraege(ergebnis.netto, zpRaten), zpBrutto = zahlungsplanBetraege(ergebnis.brutto, zpRaten);
|
||||
const zahlungsplan = { eigen: !!angebot.zahlungsplan, raten: zpRaten.map((r, i) => ({ ...r, netto: zpNetto[i]!, brutto: zpBrutto[i]! })) };
|
||||
return { angebot, titel, positionen, kosten, saetze, ergebnis, empfaenger, zahlungsplan };
|
||||
}
|
||||
|
||||
function pruefung(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>) {
|
||||
@@ -76,7 +81,7 @@ function stand(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>, anlass:
|
||||
anlass, am: new Date().toISOString(), von: wer, saetze: x.saetze,
|
||||
netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, kosten: x.ergebnis.kosten,
|
||||
kostenarten: x.ergebnis.kostenarten, titel: x.titel, positionen: x.positionen.map((p) => ({ ...p, ergebnis: x.ergebnis.positionen[p.id] })),
|
||||
kosten_zeilen: x.kosten, empfaenger: x.empfaenger,
|
||||
kosten_zeilen: x.kosten, empfaenger: x.empfaenger, zahlungsplan: x.zahlungsplan,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -252,15 +257,16 @@ export function registriereAngebote(
|
||||
// M17: Sätze aus den Stundensatz-Tabellen, die heute gelten; Vollkostensatz, daher Lohnzuschlag 0 % (A37, S4)
|
||||
const neue = await aktuelleSaetze(c, datum);
|
||||
const quelle = lv ? `${lv.format}${lv.phase ? ` Phase ${lv.phase}` : ""} · ${q.gaeb!.dateiname}` : q.vorbeleg_id ? `aus ${BELEG[vorlage.belegart as Belegart]?.name ?? "Dokument"} ${vorlage.nummer}` : null;
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze, vorbeleg_id, quelle, notiz)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) returning *`,
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze, vorbeleg_id, quelle, notiz, zahlungsplan)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) returning *`,
|
||||
[q.projekt_id, nummer, art, datum, k.bindefristWochen && BELEG[art].gruppe === "kunde" && !["lieferschein", "auftragsbestaetigung"].includes(art) ? plusTage(datum, 7 * k.bindefristWochen) : null,
|
||||
vorlage?.betreff ?? (lv ? (lv.projekt ?? lv.name).slice(0, 300) : null), vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
|
||||
vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall,
|
||||
// A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen
|
||||
{ stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
|
||||
zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum },
|
||||
q.vorbeleg_id ?? null, quelle, lv?.vortexte ? `Vorbemerkungen aus der GAEB-Datei:\n${lv.vortexte}`.slice(0, 100_000) : null])).rows[0];
|
||||
q.vorbeleg_id ?? null, quelle, lv?.vortexte ? `Vorbemerkungen aus der GAEB-Datei:\n${lv.vortexte}`.slice(0, 100_000) : null,
|
||||
vorlage?.zahlungsplan ? JSON.stringify(vorlage.zahlungsplan) : null])).rows[0];
|
||||
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
|
||||
if (lv) await gaebEinfuegen(c, neu.id, lv);
|
||||
// Ausschreibung an Subunternehmer ohne eigene Preise (A15)
|
||||
@@ -477,6 +483,10 @@ export function registriereAngebote(
|
||||
let umsatz = 0;
|
||||
for (const s of summe) umsatz += s.id === id ? x.ergebnis.netto : (await ladeAngebot(c, s.id, e))!.ergebnis.netto;
|
||||
const status = ["anfrage", "angebot"].includes(p.status) ? "auftrag" : p.status;
|
||||
// eigener Zahlungsplan im Angebot gilt fürs Projekt, solange es noch keine Raten hat
|
||||
if (x.zahlungsplan.eigen && !(await c.query("select 1 from zahlung where projekt_id = $1 limit 1", [pid])).rowCount) {
|
||||
await c.query("update projekt set zahlungsplan_raten = $2 where id = $1", [pid, JSON.stringify(x.zahlungsplan.raten.map(({ bezeichnung, prozent, ziel }) => ({ bezeichnung, prozent, ziel })))]);
|
||||
}
|
||||
// aus A-26-024 wird P-26-024, die Zahl bleibt (Henning, 26.10.2026)
|
||||
const nummer = projektNummer(p.nummer, status);
|
||||
// geplante Kosten für die Liquidität, nur wenn noch keine eingetragen sind
|
||||
|
||||
@@ -16,7 +16,8 @@ import { CardDav, ergebnisText, kontakteAbgleichen, vcfEinlesen } from "./kontak
|
||||
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 { formatEuro } from "../domain/geld.js";
|
||||
import { geldAbHeute, laufendJeMonat, lage } from "../domain/lage.js";
|
||||
import { liquiditaetsDaten } from "../domain/projektplan.js";
|
||||
import { uebernimmV70 } from "../domain/v70.js";
|
||||
import { speichereUebernahme } from "./v70import.js";
|
||||
@@ -34,7 +35,7 @@ import { registriereStundensaetze } from "./stundensaetze.js";
|
||||
import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js";
|
||||
import { planPosten } from "../domain/jahresplan.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
import { formatDatum, plusTage } from "../domain/datum.js";
|
||||
import { formatDatum, plusTage, tageZwischen } from "../domain/datum.js";
|
||||
import { eigeneAdressen, kartenAdressen, zusammen } from "./adressen.js";
|
||||
import { prioritaetenLaden } from "./prioritaet.js";
|
||||
import { empfaengerLaden } from "./empfaenger.js";
|
||||
@@ -65,6 +66,10 @@ const benutzer = (req: FastifyRequest): string => werName(req);
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
|
||||
// jsonb-Listen gehen als JSON in die Datenbank, sonst machte pg daraus ein Postgres-Array
|
||||
const JSON_LISTEN = new Set(["zahlungsplan", "zahlungsplan_raten"]);
|
||||
const alsWert = (spalte: string, wert: unknown) => (JSON_LISTEN.has(spalte) && Array.isArray(wert) ? JSON.stringify(wert) : wert);
|
||||
|
||||
export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
const app = Fastify({ logger: o.logger ?? false, bodyLimit: 50 * 1024 * 1024 });
|
||||
const { pool } = o;
|
||||
@@ -472,7 +477,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
spalten.map((s) => alsWert(s, daten[s])),
|
||||
)).rows[0], [], t.name === "zahlung" ? daten.projekt_id as string : undefined);
|
||||
});
|
||||
if (t.name === "projekt") return reply.status(201).send(await mitOrdner(row, benutzer(req)));
|
||||
@@ -502,7 +507,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
|
||||
[id, ...spalten.map((s) => daten[s])],
|
||||
[id, ...spalten.map((s) => alsWert(s, daten[s]))],
|
||||
)).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : [], zahlungVon);
|
||||
});
|
||||
if (row && t.name === "projekt" && (daten.nummer || daten.bezeichnung || daten.status)) return mitOrdner(row, benutzer(req));
|
||||
@@ -660,7 +665,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
const woche = { tage: e.arbeitstage };
|
||||
// Stufe 5: Finanzsitzung am ersten Freitag im Monat, sobald es einen Jahresplan gibt
|
||||
if (e.finanzsitzung) await transaktion(pool, benutzer(req), (c) => finanzsitzungAnlegen(c, heute));
|
||||
const [tp, aufgaben, liqui, jahresplan] = await Promise.all([
|
||||
const [tp, aufgaben, liqui, jahresplan, fuenf] = await Promise.all([
|
||||
terminplan(pool, woche, e.stundenProTag),
|
||||
pool.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, k.name as kontakt_name, g.name as kategorie
|
||||
from aufgabe a left join projekt p on p.id = a.projekt_id left join kontakt k on k.id = a.kontakt_id
|
||||
@@ -668,9 +673,27 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`),
|
||||
liquiLage(heute, 4),
|
||||
req.wer?.rolle === "inhaber" ? jahresplanStand(pool, liquiDaten, heute) : null,
|
||||
// Handy: Geld der nächsten 4 Wochen ab heute (die Wochen der Liquidität beginnen am Montag)
|
||||
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl: 5, offene: "1" }),
|
||||
]);
|
||||
const u = { ...uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui: liqui.wochen, mindestreserve: liqui.mindestgrenze,
|
||||
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null, mitKontostand: e.liquiditaetMitKontostand }), liquiLage: { ...liqui, wochen: undefined }, jahresplan };
|
||||
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null, mitKontostand: e.liquiditaetMitKontostand, ich: req.wer?.kontakt_id ?? null }),
|
||||
liquiLage: { ...liqui, wochen: undefined }, jahresplan, geld: geldAbHeute(fuenf, heute) };
|
||||
// „Brennt“: überfällige Raten und Rechnungen aus der Liquidität, vor dem fehlenden Kontostand
|
||||
const ueber = fuenf.flatMap((w) => w.posten).filter((p) => p.ueberfaelligSeit);
|
||||
const zids = ueber.map((p) => /^zahlung:(.+)$/.exec(p.quelle ?? "")?.[1]).filter((x): x is string => !!x);
|
||||
const zuProjekt = new Map<string, string>(zids.length
|
||||
? (await pool.query("select id, projekt_id from zahlung where id = any($1::uuid[])", [zids])).rows.map((r) => [r.id, r.projekt_id]) : []);
|
||||
const zahlungen = ueber.map((p) => {
|
||||
const [art, id] = (p.quelle ?? "").split(":");
|
||||
const pid = art === "zahlung" ? zuProjekt.get(id!) : art === "rest" ? id : undefined;
|
||||
const betrag = formatEuro(Math.round(p.betrag / 100) * 100).replace(",00 €", " €");
|
||||
const seit = p.ueberfaelligSeit!, tage = tageZwischen(seit, heute);
|
||||
return { art: "zahlung" as const, ziel: pid ? `projekt-${pid}-zahlungen` : "liquiditaet", text: `${p.bezeichnung} ${p.projekt ?? ""} · ${betrag}`.replace(" ", " "),
|
||||
unter: `seit ${formatDatum(seit).slice(0, 6)} fällig, ${p.gestellt ? `${tage} ${tage === 1 ? "Tag" : "Tage"} überfällig` : "Rechnung fehlt noch"}` };
|
||||
});
|
||||
const k = u.brennt.findIndex((b) => b.art === "kontostand");
|
||||
u.brennt.splice(k < 0 ? u.brennt.length : k, 0, ...zahlungen);
|
||||
// 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`);
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { z } from "zod";
|
||||
import { STANDARD_STAFFEL } from "../domain/geld.js";
|
||||
|
||||
// Aufgaben, die jedes beauftragte Projekt von selbst bekommt (Henning, 20.10.2026), an einem Vorgang festgemacht:
|
||||
// bezug ist ein Wort aus dem Vorgangsnamen („Abbund“), leer = der erste Vorgang des Projekts
|
||||
@@ -42,6 +43,18 @@ export const EinstellungenSchema = z.object({
|
||||
versteuerung: z.enum(["soll", "ist"]).default("ist"),
|
||||
})
|
||||
.prefault({}),
|
||||
// Zahlungsplan nach Auftragswert (Henning, 09.11.2026): je Stufe ab einem Netto-Auftragswert (Cent) die Raten in Prozent
|
||||
zahlungsStaffel: z
|
||||
.array(z.object({
|
||||
ab: z.number().int().min(0),
|
||||
raten: z.array(z.object({
|
||||
bezeichnung: z.string().trim().min(1).max(120),
|
||||
prozent: z.number().min(0).max(100),
|
||||
ziel: z.enum(["auftrag", "richten", "rest", "schluss"]),
|
||||
})).min(1).max(8),
|
||||
}))
|
||||
.min(1).max(6)
|
||||
.default(STANDARD_STAFFEL),
|
||||
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),
|
||||
|
||||
4
src/server/migrations/031_zahlungsplan_angebot.sql
Normal file
4
src/server/migrations/031_zahlungsplan_angebot.sql
Normal file
@@ -0,0 +1,4 @@
|
||||
-- Zahlungsplan im Angebot (Henning, 09.11.2026): null = Vorschlag aus der Staffel nach Auftragswert,
|
||||
-- sonst die Raten des Angebots ([{bezeichnung, prozent, ziel}]). Beim Annehmen gehen eigene Raten ins Projekt.
|
||||
alter table angebot add column zahlungsplan jsonb;
|
||||
alter table projekt add column zahlungsplan_raten jsonb;
|
||||
@@ -156,6 +156,8 @@ export const TABELLEN: Tabelle[] = [
|
||||
baustelle_ort: optText,
|
||||
notiz: optText,
|
||||
prioritaet: z.enum(["A", "B", "C"]).nullable().optional(),
|
||||
// Raten aus dem angenommenen Angebot (0.52); null = Staffel nach Auftragswert
|
||||
zahlungsplan_raten: z.array(z.object({ bezeichnung: z.string().trim().min(1).max(120), prozent: z.number().min(0).max(100), ziel: z.enum(["auftrag", "richten", "rest", "schluss"]) })).min(1).max(8).nullable().optional(),
|
||||
frist: datum.nullable().optional(),
|
||||
termindruck: z.enum(["witterung", "vertragsstrafe"]).nullable().optional(),
|
||||
}),
|
||||
@@ -198,6 +200,8 @@ export const TABELLEN: Tabelle[] = [
|
||||
stand: datum.optional(),
|
||||
}).optional(),
|
||||
notiz: optText,
|
||||
// Zahlungsplan im Angebot (0.52); null = Vorschlag aus der Staffel
|
||||
zahlungsplan: z.array(z.object({ bezeichnung: z.string().trim().min(1).max(120), prozent: z.number().min(0).max(100), ziel: z.enum(["auftrag", "richten", "rest", "schluss"]) })).min(1).max(8).nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
|
||||
@@ -7,6 +7,7 @@ import { flussJeWoche } from "../domain/lage.js";
|
||||
import { type Warnung, aufgabenGruppen, einsatzMatrix, naechsteArbeitstage } from "../domain/uebersicht.js";
|
||||
import type { terminplan } from "./terminplan.js";
|
||||
import { projektFarbe } from "../domain/farbe.js";
|
||||
import { imVerzug, sollFortschritt } from "../domain/fortschritt.js";
|
||||
|
||||
/** Projekte, deren Vorgänge auf der Startseite und in den Warnungen zählen */
|
||||
const LAUFEND = new Set(["auftrag", "ausfuehrung", "intern"]);
|
||||
@@ -25,9 +26,14 @@ interface Eingabe {
|
||||
kontostandErfasst: boolean;
|
||||
/** vorerst aus (Henning, 23.10.2026): dann keine Kontostand-Warnungen */
|
||||
mitKontostand?: boolean;
|
||||
/** Kontakt des Angemeldeten: „Einsatz morgen“ zählt seine Einsätze (auch über seine Kolonnen); ohne: alle */
|
||||
ich?: string | null;
|
||||
}
|
||||
|
||||
export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve, kontostandErfasst, mitKontostand = true }: Eingabe) {
|
||||
/** Zeile der Karte „Brennt“ am Handy: Antippen führt zum Ziel */
|
||||
export interface Brennt { art: "verzug" | "zahlung" | "kontostand"; text: string; unter?: string; ziel: string }
|
||||
|
||||
export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve, kontostandErfasst, mitKontostand = true, ich = null }: Eingabe) {
|
||||
const projektVon = new Map(tp.abschnitte.map((a) => [a.id, tp.projekte.find((p) => p.id === a.projekt_id)!]));
|
||||
const vorgaenge = tp.vorgaenge
|
||||
.map((v) => ({ ...v, p: projektVon.get(v.abschnitt_id)! }))
|
||||
@@ -57,15 +63,9 @@ export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve,
|
||||
}
|
||||
}
|
||||
const gruppen = aufgabenGruppen(aufgaben, heute);
|
||||
if (gruppen.ueberfaellig.length) {
|
||||
warnungen.push({ art: "aufgabe", ziel: "aufgaben", text: `${gruppen.ueberfaellig.length} ${gruppen.ueberfaellig.length === 1 ? "Aufgabe ist" : "Aufgaben sind"} überfällig` });
|
||||
}
|
||||
// „n Aufgaben überfällig“ steht oben in der Zahlenleiste, der fehlende Kontostand unter „Brennt“ (UX-Prüfung, 08.11.2026)
|
||||
const knapp = liqui.find((w) => w.kontostand < mindestreserve);
|
||||
if (!mitKontostand) {
|
||||
// vorerst ohne Kontostand: keine Warnung dazu
|
||||
} else if (!kontostandErfasst) {
|
||||
warnungen.push({ art: "kontostand", ziel: "daten", text: "Aktueller Kontostand ist noch nicht eingetragen, die Liquidität rechnet ab 0 €" });
|
||||
} else if (knapp) {
|
||||
if (mitKontostand && kontostandErfasst && knapp) {
|
||||
warnungen.push({ art: "kontostand", ziel: "liquiditaet",
|
||||
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter deiner Mindestgrenze von ${formatEuro(mindestreserve)}` : ""}` });
|
||||
}
|
||||
@@ -86,13 +86,40 @@ export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve,
|
||||
...tp.kolonnen.filter((o) => o.aktiv !== false).map((o) => ({ wer: `kolonne:${o.id}`, anzeige: o.name as string, art: "kolonne",
|
||||
mitglieder: (o.mitglieder as string[]).filter((id) => name.has(id)).map((id) => ({ wer: id, anzeige: name.get(id)! })) })),
|
||||
].sort((a, b) => a.anzeige.localeCompare(b.anzeige, "de"));
|
||||
const einsatzHandy = einsatzMatrix(vorgaenge.filter((v) => v.dauer > 0), tp.besetzungen, tageLang, woche);
|
||||
|
||||
// Handy-Übersicht (UX-Prüfung, Henning 08.11.2026): Einsätze am nächsten Arbeitstag
|
||||
const naechster = tageLang.find((d) => d > heute) ?? null;
|
||||
let einsatzNaechster: { tag: Datum; anzahl: number; eigene: boolean; was: string[] } | null = null;
|
||||
if (naechster) {
|
||||
const i = tageLang.indexOf(naechster);
|
||||
const kolonnen = ich ? tp.kolonnen.filter((o) => ((o.mitglieder ?? []) as string[]).includes(ich)).map((o) => `kolonne:${o.id}`) : [];
|
||||
const quellen = ich ? einsatzHandy.zeilen.filter((z) => z.wer === ich || kolonnen.includes(z.wer)) : [...einsatzHandy.zeilen, einsatzHandy.ohne];
|
||||
const eintraege = [...new Map(quellen.flatMap((z) => z.tage[i]!).map((x) => [x.vorgang, x])).values()];
|
||||
einsatzNaechster = { tag: naechster, anzahl: eintraege.length, eigene: !!ich, was: [...new Set(eintraege.map((x) => x.projekt))] };
|
||||
}
|
||||
// „Brennt“: Vorgänge im Verzug wie im Terminplan (nur beauftragte und laufende Projekte)
|
||||
const brennt: Brennt[] = [];
|
||||
for (const v of tp.vorgaenge) {
|
||||
const p = projektVon.get(v.abschnitt_id);
|
||||
if (!p || !LAUFEND.has(p.status)) continue;
|
||||
const fv = { anfang: v.anfang, ende: v.ende, dauer: Number(v.dauer), stunden: v.stunden, fortschritt: v.fortschritt, freitage: v.freitage };
|
||||
if (!imVerzug(fv, heute, woche)) continue;
|
||||
const ist = Number(v.fortschritt ?? 0);
|
||||
brennt.push({ art: "verzug", text: `${p.nummer} ${p.bezeichnung} · ${v.name} im Verzug`, ziel: `projekt-${p.id}`,
|
||||
unter: v.ende < heute ? `${ist} % erledigt, sollte am ${formatDatum(v.ende).slice(0, 6)} fertig sein` : `${ist} % erledigt, nach dem Kalender etwa ${sollFortschritt(fv, heute, woche)} %` });
|
||||
}
|
||||
if (mitKontostand && !kontostandErfasst) brennt.push({ art: "kontostand", text: "Kontostand nicht eingetragen", unter: "Ohne ihn zeigt die Liquidität nur den Überschuss.", ziel: "einstellungen-programmteile" });
|
||||
|
||||
return {
|
||||
heute,
|
||||
einsatzNaechster,
|
||||
brennt,
|
||||
aufgaben: gruppen,
|
||||
warnungen,
|
||||
// Meilensteine brauchen keine Besetzung und bleiben aus „Wer macht was“ heraus
|
||||
einsatz: { tage, ...einsatzMatrix(vorgaenge.filter((v) => v.dauer > 0), tp.besetzungen, tage, woche) },
|
||||
einsatzHandy: { tage: tageLang, auswahl, ...einsatzMatrix(vorgaenge.filter((v) => v.dauer > 0), tp.besetzungen, tageLang, woche) },
|
||||
einsatzHandy: { tage: tageLang, auswahl, ...einsatzHandy },
|
||||
liquiditaet: liqui.map(({ von, saldo, kontostand }) => ({ von, saldo, kontostand })),
|
||||
fluss: flussJeWoche(liqui),
|
||||
mitKontostand,
|
||||
|
||||
@@ -1,19 +1,27 @@
|
||||
// P9/P12: Zahlungsplan automatisch (Henning, 20.10.2026). Sobald ein Projekt einen Auftragswert und Termine hat,
|
||||
// entstehen die Raten 30/40/20/10 als Meilensteine im Terminplan. Solange niemand sie von Hand ändert, folgen sie
|
||||
// entstehen die Raten als Meilensteine im Terminplan, ihre Zahl nach dem Auftragswert (Staffel, Henning 09.11.2026). Solange niemand sie von Hand ändert, folgen sie
|
||||
// dem Auftragswert und den Vorgängen (z. B. wenn später ein Vorgang „Richten“ dazukommt). Jede Änderung von Hand
|
||||
// stellt den Plan auf „fest“; er wird dann nie wieder automatisch angefasst oder neu angelegt.
|
||||
import type { Client } from "pg";
|
||||
import { schlageZahlungsplanVor } from "../domain/geld.js";
|
||||
import { type PlanRate, type ZahlungsStufe, ratenFuer, schlageZahlungsplanVor } from "../domain/geld.js";
|
||||
import { EinstellungenSchema } from "./einstellungen.js";
|
||||
import { anfang, ende } from "../domain/terminplan.js";
|
||||
import type { Arbeitswoche } from "../domain/kalender.js";
|
||||
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
|
||||
async function vorschlag(c: Client, projektId: string, umsatz: number, woche: Arbeitswoche) {
|
||||
async function staffel(c: Client): Promise<ZahlungsStufe[]> {
|
||||
const r = await c.query<{ daten: unknown }>("select daten from einstellungen limit 1");
|
||||
return EinstellungenSchema.parse(r.rows[0]?.daten ?? {}).zahlungsStaffel;
|
||||
}
|
||||
|
||||
async function vorschlag(c: Client, projektId: string, umsatz: number, woche: Arbeitswoche, st?: ZahlungsStufe[]) {
|
||||
const vs = (await c.query(`select v.id, v.name, v.start, v.start_teil, v.dauer, v.freitage from vorgang v join abschnitt a on a.id = v.abschnitt_id
|
||||
where a.projekt_id = $1 order by a.reihenfolge, v.reihenfolge, v.nummer`, [projektId])).rows
|
||||
.map((v) => ({ id: v.id, name: v.name, anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }));
|
||||
return schlageZahlungsplanVor(umsatz, vs, heute());
|
||||
// Raten aus dem angenommenen Angebot gehen vor (0.52), sonst die Staffel nach Auftragswert
|
||||
const eigen = (await c.query("select zahlungsplan_raten from projekt where id = $1", [projektId])).rows[0]?.zahlungsplan_raten as PlanRate[] | null | undefined;
|
||||
return schlageZahlungsplanVor(umsatz, vs, heute(), eigen?.length ? eigen : ratenFuer(umsatz, st ?? await staffel(c)));
|
||||
}
|
||||
|
||||
export async function legeZahlungsplanAn(c: Client, projektId: string, umsatz: number, woche: Arbeitswoche): Promise<Record<string, unknown>[]> {
|
||||
@@ -37,13 +45,20 @@ export async function zahlungsplaeneAutomatisch(c: Client, woche: Arbeitswoche):
|
||||
for (const p of neu.rows) await legeZahlungsplanAn(c, p.id, Number(p.umsatz_netto), woche);
|
||||
|
||||
const auto = await c.query<{ id: string; umsatz_netto: string }>("select id, umsatz_netto from projekt where zahlungsplan = 'auto'");
|
||||
const st = auto.rows.length ? await staffel(c) : undefined;
|
||||
for (const p of auto.rows) {
|
||||
const raten = (await c.query("select id, vorgang_id, netto, termin, status from zahlung where projekt_id = $1 order by reihenfolge, termin", [p.id])).rows;
|
||||
const soll = Number(p.umsatz_netto) > 0 ? await vorschlag(c, p.id, Number(p.umsatz_netto), woche) : [];
|
||||
if (raten.length !== soll.length || raten.some((z) => z.status !== "geplant")) {
|
||||
const soll = Number(p.umsatz_netto) > 0 ? await vorschlag(c, p.id, Number(p.umsatz_netto), woche, st) : [];
|
||||
if (raten.some((z) => z.status !== "geplant") || !soll.length) {
|
||||
await c.query("update projekt set zahlungsplan = 'fest' where id = $1", [p.id]);
|
||||
continue;
|
||||
}
|
||||
// andere Stufe (Auftragswert geändert oder Staffel neu): unberührte Raten neu anlegen
|
||||
if (raten.length !== soll.length) {
|
||||
await c.query("delete from zahlung where projekt_id = $1 and status = 'geplant'", [p.id]);
|
||||
await legeZahlungsplanAn(c, p.id, Number(p.umsatz_netto), woche);
|
||||
continue;
|
||||
}
|
||||
for (const [i, z] of raten.entries()) {
|
||||
const s = soll[i]!;
|
||||
if (z.vorgang_id !== s.vorgang_id || Number(z.netto) !== s.netto || z.termin !== s.termin) {
|
||||
|
||||
@@ -228,10 +228,26 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
}
|
||||
};
|
||||
|
||||
// Zahlungsplan des Angebots: ganze Liste zurückschreiben, die letzte Rate bekommt den Rest
|
||||
const zpSpeichern = async (aendern: (raten: { bezeichnung: string; prozent: number; ziel: string }[]) => void) => {
|
||||
const raten = (d.zahlungsplan?.raten ?? []).map((r: Zeile) => ({ bezeichnung: r.bezeichnung, prozent: Number(r.prozent), ziel: r.ziel }));
|
||||
aendern(raten);
|
||||
if (!raten.length) return;
|
||||
const vorn = raten.slice(0, -1).reduce((x: number, r: { prozent: number }) => x + r.prozent, 0);
|
||||
raten.at(-1)!.prozent = Math.max(0, Math.round((100 - vorn) * 100) / 100);
|
||||
return api(`angebote/${id}`, "PATCH", { zahlungsplan: raten });
|
||||
};
|
||||
|
||||
const speichern = async (el: HTMLInputElement) => {
|
||||
const [pfad, zid, ...rest] = el.dataset.k!.split(":") as [string, string, ...string[]];
|
||||
const feld = rest.join(":");
|
||||
if (pfad === "blatt") return blattSpeichern(zid, (b) => setze(b, feld, el.value));
|
||||
if (pfad === "zp") return zpSpeichern((raten) => {
|
||||
const r = raten[Number(zid)]!;
|
||||
if (feld === "prozent") r.prozent = Math.min(100, Math.max(0, zahlAus(el.value) ?? 0));
|
||||
else if (feld === "ziel") r.ziel = el.value;
|
||||
else r.bezeichnung = el.value.trim() || r.bezeichnung;
|
||||
});
|
||||
const typ = el.dataset.typ ?? "text";
|
||||
const roh = el.value.trim();
|
||||
let wert: unknown;
|
||||
@@ -455,6 +471,9 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
// Handy: Titel auf- und zuklappen, Position antippen = Menge und Einheitspreis ändern
|
||||
if (a === "h-titel") { HANDY_ZU.has(zid) ? HANDY_ZU.delete(zid) : HANDY_ZU.add(zid); return zeichne(); }
|
||||
if (a === "h-pos") return await handyPosition(zid);
|
||||
if (a === "zp-neu") { await zpSpeichern((r) => r.splice(r.length - 1, 0, { bezeichnung: "Abschlag", prozent: 0, ziel: "richten" })); return await neuLaden(); }
|
||||
if (a === "zp-weg") { await zpSpeichern((r) => r.splice(Number(zid), 1)); return await neuLaden(); }
|
||||
if (a === "zp-staffel") { await api(`angebote/${id}`, "PATCH", { zahlungsplan: null }); return await neuLaden("Zahlungsplan wieder nach der Staffel."); }
|
||||
if (a === "aktiv") {
|
||||
if (z.aktiv === zid) return;
|
||||
z.aktiv = zid;
|
||||
@@ -1131,6 +1150,31 @@ function briefkopf(d: Zeile, z: Zustand): string {
|
||||
${fliesstext("angebote:x:kopftext", a.kopftext, "Einleitung, z. B. Sehr geehrte Damen und Herren, vielen Dank für Ihre Anfrage …", frei, "Einleitung")}`;
|
||||
}
|
||||
|
||||
// Zahlungsplan im Angebot (Henning, 09.11.2026): Vorschlag aus der Staffel nach Angebotssumme, je Angebot änderbar,
|
||||
// beim Annehmen gehen eigene Raten ins Projekt
|
||||
const ZP_ZIEL: [string, string][] = [["auftrag", "bei Auftrag"], ["richten", "nach Abbund und Richten"], ["rest", "nach den Restarbeiten"], ["schluss", "nach der Abnahme"]];
|
||||
function zahlungsplanHtml(d: Zeile, frei: boolean): string {
|
||||
const zp = d.zahlungsplan as { eigen: boolean; raten: { bezeichnung: string; prozent: number; ziel: string; netto: number; brutto: number }[] } | undefined;
|
||||
if (!zp?.raten.length) return "";
|
||||
const pz = (x: number) => String(Math.round(x * 100) / 100).replace(".", ",");
|
||||
if (!frei) {
|
||||
return `<div class="am-zp"><h3 class="am-h">Zahlungsplan</h3><ol class="am-zp-lese">${zp.raten.map((r) =>
|
||||
`<li><span>${esc(r.bezeichnung)}</span><span class="z">${pz(r.prozent)} %</span><span class="z">${euro(r.brutto)} brutto</span></li>`).join("")}</ol></div>`;
|
||||
}
|
||||
const letzte = zp.raten.length - 1;
|
||||
return `<div class="am-zp"><div class="am-zp-kopf"><h3 class="am-h">Zahlungsplan</h3>
|
||||
<span class="hinweis-k">${zp.eigen ? "eigener Plan für dieses Angebot" : "Vorschlag nach Angebotssumme (Einstellungen › Vorlagen)"}</span>
|
||||
${zp.eigen ? '<button class="verweis" data-a="zp-staffel">Vorschlag wiederherstellen</button>' : ""}</div>
|
||||
<div class="am-zp-tab">${zp.raten.map((r, i) => `<div class="am-zp-zeile">
|
||||
<input data-k="zp:${i}:bezeichnung" value="${esc(r.bezeichnung)}" aria-label="Rate ${i + 1}" data-leer="pflicht">
|
||||
${i === letzte ? `<span class="z am-zp-rest" title="Die Schlussrechnung bekommt den Rest">${pz(r.prozent)} %</span>`
|
||||
: `<span class="mit-einheit"><input class="zahl w-kurz" data-k="zp:${i}:prozent" value="${pz(r.prozent)}" inputmode="decimal" aria-label="Anteil"> %</span>`}
|
||||
<select data-k="zp:${i}:ziel" aria-label="fällig">${ZP_ZIEL.map(([k, t]) => `<option value="${k}"${k === r.ziel ? " selected" : ""}>${t}</option>`).join("")}</select>
|
||||
<span class="z">${euro(r.netto)}</span>
|
||||
${zp.raten.length > 1 ? `<button class="zeile-weg" data-a="zp-weg" data-id="${i}" aria-label="Rate entfernen">✕</button>` : "<span></span>"}</div>`).join("")}</div>
|
||||
<button class="verweis" data-a="zp-neu">+ Rate</button></div>`;
|
||||
}
|
||||
|
||||
const datenlisten = (b: Blatt | null) => `<datalist id="einheiten">${EINHEITEN.map((x) => `<option value="${x}">`).join("")}</datalist>${kuerzelListe("am-kuerzel", b ?? leeresBlatt())}`;
|
||||
|
||||
function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string, leistungen: Zeile[]): string {
|
||||
@@ -1163,7 +1207,8 @@ function html(d: Zeile, z: Zustand, vorlagen: Mengenvorlage[], meldung: string,
|
||||
</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")}
|
||||
${zahlungsplanHtml(d, frei)}
|
||||
${fliesstext("angebote:x:schlusstext", a.schlusstext, "Schlusstext, z. B. Grüße. {bindefrist} wird durch das Datum ersetzt.", frei, "Schlusstext")}
|
||||
</section>
|
||||
${seitenleiste(d, z, vorlagen, leistungen)}
|
||||
</div>
|
||||
|
||||
443
src/web/app.ts
443
src/web/app.ts
@@ -14,14 +14,14 @@ import { plusTage } from "../domain/datum.js";
|
||||
import { naechsteProjektNummer, nummerKern, nummerSchluessel, projektNummer, zerlege } from "../domain/nummer.js";
|
||||
import { PRIOS, PRIO_TEXT, type PrioErgebnis, TERMINDRUCK, prioErklaerung } from "../domain/prioritaet.js";
|
||||
import { type Eckdaten, type Reihenfolge, STANDARD_REIHENFOLGE, eckdatenRechnen, kostenSetzen, kostenVon, rohertragVon, vorn } from "../domain/eckdaten.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { type PlanRate, type RatenZiel, type ZahlungsStufe, STANDARD_STAFFEL, formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
|
||||
import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite } from "./angebote.js";
|
||||
import { dokumentMenue } from "./dokument.js";
|
||||
import { vorlageSeite } from "./mengenblatt.js";
|
||||
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiditaetSeite, zaehltHaken, zaehltSetzen } from "./liquiditaet.js";
|
||||
import { flussKachelnHtml, flussSvg, lageKopfHtml, liquiNurProjekt, liquiditaetSeite, zaehltHaken, zaehltSetzen } from "./liquiditaet.js";
|
||||
import { laufendeKostenSeite } from "./laufendekosten.js";
|
||||
import { jahresplanSeite } from "./jahresplan.js";
|
||||
import { kontaktSeite } from "./kontakt.js";
|
||||
@@ -62,6 +62,34 @@ async function kontakte(): Promise<void> {
|
||||
}));
|
||||
}
|
||||
|
||||
// Rechnungen (UX-Prüfung, Henning 08.11.2026): alle gestellten und bezahlten Raten aller Projekte; geschrieben werden
|
||||
// sie weiter in Plancraft, hier steht, was gestellt, offen oder bezahlt ist
|
||||
async function rechnungenSeite(): Promise<void> {
|
||||
seite("Rechnungen");
|
||||
const [zahlungen, projekteListe, einst] = await Promise.all([api<Zeile[]>("zahlungen"), api<Zeile[]>("projekte"), api<Zeile>("einstellungen")]);
|
||||
const projekt = new Map(projekteListe.map((p) => [p.id, p]));
|
||||
const fristVorschlag = Number(einst?.zahlungsziele?.kundenTage ?? 14);
|
||||
const faellig = (z: Zeile) => plusTage(z.rechnungsdatum ?? z.termin, z.zahlungsziel_tage == null ? fristVorschlag : Number(z.zahlungsziel_tage));
|
||||
const zustand = (z: Zeile) => (z.status === "bezahlt" ? "bezahlt" : faellig(z) < heute() ? "überfällig" : "offen");
|
||||
const zeilen = zahlungen.filter((z) => z.status === "gestellt" || z.status === "bezahlt");
|
||||
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis">Rechnungen schreibst du weiter in Plancraft. Eine Rate erscheint hier, sobald sie im Zahlungsplan des Projekts auf „gestellt“ steht.</p>');
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "rechnungen", einheit: ["Rechnung", "Rechnungen"], vorgabe: { sort: [["datum", "ab"]] }, leer: "Noch keine Rechnung gestellt.",
|
||||
spalten: [
|
||||
{ id: "nummer", titel: "Nummer", wert: (z) => `<span class="nowrap">${esc(projekt.get(z.projekt_id)?.nummer ?? "")}</span>`, text: (z) => projekt.get(z.projekt_id)?.nummer ?? "" },
|
||||
{ id: "projekt", titel: "Projekt", wert: (z) => esc(projekt.get(z.projekt_id)?.bezeichnung ?? ""), text: (z) => projekt.get(z.projekt_id)?.bezeichnung ?? "" },
|
||||
{ id: "rechnung", titel: "Rechnung", wert: (z) => esc(z.bezeichnung), text: (z) => z.bezeichnung },
|
||||
{ id: "datum", titel: "Rechnungsdatum", art: "datum", wert: (z) => dat(z.rechnungsdatum ?? z.termin), sortWert: (z) => z.rechnungsdatum ?? z.termin },
|
||||
{ id: "faellig", titel: "Fällig", art: "datum", wert: (z) => (z.status === "bezahlt" ? "" : dat(faellig(z))), sortWert: (z) => faellig(z), klasse: "optional" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (z) => euro(z.netto), sortWert: (z) => Number(z.netto) },
|
||||
{ id: "status", titel: "Status", text: zustand,
|
||||
wert: (z) => { const st = zustand(z); return `<span class="marke ${st === "bezahlt" ? "gut" : st === "überfällig" ? "schlecht" : "offen"}">${st === "bezahlt" ? `bezahlt${z.bezahlt_am ? ` ${dat(z.bezahlt_am)}` : ""}` : st}</span>`; } },
|
||||
],
|
||||
summenTitel: "Summe", summen: (l) => ({ netto: euro(l.reduce((x, z) => x + Number(z.netto), 0)) }),
|
||||
zeilen, klick: (z) => { location.hash = `projekt-${z.projekt_id}-zahlungen`; },
|
||||
}));
|
||||
}
|
||||
|
||||
const ECK_OFFEN = "betrieb-eckdaten-offen";
|
||||
const STATUS: [string, string][] = [
|
||||
["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"],
|
||||
@@ -153,7 +181,6 @@ async function projekte(): Promise<void> {
|
||||
location.hash = `projekt-${p.id}`;
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||||
if (modulAn("angebote")) inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#angebote">Angebote</a>');
|
||||
const [zeilen, kontaktListe, zahlungen, prios] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte"), api<Zeile[]>("zahlungen"), api<PrioErgebnis[]>("prioritaeten")]);
|
||||
const prio = new Map(prios.map((x) => [x.id, x]));
|
||||
const prioRang = (z: Zeile) => { const x = prio.get(z.id); return x ? PRIOS.indexOf(x.prioritaet) + 1 : 9; };
|
||||
@@ -164,13 +191,33 @@ async function projekte(): Promise<void> {
|
||||
const offen = (z: Zeile) => z.umsatz_netto - abgerechnet(z);
|
||||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||||
const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i]));
|
||||
inhalt.appendChild(liste({
|
||||
// Schnellwahl über der Liste (UX-Prüfung, Henning 08.11.2026); die Wahl bleibt gespeichert
|
||||
const SCHNELL: [string, string, string[] | null][] = [["laufend", "Laufend", ["auftrag", "ausfuehrung", "abgerechnet"]], ["angebote", "Anfragen und Angebote", ["anfrage", "angebot"]],
|
||||
["gewaehrleistung", "Gewährleistung", ["gewaehrleistung"]], ["archiv", "Archiv", ["abgeschlossen"]], ["alle", "Alle", null]];
|
||||
let wahl = SCHNELL.find(([k]) => k === lies("betrieb-projekte-wahl"))?.[0] ?? "laufend";
|
||||
const chips = document.createElement("div");
|
||||
chips.className = "fb-chips projekt-schnell";
|
||||
inhalt.appendChild(chips);
|
||||
const platz = document.createElement("div");
|
||||
inhalt.appendChild(platz);
|
||||
const zeichne = () => {
|
||||
chips.innerHTML = SCHNELL.map(([k, t, st]) => `<button type="button" class="chip-wahl${k === wahl ? " an" : ""}" data-schnell="${k}">${t} <small>${st ? zeilen.filter((z) => st.includes(z.status)).length : zeilen.length}</small></button>`).join("");
|
||||
const st = SCHNELL.find(([k]) => k === wahl)![2];
|
||||
platz.replaceChildren(tabelle(st ? zeilen.filter((z) => st.includes(z.status)) : zeilen));
|
||||
};
|
||||
chips.onclick = (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-schnell]");
|
||||
if (!b) return;
|
||||
wahl = b.dataset.schnell!;
|
||||
merke("betrieb-projekte-wahl", wahl);
|
||||
zeichne();
|
||||
};
|
||||
const tabelle = (gewaehlt: Zeile[]) => liste({
|
||||
schluessel: "projekte", einheit: ["Projekt", "Projekte"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", text: (z) => z.bezeichnung, wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
|
||||
{ id: "nummer", titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||||
{ id: "nummer", titel: "Nummer", wert: (z) => `<span class="nowrap">${esc(z.nummer)}</span>`, text: (z) => z.nummer, klasse: "optional" },
|
||||
{ id: "name", titel: "Name", text: (z) => z.bezeichnung, wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter nur-schmal">${esc([z.nummer, ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · "))}</span>` },
|
||||
{ id: "kunde", titel: "Kunde", wert: (z) => esc(name[z.bauherr_id] ?? ""), klasse: "optional" },
|
||||
{ id: "ort", titel: "Ort", wert: (z) => esc(z.baustelle_ort ?? ""), klasse: "optional" },
|
||||
{ id: "status", titel: "Status", handy: "rechts", wert: (z) => etikett(z.status), sortWert: (z) => statusRang[z.status] ?? 99 },
|
||||
// Priorität A/B/C (Henning, 08.11.2026): Vorschlag des Programms, auf der Projektseite änderbar
|
||||
{ id: "prio", titel: "Priorität", handy: "links", wert: (z) => prioMarke(prio.get(z.id)), text: (z) => prio.get(z.id)?.prioritaet ?? "–", sortWert: prioRang },
|
||||
@@ -180,14 +227,15 @@ async function projekte(): Promise<void> {
|
||||
{ id: "kosten", titel: "Kosten", art: "zahl", wert: (z) => euro(kostenSumme(z)), sortWert: kostenSumme, klasse: "zahl optional" },
|
||||
{ id: "rohertrag", titel: "Rohertrag", art: "zahl", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), sortWert: (z) => z.umsatz_netto - kostenSumme(z), klasse: "zahl optional" },
|
||||
],
|
||||
zeilen, klick: (z) => (location.hash = `projekt-${z.id}`),
|
||||
zeilen: gewaehlt, klick: (z) => (location.hash = `projekt-${z.id}`),
|
||||
// Summenzeile über alle Zahlenspalten (Henning, 27.10.2026); bei Filter nur die gefilterten Projekte
|
||||
summenTitel: "Summe",
|
||||
summen: (l) => {
|
||||
const s = (f: (z: Zeile) => number) => euro(l.reduce((x, z) => x + f(z), 0));
|
||||
return { umsatz: s((z) => z.umsatz_netto), abgerechnet: s(abgerechnet), offen: s(offen), kosten: s(kostenSumme), rohertrag: s((z) => z.umsatz_netto - kostenSumme(z)) };
|
||||
},
|
||||
}));
|
||||
});
|
||||
zeichne();
|
||||
}
|
||||
|
||||
// ---------- Projektseite (P2), aufgebaut wie bei Plancraft ----------
|
||||
@@ -259,7 +307,23 @@ async function projektSeite(id: string): Promise<void> {
|
||||
${p.bauherr_id ? '<button class="verweis" data-a="rechnung-an">Rechnungsanschrift</button><div class="pj-rechnung-an" hidden></div>' : ""}</div>`;
|
||||
}
|
||||
|
||||
// UX-Prüfung (Henning 08.11.2026): zwei große Knöpfe am Handy; Anrufen geht zuerst an den Ansprechpartner „Baustelle“, sonst an den Kunden
|
||||
function handyAktionenHtml(): string {
|
||||
const bau = eigeneAp.find((a) => (a.zustaendig ?? []).includes("baustelle") && (kontakt[a.kontakt_id]?.mobil || kontakt[a.kontakt_id]?.telefon));
|
||||
const wen = bau ? kontakt[bau.kontakt_id] : kunde?.mobil || kunde?.telefon ? kunde : null;
|
||||
const nr = wen ? String(wen.mobil || wen.telefon) : "";
|
||||
const ort = ortZeile(p);
|
||||
const anrufen = nr
|
||||
? `<a class="handy-knopf" href="tel:${esc(nr.replace(/[^+\d]/g, ""))}"><b>Anrufen</b><small>${esc(wen!.name ?? "")}${bau ? " (Baustelle)" : ""}</small></a>`
|
||||
: `<span class="handy-knopf aus" aria-disabled="true"><b>Anrufen</b><small>${kunde ? "Keine Nummer beim Kunden" : "Kein Kunde eingetragen"}</small></span>`;
|
||||
const navi = ort
|
||||
? `<a class="handy-knopf" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ort)}" target="_blank" rel="noopener"><b>Navigation</b><small>${esc(ort)}</small></a>`
|
||||
: `<span class="handy-knopf aus" aria-disabled="true"><b>Navigation</b><small>Keine Baustellenadresse</small></span>`;
|
||||
return `<div class="handy-aktionen nur-handy">${anrufen}${navi}</div>`;
|
||||
}
|
||||
|
||||
inhalt.innerHTML = `${hinweisHtml()}
|
||||
<nav class="brotkrumen nur-pc" aria-label="Pfad"><a href="#projekte">Projekte</a> › ${esc(p.nummer)} ${esc(p.bezeichnung)}</nav>
|
||||
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
|
||||
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
|
||||
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
|
||||
@@ -267,16 +331,16 @@ async function projektSeite(id: string): Promise<void> {
|
||||
[["", `Priorität ${prio.vorschlag} (Vorschlag)`], ...PRIOS.map((x): [string, string] => [x, `Priorität ${PRIO_TEXT[x]}`])], prio.selbst ? prio.prioritaet : "")}</select>` : ""}
|
||||
<button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
|
||||
${prio ? `<p class="prio-grund">${esc(prioErklaerung(prio))}</p>` : ""}
|
||||
${kunde?.telefon || ortZeile(p) ? `<div class="handy-aktionen nur-handy">${kunde?.telefon ? `<a class="neben" href="tel:${esc(kunde.telefon)}">Anrufen</a>` : ""}${ortZeile(p) ? `<a class="neben" href="https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(ortZeile(p))}" target="_blank" rel="noopener">Navigation</a>` : ""}</div>` : ""}
|
||||
${handyAktionenHtml()}
|
||||
<nav class="handy-reiter nur-handy" aria-label="Bereiche">${([["ueberblick", "Überblick"], ["ablauf", "Ablauf"], ["geld", "Geld"], ["ablage", "Ablage"]] as const)
|
||||
.map(([r, titel]) => `<button data-hr="${r}">${titel}</button>`).join("")}</nav>
|
||||
<div class="projekt-raster">
|
||||
<div class="projekt-haupt">
|
||||
<section class="karte p-stand nur-handy"></section>
|
||||
<section class="karte p-ablauf nur-handy"></section>
|
||||
<section class="karte p-stand"></section>
|
||||
<section class="karte p-ablauf"></section>
|
||||
<section class="karte projekt-teile" id="p-oben"><div class="teile-kopf"><nav class="teile">
|
||||
<button data-oben="uebersicht">Übersicht</button><button data-oben="nachkalkulation">Nachkalkulation</button></nav></div><div class="oben-inhalt"></div></section>
|
||||
<section class="karte projekt-teile" id="p-unten"><div class="teile-kopf"><nav class="teile">${([["dokumente", "Dokumente"], ["berichte", "Berichte"], ["ablage", "Ablage"], ["zahlungen", "Zahlungsplan"]] as const)
|
||||
<section class="karte projekt-teile" id="p-unten"><div class="teile-kopf"><nav class="teile">${([["dokumente", "Dokumente"], ["berichte", "Bautagebuch"], ["ablage", "Ablage"], ["zahlungen", "Zahlungsplan"]] as const)
|
||||
.map(([t, titel]) => `<button data-teil="${t}">${titel}${t === "zahlungen" && eigeneZahlungen.length ? ` <small>${eigeneZahlungen.length}</small>` : ""}</button>`).join("")}</nav>
|
||||
<span id="teil-knopf"></span></div><div id="teil"></div></section>
|
||||
</div>
|
||||
@@ -302,6 +366,19 @@ async function projektSeite(id: string): Promise<void> {
|
||||
};
|
||||
const leer = (text: string) => Object.assign(document.createElement("p"), { className: "hinweis leer", textContent: text });
|
||||
|
||||
// „Fehlt noch“ (UX-Prüfung, Henning 08.11.2026): Baustelle, Beschreibung und Eckdaten in einer Kachel; fehlende Angaben als Links
|
||||
const fehltNochHtml = (adresse: string, mitAuftrag: boolean) => {
|
||||
const fehlt: string[] = [];
|
||||
if (!adresse) fehlt.push('<button class="verweis" data-a="bearbeiten">Baustellenadresse</button>');
|
||||
if (!p.notiz) fehlt.push('<div class="zelle-text" data-a="beschreibung"><button class="verweis">Beschreibung</button></div>');
|
||||
if (!mitAuftrag && !umsatz) fehlt.push('<button class="verweis" data-a="eck-zeigen">Auftragswert</button>');
|
||||
if (!mitAuftrag && !Number(p.soll_stunden)) fehlt.push('<button class="verweis" data-a="eck-zeigen">Soll-Stunden</button>');
|
||||
const da = [adresse ? `<p><a href="https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adresse)}" target="_blank" rel="noopener">${esc(p.baustelle_strasse ?? "")}<br>${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}</a></p>` : "",
|
||||
p.notiz ? `<div class="text zelle-text" data-a="beschreibung" title="Klicken zum Bearbeiten">${esc(p.notiz)}</div>` : ""].join("");
|
||||
return `<section class="kachel beschreibung fehlt-noch"><h3>${symbolKachel(fehlt.length ? "beschreibung" : "baustelle")}${fehlt.length ? "Fehlt noch" : "Baustelle"}</h3>
|
||||
${fehlt.length ? `<ul class="fehlt-liste">${fehlt.map((x) => `<li>${x}</li>`).join("")}</ul>` : ""}${da ? `<div class="${fehlt.length ? "fehlt-da" : ""}">${da}</div>` : ""}</section>`;
|
||||
};
|
||||
|
||||
// ---------- oben: Übersicht und Nachkalkulation ----------
|
||||
const zeigeOben = () => {
|
||||
oben.querySelectorAll<HTMLElement>("[data-oben]").forEach((b) => b.classList.toggle("aktiv", b.dataset.oben === projektOben));
|
||||
@@ -338,23 +415,14 @@ async function projektSeite(id: string): Promise<void> {
|
||||
ziel.innerHTML = `<div class="uebersicht-kacheln${mitAuftrag ? "" : " mit-eckdaten"}">
|
||||
${kachel("stunden", "Arbeitsstunden", `<div class="stunden"><div><p class="gross">${stundenText(ist)}</p><p>/ ${soll ? stundenText(soll) : "0:00 Std."}</p></div>
|
||||
<svg class="ring" viewBox="0 0 36 36" role="img" aria-label="${anteil === null ? "keine Stunden geplant" : `${anteil} Prozent verbraucht`}"><circle cx="18" cy="18" r="15.5"/>${anteil ? `<circle class="wert" cx="18" cy="18" r="15.5" pathLength="100" stroke-dasharray="${Math.min(100, anteil)} 100"/>` : ""}<text x="18" y="21.5">${anteil === null ? "– %" : `${anteil} %`}</text></svg></div>`)}
|
||||
${!mitAuftrag ? "" : kachel("auftragswert", "Auftragswert", `<p><button class="verweis gross" data-a="auftragswert" title="Auftragswert ändern">${umsatz ? euro(umsatz) : "eintragen"}</button> <small class="hinweis">netto</small></p>
|
||||
<p class="hinweis">${eigeneZahlungen.length ? `${eigeneZahlungen.length} ${eigeneZahlungen.length === 1 ? "Rate" : "Raten"} im <button class="verweis" data-teil="zahlungen">Zahlungsplan</button>${p.zahlungsplan === "auto" ? ", passen sich an" : ""}` : "Mit dem Auftragswert und Terminen entsteht der Zahlungsplan."}</p>`)}
|
||||
${kachel("kunde", "Kunde", p.status === "intern" && !kunde
|
||||
? '<p class="gross">Intern</p><p class="hinweis">Eigener Betrieb, kein Kunde</p>'
|
||||
: kunde
|
||||
? `<p><a href="#kontakt-${esc(kunde.id)}" class="gross">${esc(kunde.name)}</a>${kunde.art ? ` <span class="kt-art">${esc(ART_KURZ[kunde.art] ?? "")}</span>` : kunde.firma ? `<br>${esc(kunde.firma)}` : ""}</p>
|
||||
<p class="hinweis">${[kunde.telefon && `<a href="tel:${esc(kunde.telefon)}">${esc(kunde.telefon)}</a>`, kunde.email && esc(kunde.email)].filter(Boolean).join("<br>")}</p>${ansprechpartnerHtml()}`
|
||||
: `<p><button class="verweis" data-a="bearbeiten">Kunde zuordnen</button></p>${ansprechpartnerHtml()}`)}
|
||||
<section class="kachel beschreibung"><h3>${symbolKachel("beschreibung")}Beschreibung</h3>
|
||||
<div class="text zelle-text" data-a="beschreibung" title="Klicken zum Bearbeiten">${p.notiz ? esc(p.notiz) : '<span class="hinweis">Keine Beschreibung. Klicken zum Schreiben.</span>'}</div></section>
|
||||
${kachel("zeitraum", "Zeitraum", anfang
|
||||
? `<p class="gross">${dat(anfang)} – ${dat(ende)}</p><p class="hinweis">${vorgaenge.length} ${vorgaenge.length === 1 ? "Vorgang" : "Vorgänge"} in ${abschnitte.length} ${abschnitte.length === 1 ? "Abschnitt" : "Abschnitten"} · <a href="#terminplan">Terminplan</a></p>`
|
||||
: '<p><a href="#terminplan">Abschnitt im Terminplan hinzufügen</a></p>')}
|
||||
${kachel("baustelle", "Baustelle", adresse
|
||||
? `<p><a class="gross" href="https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adresse)}" target="_blank" rel="noopener">${esc(p.baustelle_strasse ?? "")}<br>${esc([p.baustelle_plz, p.baustelle_ort].filter(Boolean).join(" "))}</a></p>`
|
||||
: '<p><button class="verweis" data-a="bearbeiten">Adresse eintragen</button></p>')}
|
||||
${eckdaten}
|
||||
${fehltNochHtml(adresse, mitAuftrag)}
|
||||
${eckOffen ? eckdaten : ""}
|
||||
</div>`;
|
||||
ziel.onchange = async (ev) => {
|
||||
const e = (ev.target as HTMLElement).closest<HTMLInputElement>("[data-e]");
|
||||
@@ -434,9 +502,9 @@ async function projektSeite(id: string): Promise<void> {
|
||||
teil.innerHTML = `${modulAn("angebote") ? `<h3 class="gruppe">Angebote und weitere Dokumente</h3>${angeboteHtml(angebote)}` : ""}
|
||||
<h3 class="gruppe">Rechnungen</h3>${rechnungen.length ? `<ul class="dokumente">${rechnungen.map((z) => {
|
||||
const ueberfaellig = z.status === "gestellt" && z.termin < heute();
|
||||
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
|
||||
<span class="marken"><span class="marke ${z.status === "bezahlt" ? "gut" : ueberfaellig ? "schlecht" : "offen"}">${z.status === "bezahlt" ? `Bezahlt${z.bezahlt_am ? ` ${dat(z.bezahlt_am)}` : ""}` : ueberfaellig ? "Überfällig" : "Offen"}</span>
|
||||
<span class="marke grau" title="Festgeschrieben, nicht mehr änderbar">Freigegeben</span><span class="marke dunkel">${esc(art(z))}</span></span></button></li>`;
|
||||
// nur eine Marke (UX-Prüfung, 08.11.2026): bezahlt, überfällig oder gestellt; die Art steht in der Unterzeile
|
||||
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${esc(art(z))} · ${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
|
||||
<span class="marken"><span class="marke ${z.status === "bezahlt" ? "gut" : ueberfaellig ? "schlecht" : "offen"}">${z.status === "bezahlt" ? `bezahlt${z.bezahlt_am ? ` ${dat(z.bezahlt_am)}` : ""}` : ueberfaellig ? "überfällig" : "gestellt"}</span></span></button></li>`;
|
||||
}).join("")}</ul>` : '<p class="hinweis leer">Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.</p>'}`;
|
||||
} else if (projektTeil === "berichte") {
|
||||
teil.innerHTML = `<p class="hinweis leer">Noch keine Berichte.</p>
|
||||
@@ -532,7 +600,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const info = document.createElement("div");
|
||||
info.className = "vorschlag";
|
||||
if (!eigeneZahlungen.length && p.zahlungsplan !== "fest") {
|
||||
info.innerHTML = `<p>Der Zahlungsplan entsteht automatisch, sobald der Auftragswert eingetragen ist und das Projekt Termine im Terminplan hat: 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten, 10 % Schlussrechnung nach Abnahme.</p>
|
||||
info.innerHTML = `<p>Der Zahlungsplan entsteht automatisch, sobald der Auftragswert eingetragen ist und das Projekt Termine im Terminplan hat. Wie viele Raten es werden, hängt vom Auftragswert ab (Einstellungen › Vorlagen).</p>
|
||||
${umsatz ? "" : '<button class="neben" data-a="bearbeiten">Auftragswert eintragen</button>'}`;
|
||||
} else if (!eigeneZahlungen.length) {
|
||||
info.innerHTML = `<p>Noch kein Zahlungsplan. Der Standard ist 30 % Anzahlung bei Auftrag, 40 % nach Abbund und Richten, 20 % nach den Restarbeiten und 10 % Schlussrechnung nach Abnahme.</p>
|
||||
@@ -653,20 +721,32 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}
|
||||
|
||||
// ---------- rechts: offene Aufgaben statt Chat ----------
|
||||
// fest auf „offen“, ohne Filter (UX-Prüfung, Henning 08.11.2026); erledigte auf Wunsch darunter
|
||||
let erledigteZeigen = false;
|
||||
const zeigeAufgaben = () => {
|
||||
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length;
|
||||
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).sort((a, b) => (a.faellig_am ?? "9999").localeCompare(b.faellig_am ?? "9999"));
|
||||
const fertig = eigeneAufgaben.filter((a) => a.erledigt_am);
|
||||
const li = (a: Zeile) => `<li class="aufgabe-2${a.erledigt_am ? " erledigt" : ""}"><label class="haken"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt: ${esc(a.text)}"${a.erledigt_am ? " checked" : ""}></label>
|
||||
<button class="a-text verweis-zeile" data-aufgabe="${a.id}">${a.erledigt_am ? `<s>${esc(a.text)}</s>` : `<b>${esc(a.text)}</b>`}${a.kategorie_id && aufgabenDat.namen.kategorie[a.kategorie_id] ? `<span class="kategorie">${esc(aufgabenDat.namen.kategorie[a.kategorie_id])}</span>` : ""}</button>
|
||||
<span class="a-datum${!a.erledigt_am && a.faellig_am && a.faellig_am < heute() ? " ueber" : ""}">${a.faellig_am ? dat(a.faellig_am).slice(0, 6) : ""}</span></li>`;
|
||||
const seite = inhalt.querySelector<HTMLElement>(".projekt-aufgaben")!;
|
||||
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>`;
|
||||
seite.append(aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true));
|
||||
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen.length}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>
|
||||
${offen.length ? `<ul class="aufgaben">${offen.map(li).join("")}</ul>` : `<p class="hinweis">Keine offenen Aufgaben${fertig.length && !erledigteZeigen ? "" : "."}</p>`}
|
||||
${fertig.length ? `<p class="hinweis"><button class="verweis" data-a="erledigte">${erledigteZeigen ? "erledigte ausblenden" : `${fertig.length} erledigte anzeigen`}</button></p>` : ""}
|
||||
${erledigteZeigen && fertig.length ? `<ul class="aufgaben">${fertig.map(li).join("")}</ul>` : ""}`;
|
||||
};
|
||||
|
||||
// ---------- Handy: Stand und Ablauf ----------
|
||||
const raster = inhalt.querySelector<HTMLElement>(".projekt-raster")!;
|
||||
const bezahlt = eigeneZahlungen.filter((z) => z.status === "bezahlt").reduce((s, z) => s + z.netto, 0);
|
||||
inhalt.querySelector<HTMLElement>(".p-stand")!.innerHTML = `<h3>Stand</h3><div class="stand-zahlen">
|
||||
<div><small>Auftragswert</small><b>${euro(umsatz)}</b></div><div><small>bezahlt</small><b class="gut">${euro(bezahlt)}</b></div><div><small>offen</small><b>${euro(Math.max(0, umsatz - bezahlt))}</b></div></div>`;
|
||||
const roStand = rohertragVon(eckVon(p));
|
||||
const mitAuftragStand = angebote.some((a) => a.status === "angenommen");
|
||||
inhalt.querySelector<HTMLElement>(".p-stand")!.innerHTML = `<h3>Stand${mitAuftragStand ? "" : ' <button class="verweis" data-a="eck-zeigen">Eckdaten ändern</button>'}</h3><div class="stand-zahlen">
|
||||
<div><small>Auftragswert</small><b>${mitAuftragStand ? `<button class="verweis" data-a="auftragswert" title="Auftragswert ändern">${euro(umsatz)}</button>` : euro(umsatz)}</b></div>
|
||||
<div><small>bezahlt</small><b class="gut">${euro(bezahlt)}</b></div><div><small>offen</small><b>${euro(Math.max(0, umsatz - bezahlt))}</b></div>
|
||||
<div class="stand-ro"><small>Rohertrag</small><b class="${roStand.euro < 0 ? "schlecht" : "gut"}">${euro(roStand.euro)}</b>${roStand.prozent === null ? "" : `<small>${zahlText(Math.round(roStand.prozent * 10) / 10)} %</small>`}</div></div>`;
|
||||
const zeitraumText = (a?: string, e?: string) => (!a ? "ohne Termin" : a === e ? dat(a) : `${dat(a)} – ${dat(e)}`);
|
||||
inhalt.querySelector<HTMLElement>(".p-ablauf")!.innerHTML = `<h3>Abschnitte <a href="#terminplan">Terminplan</a></h3>${abschnitte.length ? `<ul class="ablauf-liste">${abschnitte.map((ab: Zeile) => {
|
||||
inhalt.querySelector<HTMLElement>(".p-ablauf")!.innerHTML = `<h3>Abschnitte <span class="p-ablauf-links"><button class="verweis" data-a="tp-projekt">im Terminplan zeigen</button><button class="verweis nur-pc" data-a="liqui-projekt">in Liquidität zeigen</button></span></h3>${abschnitte.length ? `<ul class="ablauf-liste">${abschnitte.map((ab: Zeile) => {
|
||||
const vs = vorgaenge.filter((v: Zeile) => v.abschnitt_id === ab.id);
|
||||
const bs = plan.besetzungen.filter((b: Zeile) => vs.some((v: Zeile) => v.id === b.vorgang_id));
|
||||
const leute = [...new Set(bs.map((b: Zeile) => b.anzeige as string).filter(Boolean))].join(", ");
|
||||
@@ -713,6 +793,16 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const aid = ziel.closest<HTMLElement>("[data-aufgabe]")?.dataset.aufgabe;
|
||||
if (aid) return (await bearbeiten("aufgaben", "Aufgabe bearbeiten", aufgabenDat.felder, eigeneAufgaben.find((a) => a.id === aid)!)) && neuLaden();
|
||||
const a = ziel.closest<HTMLElement>("[data-a]")?.dataset.a;
|
||||
if (a === "erledigte") { erledigteZeigen = !erledigteZeigen; zeigeAufgaben(); return; }
|
||||
if (a === "eck-zeigen") { merke(ECK_OFFEN, "1"); projektOben = "uebersicht"; zeigeOben(); inhalt.querySelector(".kachel.eckdaten input")?.scrollIntoView({ block: "center" }); return; }
|
||||
if (a === "tp-projekt") {
|
||||
// Terminplan nur mit diesem Projekt: alle anderen im Projektfilter ausblenden
|
||||
const an = gespeicherteAnsicht("terminplan");
|
||||
ansichtMerken("terminplan", { ...an, filter: { ...an.filter, projekt: (plan.projekte as Zeile[]).map((x) => x.id as string).filter((x) => x !== id) } });
|
||||
location.hash = "terminplan";
|
||||
return;
|
||||
}
|
||||
if (a === "liqui-projekt") { liquiNurProjekt(p.nummer); location.hash = "liquiditaet"; return; }
|
||||
if (a === "eck-auf") {
|
||||
const k = ziel.closest<HTMLElement>(".kachel.eckdaten")!;
|
||||
const offen = k.classList.toggle("zu") === false;
|
||||
@@ -1003,32 +1093,52 @@ async function uebersicht(): Promise<void> {
|
||||
const aufgabeLi = (a: Zeile) => {
|
||||
const unter = [a.projekt_nummer ? `${a.projekt_nummer} ${a.projekt_name ?? ""}`.trim() : "", a.kontakt_name ?? ""].filter(Boolean).map(esc).join(" · ");
|
||||
const ueber = a.faellig_am && a.faellig_am < u.heute;
|
||||
return `<li class="aufgabe-2"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt: ${esc(a.text)}">
|
||||
return `<li class="aufgabe-2"><label class="haken"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt: ${esc(a.text)}"></label>
|
||||
<span class="a-text"><b>${esc(a.text)}</b>${unter ? `<small>${unter}</small>` : ""}${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</span>` : ""}</span>
|
||||
<span class="a-datum${ueber ? " ueber" : ""}">${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}</span></li>`;
|
||||
};
|
||||
const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `<div class="gruppe${warn && liste.length ? " warn" : ""}">
|
||||
<h3>${titel} <b>${liste.length}</b></h3>${liste.length ? `<ul class="aufgaben">${liste.map(aufgabeLi).join("")}</ul>` : `<p class="hinweis">${leer}</p>`}</div>`;
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§", angebot: "✉" };
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§", angebot: "✉", verzug: "▲", zahlung: "€" };
|
||||
|
||||
// am Handy oben die Aufgaben-Zahlen; Warnungen und Liquidität gibt es am Handy nicht (Henning, 22.10.2026)
|
||||
const heuteFaellig = u.aufgaben.dieseWoche.filter((a: Zeile) => a.faellig_am === u.heute).length;
|
||||
const liegen = u.aufgaben.ueberfaellig.length;
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="handy-band nur-handy"><a href="#aufgaben"><b>${heuteFaellig}</b><small>Aufgaben heute</small></a>
|
||||
<a href="#aufgaben"><b class="${liegen ? "warn" : ""}">${liegen}</b><small>liegen geblieben</small></a></div>`);
|
||||
// Zahlen oben (UX-Prüfung, Henning 08.11.2026): nächster Arbeitstag, überfällig, brennt, Geld der nächsten 4 Wochen
|
||||
const en = u.einsatzNaechster as Zeile | null;
|
||||
const tagWort = en ? (en.tag === plusTage(u.heute, 1) ? "morgen" : `${WOCHENTAG[wtag(en.tag)]} ${dat(en.tag).slice(0, 6)}`) : "";
|
||||
const ueber = u.aufgaben.ueberfaellig as Zeile[];
|
||||
const brennt = u.brennt as Zeile[];
|
||||
const geld = u.geld as Zeile;
|
||||
const ganz = (c: number) => `${c > 0 ? "+" : ""}${formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €")}`;
|
||||
const bisText = dat(geld.bis).slice(0, 6);
|
||||
const ohneKonto = mitKontostand && u.brennt.some((b: Zeile) => b.art === "kontostand");
|
||||
const anzahlText = (n: number, eins: string, mehr: string) => `${n} ${n === 1 ? eins : mehr}`;
|
||||
const verzug = brennt.filter((b) => b.art === "verzug").length, offen = brennt.filter((b) => b.art === "zahlung").length;
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="handy-band nur-handy">
|
||||
<a href="#terminplan"><b>${en?.anzahl ?? 0}</b><small>${en && en.anzahl !== 1 ? "Einsätze" : "Einsatz"} ${esc(tagWort || "morgen")}</small></a>
|
||||
<a href="#aufgaben"><b class="${ueber.length ? "warn" : ""}">${ueber.length}</b><small>überfällig</small></a>
|
||||
<a href="#liquiditaet"><b class="${geld.betrag < 0 ? "warn" : "gut"}">${ganz(geld.betrag)}</b><small>Geld bis ${bisText}</small></a></div>
|
||||
<div class="start-zahlen nur-pc">
|
||||
<a href="#terminplan"><small>${en ? `${tagWort === "morgen" ? "Morgen, " : "Nächster Arbeitstag, "}${WOCHENTAG[wtag(en.tag)]} ${dat(en.tag).slice(0, 6)}` : "Nächster Arbeitstag"}</small>
|
||||
<b>${anzahlText(en?.anzahl ?? 0, "Einsatz", "Einsätze")}</b><span>${en?.was.length ? esc(en.was.slice(0, 2).join(", ")) + (en.was.length > 2 ? " …" : "") : "nichts eingeplant"}</span></a>
|
||||
<a href="#aufgaben" class="${ueber.length ? "warn" : ""}"><small>Überfällig</small><b>${anzahlText(ueber.length, "Aufgabe", "Aufgaben")}</b>
|
||||
<span>${ueber[0]?.faellig_am ? `älteste seit ${WOCHENTAG[wtag(ueber[0].faellig_am)]} ${dat(ueber[0].faellig_am).slice(0, 6)}` : "nichts liegen geblieben"}</span></a>
|
||||
<a href="#start-warnungen" class="${brennt.length ? "warn" : ""}"><small>Brennt</small><b>${brennt.length}</b>
|
||||
<span>${[verzug ? anzahlText(verzug, "Vorgang im Verzug", "Vorgänge im Verzug") : "", offen ? anzahlText(offen, "Zahlung überfällig", "Zahlungen überfällig") : "", ohneKonto ? "Kontostand fehlt" : ""].filter(Boolean).join(" · ") || "nichts"}</span></a>
|
||||
<a href="#liquiditaet" class="${geld.betrag < 0 ? "warn" : "gut"}"><small>Geld bis ${bisText}</small><b>${ganz(geld.betrag)}</b><span>Überschuss${ohneKonto ? " · Kontostand fehlt noch" : " 4 Wochen"}</span></a></div>`);
|
||||
const brenntLi = (w: Zeile) => `<li class="${w.art}"><a href="#${w.ziel}"><span class="symbol">${SYMBOL[w.art] ?? "!"}</span><span class="w-text">${esc(w.text)}${w.unter ? `<small>${esc(w.unter)}</small>` : ""}</span></a></li>`;
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "start";
|
||||
raster.innerHTML = `
|
||||
${brennt.length ? `<section class="karte start-brennt nur-handy"><div class="karte-kopf"><h2>Brennt</h2></div><ul class="warnungen brennt">${brennt.map(brenntLi).join("")}</ul></section>` : ""}
|
||||
<section class="karte start-aufgaben"><div class="karte-kopf"><h2>Aufgaben</h2><button class="neben" data-a="neue-aufgabe">+ Aufgabe</button></div>
|
||||
${gruppe("Noch nicht abgearbeitet", u.aufgaben.ueberfaellig, "Nichts liegen geblieben.", true)}
|
||||
${gruppe(`Diese Woche`, u.aufgaben.dieseWoche, "Keine Aufgaben mehr in dieser Woche.")}
|
||||
${gruppe("Langfristig", u.aufgaben.langfristig, "Keine langfristigen Aufgaben.")}</section>
|
||||
${gruppe("Überfällig", ueber, "Nichts überfällig.", true)}
|
||||
${gruppe("Nächste 7 Tage", u.aufgaben.naechste7, "Keine Aufgaben in den nächsten 7 Tagen.")}
|
||||
${gruppe("Später", u.aufgaben.spaeter, "Keine späteren Aufgaben.")}</section>
|
||||
<section class="karte start-warnungen nur-pc" id="start-warnungen"><div class="karte-kopf"><h2>Warnungen</h2></div>
|
||||
${u.warnungen.length ? `<ul class="warnungen">${u.warnungen.map((w: Zeile) => `<li class="${w.art}"><a href="#${w.ziel}"><span class="symbol">${SYMBOL[w.art] ?? "!"}</span>${esc(w.text)}</a></li>`).join("")}</ul>`
|
||||
${brennt.length || u.warnungen.length ? `<ul class="warnungen">${[...brennt, ...u.warnungen].map(brenntLi).join("")}</ul>`
|
||||
: '<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)}<div class="einsatz-liste"></div></section>
|
||||
<section class="karte breit nur-pc start-liqui"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
|
||||
${mitKontostand && u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : flussKachelnHtml(u.fluss, "4 Wochen", false)}
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz, u.heute)}<div class="einsatz-liste"></div></section>
|
||||
<section class="karte breit nur-pc start-liqui"><div class="karte-kopf"><h2>Geld · ${dat(geld.von).slice(0, 6)}–${bisText} <small class="hinweis">gleiche Rechnung wie die Liquidität</small></h2><a class="neben" href="#liquiditaet">Details</a></div>
|
||||
${mitKontostand && u.liquiLage ? lageKopfHtml(u.liquiLage, "4 Wochen") : ""}${flussKachelnHtml([geld], "4 Wochen", true)}
|
||||
<div class="fluss-platz"></div>
|
||||
${u.jahresplan ? jahresplanZeile(u.jahresplan) : ""}</section>`;
|
||||
inhalt.appendChild(raster);
|
||||
@@ -1037,6 +1147,10 @@ async function uebersicht(): Promise<void> {
|
||||
const platz = raster.querySelector<HTMLElement>(".fluss-platz")!;
|
||||
platz.innerHTML = flussSvg(u.fluss, platz.clientWidth || 900, false);
|
||||
|
||||
raster.addEventListener("click", (ev) => {
|
||||
const t = (ev.target as HTMLElement).closest<HTMLElement>(".einsatz-tabelle [data-wmw-v]");
|
||||
if (t) { vorgangImTerminplan(t.dataset.wmwV!, t.dataset.wmwD!); location.hash = "#terminplan"; }
|
||||
});
|
||||
raster.addEventListener("change", async (ev) => {
|
||||
const box = ev.target as HTMLInputElement;
|
||||
if (!box.dataset.erledigt) return;
|
||||
@@ -1057,14 +1171,17 @@ function jahresplanZeile(j: Zeile): string {
|
||||
<span class="jp-balken" role="img" aria-label="${anteil} % beauftragt"><i style="width:${anteil}%"></i></span></div>`;
|
||||
}
|
||||
|
||||
function einsatzHtml(e: Zeile): string {
|
||||
function einsatzHtml(e: Zeile, heuteD: string): string {
|
||||
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<p class="hinweis">In den nächsten zwei Wochen ist nichts eingeplant.</p>';
|
||||
const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
|
||||
const kopf = e.tage.map((d: string, i: number) => `<th class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}</th>`).join("");
|
||||
// UX-Prüfung (08.11.2026): der nächste Arbeitstag hervorgehoben, ein freigegebener Freitag als „Reserve“
|
||||
const naechster = (e.tage as string[]).find((d) => d > heuteD);
|
||||
const merk = (d: string) => (d === heuteD ? "heute" : d === naechster ? (d === plusTage(heuteD, 1) ? "morgen" : "nächster Tag") : wtag(d) === 5 ? "Reserve" : "");
|
||||
const kopf = e.tage.map((d: string, i: number) => `<th class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}${d === naechster ? " morgen" : ""}${wtag(d) === 5 ? " freitag" : ""}">${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}${merk(d) ? `<small>${merk(d)}</small>` : ""}</th>`).join("");
|
||||
const neueWoche = (i: number) => i > 0 && wtag(e.tage[i]) < wtag(e.tage[i - 1]);
|
||||
// Balken in der Projektfarbe, zweizeilig: oben klein Projektnummer und Titel, unten der Vorgang (Henning, 23.10.2026)
|
||||
const balken = (x: Zeile) => `<span class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" style="--pf:${esc(x.farbe ?? "#1d5fa8")}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}">
|
||||
<small>${esc(x.projekt)}</small><b>${esc(x.name)}</b></span>`;
|
||||
const balken = (x: Zeile, d: string) => `<button type="button" class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" style="--pf:${esc(x.farbe ?? "#1d5fa8")}" data-wmw-v="${esc(x.vorgang)}" data-wmw-d="${d}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""} · im Terminplan öffnen">
|
||||
<small>${esc(x.projekt)}</small><b>${esc(x.name)}</b></button>`;
|
||||
// derselbe Vorgang an Folgetagen derselben Woche wird ein durchgehender Balken
|
||||
const allein = (t: Zeile[] | undefined) => (t && t.length === 1 ? t[0]! : null);
|
||||
const zeileHtml = (z: Zeile) => {
|
||||
@@ -1073,7 +1190,7 @@ function einsatzHtml(e: Zeile): string {
|
||||
const x = allein(z.tage[i]);
|
||||
let n = 1;
|
||||
while (x && i + n < z.tage.length && !neueWoche(i + n) && allein(z.tage[i + n])?.vorgang === x.vorgang && allein(z.tage[i + n])?.vorgemerkt === x.vorgemerkt) n++;
|
||||
zellen.push(`<td class="${neueWoche(i) ? "neue-woche" : ""}"${n > 1 ? ` colspan="${n}"` : ""}>${(z.tage[i] as Zeile[]).map(balken).join("")}</td>`);
|
||||
zellen.push(`<td class="${neueWoche(i) ? "neue-woche" : ""}${e.tage[i] === naechster ? " morgen" : ""}"${n > 1 ? ` colspan="${n}"` : ""}>${(z.tage[i] as Zeile[]).map((x) => balken(x, e.tage[i])).join("")}</td>`);
|
||||
i += n - 1;
|
||||
}
|
||||
return `<tr class="${z.wer ? "" : "ohne"}"><th>${esc(z.anzeige)}</th>${zellen.join("")}</tr>`;
|
||||
@@ -1321,9 +1438,59 @@ function moduleSchalter(e: Zeile): void {
|
||||
/** Testversion im Browser (demo/): speichert anders und kennt keine Kalender-Abos */
|
||||
const testversion = (globalThis as { betriebTestversion?: { sichern(): Promise<string> } }).betriebTestversion;
|
||||
|
||||
async function daten(): Promise<void> {
|
||||
seite("Daten und Einstellungen");
|
||||
// Einstellungen mit Reitern (UX-Prüfung, Henning 08.11.2026)
|
||||
type EinstTeil = "benutzer" | "vorlagen" | "daten" | "programmteile" | "anbindungen";
|
||||
const EINST_REITER: [EinstTeil, string, string][] = [["benutzer", "Benutzer", "benutzer"], ["vorlagen", "Vorlagen (Aufgaben, Zahlungsplan, Angebot)", "einstellungen-vorlagen"],
|
||||
["daten", "Daten und Sicherung", "daten"], ["programmteile", "Programmteile", "einstellungen-programmteile"], ["anbindungen", "Anbindungen (Nextcloud, Outlook, Kontakte)", "einstellungen-anbindungen"]];
|
||||
function einstellungsReiter(aktiv: EinstTeil): void {
|
||||
const kopf = inhalt.querySelector(".kopf");
|
||||
kopf?.querySelector("h1")?.replaceChildren("Einstellungen");
|
||||
kopf?.insertAdjacentHTML("afterend", `<nav class="einst-reiter" aria-label="Einstellungen">${EINST_REITER
|
||||
.map(([t, titel, ziel]) => `<a href="#${ziel}" class="${t === aktiv ? "aktiv" : ""}"${t === aktiv ? ' aria-current="page"' : ""}>${titel}</a>`).join("")}</nav>`);
|
||||
}
|
||||
async function einstellungenMit(teil: EinstTeil, f: () => Promise<void>): Promise<void> {
|
||||
await f();
|
||||
einstellungsReiter(teil);
|
||||
}
|
||||
/** eigener Knopf statt des englischen „Choose File“ */
|
||||
const dateiWahl = (id: string, accept: string) => `<p class="datei-wahl"><input type="file" id="${id}" accept="${accept}" hidden>
|
||||
<button type="button" class="neben" data-datei="${id}">Datei wählen …</button></p>`;
|
||||
|
||||
async function daten(teil: EinstTeil = "daten"): Promise<void> {
|
||||
seite("Einstellungen");
|
||||
einstellungsReiter(teil);
|
||||
const e = await api<Zeile>("einstellungen");
|
||||
inhalt.onclick = (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-datei]");
|
||||
if (b) document.getElementById(b.dataset.datei!)?.click();
|
||||
};
|
||||
if (teil === "vorlagen") {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Zahlungsplan nach Auftragswert</h2>
|
||||
<p class="hinweis">Neue Projekte bekommen die Raten der Stufe, die zum Auftragswert (netto) passt, je mit ${Number(e.zahlungsziele?.kundenTage ?? 14)} Tagen Zahlungsfrist. Die letzte Rate ist die Schlussrechnung und bekommt den Rest. Im Projekt unter Zahlungsplan änderbar.</p><div id="einst-zp"></div>`);
|
||||
zahlungsStaffelEditor(e);
|
||||
if (modulAn("angebote")) {
|
||||
inhalt.insertAdjacentHTML("beforeend", '<h2>Angebot: Kalkulation, Einleitung und Schlusstext</h2><p id="einst-kalk"></p>');
|
||||
angebotsVorgaben(e);
|
||||
}
|
||||
await vorlageEditor(e);
|
||||
return;
|
||||
}
|
||||
if (teil === "programmteile") {
|
||||
inhalt.insertAdjacentHTML("beforeend", '<h2>Programmteile</h2><div id="module"></div><h2>Grundwerte</h2><p class="hinweis">Kontostand, Zahlungsfristen, Umsatzsteuer und Arbeitszeit.</p><p id="einst-grund"></p>');
|
||||
moduleSchalter(e);
|
||||
grundwerte(e);
|
||||
return;
|
||||
}
|
||||
if (teil === "anbindungen") {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Nextcloud (Projektordner)</h2><div id="nextcloud"></div>
|
||||
<h2>Kontakte mit dem Handy abgleichen</h2><div id="kontakte-abgleich"></div>
|
||||
<h2>Kalender in Outlook</h2><div id="kalender"></div>`);
|
||||
if (testversion) document.getElementById("kalender")!.innerHTML = `<p class="hinweis">Die Kalender-Abos für Outlook funktionieren erst auf dem Server.</p>`;
|
||||
else kalenderLinks(e.kalenderToken);
|
||||
void nextcloudZugang();
|
||||
void kontakteAbgleich();
|
||||
return;
|
||||
}
|
||||
inhalt.insertAdjacentHTML("beforeend", `
|
||||
${testversion
|
||||
? `<p><button class="neben" id="sichern">Kompletten Stand als Datei sichern</button> <span id="sichern-ergebnis"></span></p>
|
||||
@@ -1332,31 +1499,18 @@ async function daten(): Promise<void> {
|
||||
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert.</p>`}
|
||||
<h2>Sicherung einspielen</h2>
|
||||
<p class="hinweis">Sicherungsdatei aus diesem Programm wählen (betrieb-….json), zum Beispiel aus der Testversion. Geht nur, solange noch nichts erfasst ist.</p>
|
||||
<p><input type="file" id="stand-datei" accept=".json,application/json"></p>
|
||||
${dateiWahl("stand-datei", ".json,application/json")}
|
||||
<div id="stand-ergebnis"></div>
|
||||
<h2>Übernahme aus dem Projektplaner V70</h2>
|
||||
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
|
||||
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
|
||||
<div id="v70-ergebnis"></div>
|
||||
<h2>Programmteile</h2>
|
||||
<div id="module"></div>
|
||||
<h2>Nextcloud (Projektordner)</h2>
|
||||
<div id="nextcloud"></div>
|
||||
<h2>Kontakte mit dem Handy abgleichen</h2>
|
||||
<div id="kontakte-abgleich"></div>
|
||||
<h2>Kalender in Outlook</h2>
|
||||
<div id="kalender"></div>
|
||||
<h2>Einstellungen</h2>`);
|
||||
${dateiWahl("v70-datei", ".json,application/json")}
|
||||
<div id="v70-ergebnis"></div>`);
|
||||
if (testversion) {
|
||||
document.getElementById("kalender")!.innerHTML = `<p class="hinweis">Die Kalender-Abos für Outlook funktionieren erst auf dem Server.</p>`;
|
||||
const knopf = document.getElementById("sichern")!, ergebnis = document.getElementById("sichern-ergebnis")!;
|
||||
knopf.onclick = async () => {
|
||||
try { ergebnis.textContent = await testversion.sichern(); } catch (err) { ergebnis.textContent = (err as Error).message; }
|
||||
};
|
||||
} else kalenderLinks(e.kalenderToken);
|
||||
moduleSchalter(e);
|
||||
void nextcloudZugang();
|
||||
void kontakteAbgleich();
|
||||
}
|
||||
const stand = document.getElementById("stand-datei") as HTMLInputElement;
|
||||
stand.onchange = async () => {
|
||||
const f = stand.files?.[0];
|
||||
@@ -1384,6 +1538,9 @@ async function daten(): Promise<void> {
|
||||
}
|
||||
datei.value = "";
|
||||
};
|
||||
}
|
||||
|
||||
function grundwerte(e: Zeile): void {
|
||||
const felder: Feld[] = [
|
||||
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
|
||||
{ name: "kundenTage", titel: "Zahlungsfrist Kunden (Kalendertage)", art: "zahl", hilfe: "Vorschlag für jede neue Rate im Zahlungsplan; je Rate änderbar." },
|
||||
@@ -1408,9 +1565,91 @@ async function daten(): Promise<void> {
|
||||
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
|
||||
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
|
||||
});
|
||||
daten();
|
||||
void daten("programmteile");
|
||||
};
|
||||
inhalt.appendChild(knopf);
|
||||
document.getElementById("einst-grund")!.appendChild(knopf);
|
||||
}
|
||||
|
||||
// Zahlungsplan nach Auftragswert (Henning, 09.11.2026): Stufen mit Grenze und Raten, gespeichert in den Einstellungen
|
||||
const RATEN_ZIEL: [RatenZiel, string][] = [["auftrag", "bei Auftrag"], ["richten", "nach Abbund und Richten"], ["rest", "nach den Restarbeiten"], ["schluss", "nach der Abnahme"]];
|
||||
function zahlungsStaffelEditor(e: Zeile): void {
|
||||
const ort = document.getElementById("einst-zp");
|
||||
if (!ort) return;
|
||||
let stufen: ZahlungsStufe[] = structuredClone((e.zahlungsStaffel as ZahlungsStufe[] | undefined) ?? STANDARD_STAFFEL).sort((a, b) => a.ab - b.ab);
|
||||
let geaendert = false;
|
||||
const ganz = (c: number) => `${(c / 100).toLocaleString("de-DE")} €`;
|
||||
const bereich = (i: number) => {
|
||||
const bis = stufen[i + 1]?.ab;
|
||||
return i === 0 ? (bis != null ? `unter ${ganz(bis)}` : "alle Aufträge") : bis != null ? `${ganz(stufen[i]!.ab)} bis unter ${ganz(bis)}` : `ab ${ganz(stufen[i]!.ab)}`;
|
||||
};
|
||||
const zeichnen = () => {
|
||||
ort.innerHTML = `${stufen.map((st, i) => {
|
||||
const summe = st.raten.reduce((x, r) => x + r.prozent, 0);
|
||||
return `<section class="karte zp-stufe" data-st="${i}"><div class="zp-kopf"><h3>${esc(bereich(i))} <small>${st.raten.length} ${st.raten.length === 1 ? "Rate" : "Raten"}</small></h3>
|
||||
${i ? `<label>ab <input class="zp-ab" inputmode="decimal" value="${esc((st.ab / 100).toLocaleString("de-DE"))}"> € netto</label><button type="button" class="verweis" data-zp="stufe-weg">Stufe entfernen</button>` : ""}</div>
|
||||
<table class="zp-raten"><thead><tr><th>Rate</th><th class="zahl">Anteil</th><th>fällig</th><th></th></tr></thead><tbody>${st.raten.map((r, j) => `<tr data-r="${j}">
|
||||
<td><input class="zp-text" value="${esc(r.bezeichnung)}" aria-label="Bezeichnung"></td>
|
||||
<td class="zahl">${j === st.raten.length - 1 ? `<span class="zp-rest">${String(Math.round((100 - summe + r.prozent) * 100) / 100).replace(".", ",")} % (Rest)</span>` : `<input class="zp-pz" inputmode="decimal" value="${String(r.prozent).replace(".", ",")}" aria-label="Prozent"> %`}</td>
|
||||
<td><select class="zp-ziel" aria-label="fällig">${RATEN_ZIEL.map(([k, t]) => `<option value="${k}"${k === r.ziel ? " selected" : ""}>${t}</option>`).join("")}</select></td>
|
||||
<td>${st.raten.length > 1 ? '<button type="button" class="zeile-weg" data-zp="rate-weg" aria-label="Rate entfernen">✕</button>' : ""}</td></tr>`).join("")}</tbody></table>
|
||||
${summe - st.raten.at(-1)!.prozent > 100 ? '<p class="rot">Die Raten vor der Schlussrechnung sind zusammen mehr als 100 %.</p>' : ""}
|
||||
<button type="button" class="verweis" data-zp="rate-neu">+ Rate</button></section>`;
|
||||
}).join("")}
|
||||
<p class="zp-knoepfe"><button type="button" class="neben" data-zp="stufe-neu">+ Stufe</button><button type="button" class="neben" data-zp="standard">Vorschlag wiederherstellen</button>
|
||||
<button type="button" class="haupt" data-zp="speichern"${geaendert ? "" : " disabled"}>Speichern</button></p>`;
|
||||
};
|
||||
const lesen = () => {
|
||||
ort.querySelectorAll<HTMLElement>(".zp-stufe").forEach((el) => {
|
||||
const st = stufen[Number(el.dataset.st)]!;
|
||||
const ab = el.querySelector<HTMLInputElement>(".zp-ab");
|
||||
if (ab) { try { st.ab = Math.max(0, parseEuro(ab.value.replace(/[^\d.,-]/g, "") || "0")); } catch { /* ungültig: alter Wert bleibt */ } }
|
||||
el.querySelectorAll<HTMLElement>("tr[data-r]").forEach((tr) => {
|
||||
const r = st.raten[Number(tr.dataset.r)]!;
|
||||
r.bezeichnung = tr.querySelector<HTMLInputElement>(".zp-text")!.value.trim() || r.bezeichnung;
|
||||
const pz = tr.querySelector<HTMLInputElement>(".zp-pz");
|
||||
if (pz) r.prozent = Math.min(100, Math.max(0, Number(pz.value.replace(",", ".")) || 0));
|
||||
r.ziel = tr.querySelector<HTMLSelectElement>(".zp-ziel")!.value as RatenZiel;
|
||||
});
|
||||
// die Schlussrechnung bekommt den Rest
|
||||
const vorn = st.raten.slice(0, -1).reduce((x, r) => x + r.prozent, 0);
|
||||
st.raten.at(-1)!.prozent = Math.max(0, Math.round((100 - vorn) * 100) / 100);
|
||||
});
|
||||
};
|
||||
ort.addEventListener("change", () => { lesen(); geaendert = true; zeichnen(); });
|
||||
ort.addEventListener("click", async (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-zp]");
|
||||
if (!b) return;
|
||||
lesen();
|
||||
const st = stufen[Number(b.closest<HTMLElement>("[data-st]")?.dataset.st)];
|
||||
const tr = b.closest<HTMLElement>("tr[data-r]");
|
||||
switch (b.dataset.zp) {
|
||||
case "rate-neu": st!.raten.splice(st!.raten.length - 1, 0, { bezeichnung: "Abschlag", prozent: 0, ziel: "richten" } as PlanRate); break;
|
||||
case "rate-weg": st!.raten.splice(Number(tr!.dataset.r), 1); break;
|
||||
case "stufe-weg": stufen = stufen.filter((x) => x !== st); break;
|
||||
case "stufe-neu": {
|
||||
const letzte = stufen.at(-1)!;
|
||||
stufen.push({ ab: letzte.ab + 1_000_000, raten: structuredClone(letzte.raten) });
|
||||
break;
|
||||
}
|
||||
case "standard": stufen = structuredClone(STANDARD_STAFFEL); break;
|
||||
case "speichern": {
|
||||
stufen.sort((a, b) => a.ab - b.ab);
|
||||
stufen[0]!.ab = 0;
|
||||
await api("einstellungen", "PUT", { ...e, zahlungsStaffel: stufen });
|
||||
e.zahlungsStaffel = structuredClone(stufen);
|
||||
geaendert = false;
|
||||
zeichnen();
|
||||
ort.querySelector(".zp-knoepfe")!.insertAdjacentHTML("beforeend", '<span class="erfolg-text">Gespeichert. Gilt für neue Projekte und automatische Pläne, an denen nichts von Hand geändert ist.</span>');
|
||||
return;
|
||||
}
|
||||
}
|
||||
geaendert = true;
|
||||
zeichnen();
|
||||
});
|
||||
zeichnen();
|
||||
}
|
||||
|
||||
function angebotsVorgaben(e: Zeile): void {
|
||||
// Stufe 3a: Vorgaben für neue Angebote; ein angelegtes Angebot behält seine Sätze (A36)
|
||||
const k = e.kalkulation;
|
||||
const kalkFelder: Feld[] = [
|
||||
@@ -1444,14 +1683,13 @@ async function daten(): Promise<void> {
|
||||
bindefristWochen: Math.round(z("bindefristWochen", k.bindefristWochen)), erinnerungTage: Math.round(z("erinnerungTage", k.erinnerungTage)),
|
||||
kopftext: d.kopftext ?? "", schlusstext: d.schlusstext ?? "",
|
||||
} });
|
||||
daten();
|
||||
void daten("vorlagen");
|
||||
};
|
||||
const vorlagenLink = document.createElement("a");
|
||||
vorlagenLink.className = "neben";
|
||||
vorlagenLink.href = "#stammdaten";
|
||||
vorlagenLink.textContent = "Leistungen, Material und Mengenvorlagen: Stammdaten";
|
||||
if (modulAn("angebote")) inhalt.append(" ", kalkKnopf, " ", vorlagenLink);
|
||||
await vorlageEditor(e);
|
||||
document.getElementById("einst-kalk")!.append(kalkKnopf, " ", vorlagenLink);
|
||||
}
|
||||
|
||||
// Aufgaben, die jedes beauftragte Projekt bekommt (Henning, 20.10.2026), z. B. „Material bestellen, 7 Arbeitstage vor Abbund“
|
||||
@@ -1524,9 +1762,11 @@ function reiterFuer(s: Sitzung): Reiter[] {
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
|
||||
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", () => laufendeKostenSeite()],
|
||||
["rechnungen", "Rechnungen", rechnungenSeite],
|
||||
];
|
||||
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
|
||||
if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||||
if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => einstellungenMit("benutzer", () => benutzerSeite(s))],
|
||||
["daten", "Einstellungen", () => daten("daten")]);
|
||||
// abgeschaltete Programmteile (Einstellungen → Daten)
|
||||
const aus = new Set([...(zeit ? [] : ["stunden"]), ...(modulAn("angebote") ? [] : ["stammdaten"]), ...(modulAn("jahresplanung") ? [] : ["jahresplanung"])]);
|
||||
return alle.filter(([id]) => !aus.has(id));
|
||||
@@ -1551,6 +1791,9 @@ const SYMBOLE: Record<string, string> = {
|
||||
heute: '<path d="M3 11l9-7 9 7"/><path d="M5 10v10h14V10"/><path d="M10 20v-5h4v5"/>',
|
||||
baustelle: '<path d="M4 8h3l2-3h6l2 3h3v11H4z"/><circle cx="12" cy="13" r="3.5"/>',
|
||||
mehr: '<path d="M4 6h16M4 12h16M4 18h16"/>',
|
||||
betrieb: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
|
||||
rechnungen: '<path d="M6 3h12v18l-3-2-3 2-3-2-3 2z"/><path d="M9 8h6M9 12h6"/>',
|
||||
einstellungen: '<circle cx="12" cy="12" r="3"/><path d="M12 2v3M12 19v3M4.2 4.2l2.1 2.1M17.7 17.7l2.1 2.1M2 12h3M19 12h3M4.2 19.8l2.1-2.1M17.7 6.3l2.1-2.1"/>',
|
||||
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
|
||||
};
|
||||
const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${SYMBOLE[id] ?? ""}</svg>`;
|
||||
@@ -1639,6 +1882,35 @@ function mehrBlatt(s: Sitzung, anker: HTMLElement, ids: string[]): void {
|
||||
}
|
||||
};
|
||||
}
|
||||
// Seitenleiste am PC nach Lastenheft (UX-Prüfung, Henning 08.11.2026): 8 Hauptpunkte, beim aktiven Bereich klappen
|
||||
// die Unterpunkte auf. Wohin ein Hauptpunkt führt: auf seine eigene Seite, sonst auf den ersten Unterpunkt.
|
||||
const MENUE: [string, string, [string, string][]][] = [
|
||||
["uebersicht", "Übersicht", []], ["aufgaben", "Aufgaben", []],
|
||||
["projekte", "Projekte", [["angebote", "Angebote"], ["rechnungen", "Rechnungen"], ["stammdaten", "Stammdaten"]]],
|
||||
["terminplan", "Terminplan", []],
|
||||
["personal", "Personal", [["personal", "Mitarbeiter"], ["stunden", "Zeiterfassung"]]],
|
||||
["betrieb", "Betrieb", [["liquiditaet", "Liquidität"], ["laufende-kosten", "Laufende Kosten"], ["jahresplanung", "Jahresfinanzplanung"], ["bwa", "BWA"]]],
|
||||
["kontakte", "Kontakte", []],
|
||||
["einstellungen", "Einstellungen", [["benutzer", "Benutzer"], ["einstellungen-vorlagen", "Vorlagen"], ["daten", "Daten und Sicherung"]]],
|
||||
];
|
||||
const gruppeVon = (r: string) => MENUE.find(([id, , u]) => id === r || u.some(([x]) => x === r))?.[0] ?? "";
|
||||
function navZeichnen(gruppe: string, unter: string): void {
|
||||
if (sitzung?.benutzer?.rolle === "mitarbeiter") {
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === gruppe));
|
||||
return;
|
||||
}
|
||||
const da = new Set(REITER.map(([r]) => r));
|
||||
const geht = (u: string) => da.has(u) || (u === "angebote" && da.has("projekte") && modulAn("angebote")) || (u === "bwa" && da.has("jahresplanung"))
|
||||
|| (u === "einstellungen-vorlagen" && da.has("daten"));
|
||||
nav.innerHTML = MENUE.map(([id, titel, unterpunkte]) => {
|
||||
const u = unterpunkte.filter(([x]) => geht(x));
|
||||
const ziel = id === "einstellungen" ? (da.has("daten") ? "daten" : u[0]?.[0]) : da.has(id) ? id : u[0]?.[0];
|
||||
if (!ziel) return "";
|
||||
const offen = gruppe === id && u.length > 0;
|
||||
return `<button data-r="${ziel}" class="${gruppe === id ? "aktiv" : ""}"${offen ? ' aria-expanded="true"' : ""}>${symbol(id)}<span>${titel}</span></button>`
|
||||
+ (offen ? `<div class="unter-reiter">${u.map(([x, t]) => `<button data-r="${x}" class="${x === unter ? "aktiv" : ""}">${t}</button>`).join("")}</div>` : "");
|
||||
}).join("");
|
||||
}
|
||||
let REITER: Reiter[] = [];
|
||||
let sitzung: Sitzung | undefined;
|
||||
nav.addEventListener("click", (ev) => {
|
||||
@@ -1676,8 +1948,13 @@ async function zeige(): Promise<void> {
|
||||
const zuStamm = vorlage || leistung || sdTeil;
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : kontaktWahl ? "kontakte" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
// Einstellungen mit Reitern (UX-Prüfung, 08.11.2026); BWA ist der Reiter „Plan / Ist“ der Jahresplanung
|
||||
const einstTeil = /^einstellungen-(vorlagen|programmteile|anbindungen)$/.exec(id)?.[1] ?? (id === "einstellungen" ? "daten" : undefined);
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : zuStamm ? "stammdaten" : kontaktWahl ? "kontakte"
|
||||
: einstTeil ? "daten" : id === "bwa" ? "jahresplanung" : id)) ?? REITER[0]!;
|
||||
const unterAktiv = angebot || mengenblatt || id === "angebote" ? "angebote" : einstTeil === "vorlagen" ? "einstellungen-vorlagen"
|
||||
: einstTeil ? (einstTeil === "daten" ? "daten" : "") : id === "bwa" ? "bwa" : reiter[0];
|
||||
navZeichnen(gruppeVon(unterAktiv || reiter[0]) || gruppeVon(reiter[0]), unterAktiv);
|
||||
inhalt.dataset.reiter = reiter[0];
|
||||
const imUnten = !!unten.querySelector(`[data-r="${reiter[0]}"]`);
|
||||
unten.querySelectorAll<HTMLElement>("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0] || (!imUnten && b.dataset.r === "mehr")));
|
||||
@@ -1694,7 +1971,9 @@ async function zeige(): Promise<void> {
|
||||
: vorlage && reiter[0] === "stammdaten" ? vorlageSeite(vorlage)
|
||||
: leistung && reiter[0] === "stammdaten" ? leistungSeite(leistung)
|
||||
: sdTeil && reiter[0] === "stammdaten" ? stammdatenSeite(sdTeil)
|
||||
: id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]());
|
||||
: id === "angebote" && reiter[0] === "projekte" ? angeboteSeite()
|
||||
: einstTeil && reiter[0] === "daten" ? daten(einstTeil as EinstTeil)
|
||||
: id === "bwa" && reiter[0] === "jahresplanung" ? jahresplanSeite("planist") : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
@@ -1718,7 +1997,7 @@ async function start(): Promise<void> {
|
||||
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
|
||||
document.body.classList.toggle("rolle-inhaber", s.benutzer.rolle === "inhaber");
|
||||
REITER = reiterFuer(s);
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
if (s.benutzer.rolle === "mitarbeiter") nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
werLeiste(s);
|
||||
pcAnsichtAnwenden();
|
||||
await ansichtenLaden();
|
||||
|
||||
@@ -556,11 +556,11 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const z = nurPerson ? w.personen.find((p) => p.kontakt_id === nurPerson)! : w;
|
||||
const klasse = z.geplant > z.verfuegbar + 0.01 ? "ueber" : z.verfuegbar - z.geplant >= 8 ? "leer" : "voll";
|
||||
const breite = woche.tage.length * W;
|
||||
const titel = `KW ${kalenderwoche(w.ab)}: ${std(z.geplant)} von ${std(z.verfuegbar)} Std. eingeplant`
|
||||
const titel = `KW ${kalenderwoche(w.ab)}: ${std(z.geplant)} von ${std(z.verfuegbar)} Std. eingeplant (Mo–Do)`
|
||||
+ (nurPerson ? "" : w.personen.map((p) => `\n${nameVon.get(p.kontakt_id) ?? ""}: ${std(p.geplant)} von ${std(p.verfuegbar)}${p.geplant > p.verfuegbar + 0.01 ? " (überplant)" : ""}`).join(""));
|
||||
return `<div class="last ${klasse}" style="left:${x(w.ab)}px;width:${breite}px" title="${esc(titel)}">${breite >= 58 ? `${std(z.geplant)}/${std(z.verfuegbar)}` : ""}</div>`;
|
||||
}).join("");
|
||||
return `<div class="g-auslastung"><div class="g-links"><span class="nr"></span><span class="name ebene0" title="Stunden je Woche: eingeplant / verfügbar. Rot = überplant, grau = Leerlauf">Auslastung ${nurPerson ? esc(nameVon.get(nurPerson)) : "Team"} <small>Std./Woche</small></span></div>
|
||||
return `<div class="g-auslastung"><div class="g-links"><span class="nr"></span><span class="name ebene0" title="Stunden je Woche: eingeplant / verfügbar. Rot = überplant, grau = Leerlauf">Auslastung ${nurPerson ? esc(nameVon.get(nurPerson)) : "Team"} <small>Std./Woche, Mo–Do</small></span></div>
|
||||
<div class="g-last-zeit" style="width:${tage * W}px">${bloecke}</div></div>`;
|
||||
})() : "";
|
||||
|
||||
|
||||
@@ -46,7 +46,8 @@ let speichernNach: ReturnType<typeof setTimeout> | undefined;
|
||||
|
||||
const aktivSchluessel = () => `jp-version-${jahr}`;
|
||||
|
||||
export async function jahresplanSeite(): Promise<void> {
|
||||
export async function jahresplanSeite(start?: Reiter): Promise<void> {
|
||||
if (start) reiter = start;
|
||||
d = await api<Zeile>(`jahresplan${jahr ? `?jahr=${jahr}` : ""}`);
|
||||
jahr = d.jahr;
|
||||
versionen = d.versionen;
|
||||
|
||||
@@ -54,16 +54,28 @@ export async function liquiditaetSeite(): Promise<void> {
|
||||
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 €", " €");
|
||||
/** Projektnummer → Projekt-ID, damit die Nummern Links zum Projekt sind (UX-Prüfung, 08.11.2026) */
|
||||
let projektIds = new Map<string, string>();
|
||||
const projektLink = (nr: string) => (projektIds.has(nr) ? `<a href="#projekt-${esc(projektIds.get(nr)!)}">${esc(nr)}</a>` : esc(nr));
|
||||
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))}` : ""}` : ""}`;
|
||||
`${esc(p.bezeichnung)}${p.projekt ? ` · ${projektLink(p.projekt)}${namen?.get(p.projekt) ? ` ${esc(namen.get(p.projekt))}` : ""}` : ""}`;
|
||||
/** vom Projekt aus „in Liquidität zeigen“: „Alle Zahlungen“ nur dieses Projekts */
|
||||
let nurProjekt: string | null = null;
|
||||
export function liquiNurProjekt(nummer: string): void {
|
||||
nurProjekt = nummer;
|
||||
reiter = "alle";
|
||||
}
|
||||
|
||||
const FLUSS_GRUPPEN = new Set(["Projekteinnahmen", "Projektkosten", "Laufende Kosten", "Umsatzsteuer"]);
|
||||
|
||||
/** Karte oben ohne Kontostand: Summen des Zeitraums und Überschuss */
|
||||
/** Karte oben ohne Kontostand (UX-Prüfung, 08.11.2026): ein Lage-Satz mit Zeitraum und Überschuss, darunter die Summen */
|
||||
function flussKopfHtml(wochen: Zeile[]): string {
|
||||
return `<section class="karte liqui-fluss-kopf">${flussKachelnHtml(flussJeWoche(wochen as Periode[]), ZEIT_KNOPF[zeitraum], true)}
|
||||
<p class="hinweis">Ohne Kontostand gerechnet: Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer (monatlich, fällig am 10. des übernächsten Monats).
|
||||
<button class="verweis" data-kontostand="an">Kontostand einbeziehen</button></p></section>`;
|
||||
const fluss = flussJeWoche(wochen as Periode[]);
|
||||
const ueber = fluss.reduce((x, w) => x + w.einnahmen - w.projektkosten - w.laufend - w.ust, 0);
|
||||
const von = heute(), bis = (wochen.at(-1)?.bis as string | undefined) ?? von;
|
||||
return `<section class="karte liqui-satz-ohne"><p class="liqui-satz-gross">${dat(von)} – ${dat(bis)}: <b class="${ueber < 0 ? "fehler" : ""}">${ueber > 0 ? "+" : ""}${glatt(ueber)}</b> ${ueber < 0 ? "Fehlbetrag" : "Überschuss"}</p>
|
||||
<p class="hinweis">Trag den Kontostand ein, dann steht hier „frei verfügbar heute“ und die Woche, in der es am knappsten wird. <button class="verweis" data-kontostand="an">Kontostand eintragen</button></p></section>
|
||||
<section class="karte liqui-fluss-kopf">${flussKachelnHtml(fluss, ZEIT_KNOPF[zeitraum], true)}</section>`;
|
||||
}
|
||||
|
||||
/** Karte oben: frei verfügbar, Ampel, Satz und Grund. Auch auf der Startseite (Block 3) */
|
||||
@@ -80,7 +92,7 @@ export function lageKopfHtml(d: Zeile, zeitText: string): string {
|
||||
}
|
||||
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>';
|
||||
const stand = d.kontostandDatum ? `Kontostand vom ${dat(d.kontostandDatum)}` : '<a href="#einstellungen-programmteile">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>
|
||||
@@ -203,6 +215,7 @@ 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]));
|
||||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id as string]));
|
||||
// vorerst ohne Kontostand (Henning, 23.10.2026): nur Einnahmen, Projektkosten, laufende Kosten und Umsatzsteuer
|
||||
const ohne = !d.mitKontostand;
|
||||
if (ohne) d.wochen = (d.wochen as Zeile[]).map((w) => ({ ...w, posten: (w.posten as Zeile[]).filter((p) => FLUSS_GRUPPEN.has(p.gruppe)),
|
||||
@@ -229,11 +242,7 @@ async function lageZeigen(): Promise<void> {
|
||||
${planHinweis(d)}
|
||||
<p class="hinweis"><button class="verweis" data-kontostand="aus">Ohne Kontostand rechnen</button></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>`;
|
||||
+ `<div class="liqui-zwei">${listeHtml("ein", zeilen.ein, namen, ausSet, d)}${listeHtml("aus", zeilen.aus, namen, ausSet, d)}</div>`;
|
||||
};
|
||||
zeichne();
|
||||
bereich.onclick = (ev) => {
|
||||
@@ -440,7 +449,7 @@ function listeHtml(art: "ein" | "aus", alle: ListenZeile[], namen: Map<string, s
|
||||
const rest = posten.slice(sichtbar);
|
||||
const probeText = probe.size && probeSumme !== summe(zaehlen) ? ` <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"><thead><tr><th class="vorne"></th><th class="datum">Datum</th><th class="text">Was</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">zählt</th><th class="zahl">Betrag</th></tr></thead>
|
||||
${alle.length ? `<table class="liqui-posten"><thead><tr><th class="vorne"></th><th class="datum">Datum</th><th class="text">Was</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">In Rechnung</th><th class="zahl">Betrag</th></tr></thead>
|
||||
<tbody>${posten.slice(0, sichtbar).map(zeile).join("")}
|
||||
${rest.length || (mehr[art] && posten.length > SICHTBAR) ? `<tr class="mehr"><td></td><td></td><td colspan="3"><button class="verweis" data-mehr="${art}" aria-expanded="${mehr[art]}">${mehr[art] ? "▴ weniger anzeigen" : `▾ ${rest.length} weitere anzeigen (${glatt(summe(rest.filter((z) => z.zaehlt)))})`}</button></td></tr>` : ""}
|
||||
${nicht.length ? `<tr class="aus-hinweis"><td></td><td></td><td colspan="3">${nicht.length} Posten ${nicht.length === 1 ? "zählt" : "zählen"} nicht · <button class="verweis" data-alle-zaehlen="${esc(nicht.flatMap((z) => z.quellen).join(" "))}">alle wieder zählen</button></td></tr>` : ""}
|
||||
@@ -501,6 +510,7 @@ async function planZeigen(): Promise<void> {
|
||||
ohne: ((p.ohne ?? []) as Zeile[]).filter((x) => FLUSS_GRUPPEN.has(x.gruppe)) })) : roh;
|
||||
const flussVon = (p: Zeile) => flussJeWoche([p as Periode])[0]!;
|
||||
const namen = new Map(projekte.map((p) => [p.nummer as string, p.bezeichnung as string]));
|
||||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id 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");
|
||||
@@ -535,7 +545,7 @@ async function planZeigen(): Promise<void> {
|
||||
const posten = [...p.posten, ...(p.ohne ?? [])].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"}${p.ohne?.length ? `, ${p.ohne.length} ${p.ohne.length === 1 ? "zählt" : "zählen"} nicht` : ""}</small></td>
|
||||
${zahlen(p)}</tr>
|
||||
${offen ? `<tr class="details"><td colspan="${spalten}">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">zählt</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>`;
|
||||
${offen ? `<tr class="details"><td colspan="${spalten}">${posten.length ? `<table class="posten-tabelle"><thead><tr><th>Fällig am</th><th>Was</th><th class="optional">Projekt</th><th class="zaehlt" title="Haken weg = zählt dauerhaft nicht mit">In Rechnung</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("change", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
@@ -556,13 +566,19 @@ async function alleZeigen(): Promise<void> {
|
||||
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]));
|
||||
projektIds = new Map(projekte.map((p) => [p.nummer as string, p.id as string]));
|
||||
const h = heute();
|
||||
const ohne = !einst.liquiditaetMitKontostand;
|
||||
// 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[]), ...((p.ohne ?? []) as Zeile[])]).filter((x) => !ohne || FLUSS_GRUPPEN.has(x.gruppe))
|
||||
.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.zaehltNicht ? 0 : x.betrag) }));
|
||||
.map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.zaehltNicht ? 0 : x.betrag) }))
|
||||
.filter((x) => !nurProjekt || (x as Zeile).projekt === nurProjekt);
|
||||
if (nurProjekt) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="fb-chips"><button class="chip-wahl an" data-nur-weg>Nur ${esc(nurProjekt)} ${esc(namen.get(nurProjekt) ?? "")} ✕</button></div>`);
|
||||
inhalt.querySelector<HTMLElement>("[data-nur-weg]")!.onclick = () => { nurProjekt = null; void liquiditaetSeite(); };
|
||||
}
|
||||
const tabelle = liste({
|
||||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||||
zeilenKlasse: (x) => `${x.ueberfaelligSeit ? "ueber" : x.datum < h ? "vorbei" : ""}${x.zaehltNicht ? " zaehlt-nicht" : ""}`,
|
||||
@@ -570,8 +586,8 @@ async function alleZeigen(): Promise<void> {
|
||||
{ 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>` : ""}${x.zaehltNicht ? ' <span class="tag-zaehlt">zählt nicht</span>' : ""}<span class="unter nur-schmal">${esc(x.gruppe)}</span>`, klasse: "text" },
|
||||
{ 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: "zaehlt", titel: "Zählt", text: (x) => (x.zaehltNicht ? "zählt nicht" : "zählt"), wert: (x) => zaehltHaken(x.quelle ? [x.quelle] : [], !x.zaehltNicht, x.bezeichnung), klasse: "zaehlt" },
|
||||
{ id: "projekt", titel: "Projekt", text: (x) => (x.projekt ? `${x.projekt} ${namen.get(x.projekt) ?? ""}`.trim() : ""), wert: (x) => (x.projekt ? `${projektLink(x.projekt)}${namen.get(x.projekt) ? ` ${esc(namen.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||||
{ id: "zaehlt", titel: "In Rechnung", text: (x) => (x.zaehltNicht ? "zählt nicht" : "zählt"), wert: (x) => zaehltHaken(x.quelle ? [x.quelle] : [], !x.zaehltNicht, x.bezeichnung), klasse: "zaehlt" },
|
||||
{ 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" },
|
||||
...(ohne ? [] : [{ id: "stand", titel: "Kontostand danach", art: "zahl" as const, wert: (x: Zeile) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x: Zeile) => x.stand, klasse: "zahl optional" }]),
|
||||
],
|
||||
|
||||
@@ -56,6 +56,30 @@ body { margin: 0; background: var(--bg); color: var(--text); display: flex; min-
|
||||
#reiter button svg { width: 19px; height: 19px; flex: none; }
|
||||
#reiter button:hover { background: rgb(255 255 255 / 0.06); color: #fff; }
|
||||
#reiter button.aktiv { background: var(--leiste-aktiv); color: #fff; font-weight: 600; box-shadow: inset 3px 0 0 var(--holz); }
|
||||
/* Unterpunkte des aktiven Bereichs (UX-Prüfung, 08.11.2026) */
|
||||
#reiter .unter-reiter { display: flex; flex-direction: column; gap: 1px; margin: 2px 0 6px 20px; padding-left: 10px; border-left: 1px solid rgb(255 255 255 / 0.14); }
|
||||
#reiter .unter-reiter button { padding: 6px 10px; font-size: 13px; }
|
||||
#reiter .unter-reiter button.aktiv { background: none; box-shadow: inset 2px 0 0 var(--holz); border-radius: 0 6px 6px 0; }
|
||||
#reiter button[aria-expanded="true"].aktiv { background: rgb(255 255 255 / 0.06); }
|
||||
.einst-reiter { display: flex; flex-wrap: wrap; gap: 4px 18px; border-bottom: 1px solid var(--linie); margin: 0 0 16px; }
|
||||
.einst-reiter a { padding: 8px 2px; color: var(--leise); text-decoration: none; border-bottom: 2px solid transparent; margin-bottom: -1px; }
|
||||
.einst-reiter a:hover { color: var(--text); }
|
||||
.einst-reiter a.aktiv { color: var(--text); font-weight: 600; border-bottom-color: var(--holz); }
|
||||
.nowrap { white-space: nowrap; }
|
||||
.liqui-posten td.text a, .liste td a[href^="#projekt-"] { color: var(--akzent); }
|
||||
button.verweis-zeile { all: unset; cursor: pointer; display: flex; flex-direction: column; align-items: flex-start; gap: 2px; min-width: 0; }
|
||||
button.verweis-zeile:hover b { color: var(--akzent); }
|
||||
.projekt-aufgaben ul.aufgaben { margin-top: 8px; }
|
||||
.liqui-satz-ohne { border-left: 4px solid var(--akzent); }
|
||||
.liqui-satz-gross { font-size: 18px; margin: 0 0 4px; }
|
||||
.brotkrumen { font-size: 13px; color: var(--leise); margin: 0 0 4px; }
|
||||
.brotkrumen a { color: var(--akzent); }
|
||||
.fehlt-liste { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; }
|
||||
.fehlt-da { margin-top: 10px; padding-top: 8px; border-top: 1px solid var(--linie); }
|
||||
.p-ablauf-links { display: inline-flex; gap: 14px; font-size: 13px; font-weight: 400; }
|
||||
.stand-ro small:last-child { color: var(--leise); }
|
||||
.projekt-schnell { margin: 0 0 10px; }
|
||||
.projekt-schnell small { color: var(--leise); margin-left: 2px; }
|
||||
#version { font-size: 12px; padding: 8px 10px 0; opacity: 0.7; }
|
||||
|
||||
/* Inhalt */
|
||||
@@ -86,8 +110,9 @@ td.zahl { white-space: nowrap; }
|
||||
|
||||
/* Status-Etiketten */
|
||||
.etikett { display: inline-block; padding: 4px 11px; border-radius: 999px; font-size: 13px; white-space: nowrap; background: #eef1f5; color: #4a5565; }
|
||||
.etikett.angebot { background: #e4eefa; color: #1d5fa8; }
|
||||
.etikett.auftrag { background: #d7ecfa; color: #0b5f96; }
|
||||
/* Status als Farbreihe (UX-Prüfung, 08.11.2026): Anfrage grau, Angebot holz-hell, Auftrag blau gefüllt */
|
||||
.etikett.angebot { background: #f6ead9; color: #7a4a24; }
|
||||
.etikett.auftrag { background: #1d5fa8; color: #fff; }
|
||||
.etikett.ausfuehrung { background: #fcefc3; color: #7a5600; }
|
||||
.etikett.abgerechnet { background: #dcf1f4; color: #0f6674; }
|
||||
.etikett.gewaehrleistung { background: #e6e8fb; color: #3c47a8; }
|
||||
@@ -247,6 +272,29 @@ ul.warnungen li.ueberschneidung a, ul.warnungen li.kontostand a { border-left-co
|
||||
ul.warnungen li.unbesetzt a, ul.warnungen li.freigabe a { border-left-color: var(--holz); }
|
||||
ul.warnungen li.aufgabe a, ul.warnungen li.urlaub a { border-left-color: var(--akzent); }
|
||||
ul.warnungen .symbol { width: 18px; text-align: center; flex: none; }
|
||||
/* UX-Prüfung (08.11.2026): Brennt und Zahlenleiste */
|
||||
ul.warnungen .w-text { display: flex; flex-direction: column; min-width: 0; }
|
||||
ul.warnungen .w-text small { color: var(--leise); font-size: 12px; }
|
||||
ul.warnungen li.verzug a, ul.warnungen li.zahlung a { border-left-color: var(--warn); }
|
||||
ul.warnungen li.verzug .symbol, ul.warnungen li.zahlung .symbol { color: var(--warn); }
|
||||
.start-zahlen { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin: 0 0 16px; }
|
||||
.start-zahlen a { display: flex; flex-direction: column; gap: 2px; padding: 10px 14px; background: var(--fl); border: 1px solid var(--linie); border-left: 4px solid var(--akzent); border-radius: 10px; color: var(--text); text-decoration: none; min-width: 0; }
|
||||
.start-zahlen a:hover { border-color: var(--akzent); }
|
||||
.start-zahlen a.warn { border-left-color: var(--warn); }
|
||||
.start-zahlen a.warn b { color: var(--warn); }
|
||||
.start-zahlen a.gut { border-left-color: var(--gut-text); }
|
||||
.start-zahlen a.gut b { color: var(--gut-text); }
|
||||
.start-zahlen small { color: var(--leise); font-size: 12px; }
|
||||
.start-zahlen b { font-size: 22px; font-variant-numeric: tabular-nums; line-height: 1.2; }
|
||||
.start-zahlen span { color: var(--leise); font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
|
||||
@media (max-width: 1100px) { .start-zahlen { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
|
||||
.einsatz-tabelle th.morgen, .einsatz-tabelle td.morgen { background: var(--akzent-hell); }
|
||||
.einsatz-tabelle thead th small { display: block; font-weight: 600; font-size: 10.5px; color: var(--akzent); }
|
||||
.einsatz-tabelle thead th.freitag small { color: var(--holz); }
|
||||
button.einsatz { width: 100%; text-align: left; font: inherit; border: 0; cursor: pointer; }
|
||||
button.einsatz.vorgemerkt { border: 1.5px dashed var(--pf, var(--leise)); }
|
||||
button.einsatz:hover { filter: brightness(1.08); }
|
||||
label.haken { display: inline-flex; align-items: center; justify-content: center; cursor: pointer; }
|
||||
.einsatz-tabelle { overflow-x: auto; }
|
||||
.einsatz-tabelle table { border: 0; border-radius: 0; font-size: 13px; }
|
||||
.einsatz-tabelle th, .einsatz-tabelle td { padding: 6px 6px; vertical-align: top; min-width: 96px; }
|
||||
@@ -502,6 +550,8 @@ tr.ueber .tag-ueber { background: var(--fl); }
|
||||
/* Projektseite wie Plancraft (Henning, 20.10.2026): links Übersicht und Dokumente, rechts offene Aufgaben */
|
||||
.projekt-raster { display: grid; grid-template-columns: minmax(0, 1fr) 340px; gap: 16px; align-items: start; }
|
||||
.projekt-haupt { display: grid; gap: 16px; min-width: 0; }
|
||||
/* PC (UX-Prüfung, 08.11.2026): Stand oben, Abschnitte unter der Übersicht */
|
||||
.projekt-haupt > .p-stand { order: -1; } .projekt-haupt > .p-ablauf { order: 1; } .projekt-haupt > #p-unten { order: 2; }
|
||||
.projekt-raster .karte { margin: 0; }
|
||||
/* wie die freigegebene Vorabansicht: oben drei gleich breite Kacheln, unten Zeitraum schmal und Baustelle doppelt breit */
|
||||
.uebersicht-kacheln { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-template-areas: "stunden kunde beschreibung" "zeitraum baustelle baustelle"; gap: 12px; padding: 12px 16px 16px; }
|
||||
@@ -1494,10 +1544,10 @@ dl.am-kennzahlen dd { margin: 0; text-align: right; font-variant-numeric: tabula
|
||||
.liqui-posten td.vorne input { width: 16px; height: 16px; margin: 2px 0 0; }
|
||||
.liqui-posten tr.ausgeblendet td:not(.vorne) { opacity: .5; }
|
||||
/* Haken „zählt“ (Henning, 26.10.2026): ohne Haken grau und durchgestrichen, zählt nirgends mit */
|
||||
.liqui-posten th { padding: 2px 4px 4px; font-size: 11px; font-weight: 600; letter-spacing: .04em; text-transform: uppercase; color: var(--leise); text-align: left; }
|
||||
.liqui-posten th { padding: 2px 4px 4px; font-size: 12.5px; font-weight: 600; color: var(--leise); text-align: left; }
|
||||
.liqui-posten th.datum { width: 86px; }
|
||||
.liqui-posten th.zahl { width: 112px; text-align: right; }
|
||||
.liqui-posten th.zaehlt, .liqui-posten td.zaehlt { width: 46px; text-align: center; }
|
||||
.liqui-posten th.zaehlt, .liqui-posten td.zaehlt { width: 76px; text-align: center; }
|
||||
th.zaehlt, td.zaehlt { text-align: center; }
|
||||
td.zaehlt input, input.zaehlt-haken { width: 16px; height: 16px; margin: 2px 0 0; cursor: pointer; }
|
||||
tr.zaehlt-nicht td:not(.zaehlt):not(.vorne) { color: var(--leise); }
|
||||
@@ -1753,6 +1803,16 @@ a.heute-stunden { display: flex; justify-content: space-between; align-items: ce
|
||||
.handy-band a { flex: 1; display: flex; flex-direction: column; align-items: center; color: #fff; text-decoration: none; min-width: 0; }
|
||||
.handy-band b { font-size: 24px; font-variant-numeric: tabular-nums; }
|
||||
.handy-band b.warn { color: #ffb4a8; }
|
||||
.handy-band b.gut { color: #9ee6b4; }
|
||||
.handy-band b { white-space: nowrap; }
|
||||
.handy-band a:last-child b { font-size: 20px; line-height: 1.45; }
|
||||
/* Brennt: Zeilen mit 44 px Trefferfläche */
|
||||
section.start-brennt.nur-handy { display: block; }
|
||||
.start-brennt ul.warnungen li a { min-height: 44px; align-items: center; padding: 10px 12px; font-size: 15px; }
|
||||
/* große Haken: 24-px-Kästchen in 44-px-Trefferfläche */
|
||||
ul.aufgaben li.aufgabe-2 { grid-template-columns: 44px minmax(0, 1fr) auto; gap: 6px; }
|
||||
ul.aufgaben li.aufgabe-2 label.haken { width: 44px; height: 44px; margin: -10px 0 -10px -10px; }
|
||||
ul.aufgaben li.aufgabe-2 label.haken input { width: 24px; height: 24px; margin: 0; }
|
||||
.handy-band small { color: var(--leiste-text); font-size: 12px; }
|
||||
.start { display: flex; flex-direction: column; gap: 12px; }
|
||||
.start .start-warnungen { order: -1; }
|
||||
@@ -1818,7 +1878,7 @@ html.pc-erzwungen #handy-zurueck { display: block; position: fixed; left: max(12
|
||||
.handy-reiter { display: flex; gap: 2px; padding: 3px; background: var(--bg); border: 1px solid var(--linie); border-radius: 10px; margin: 0 0 12px; }
|
||||
.handy-reiter button { flex: 1; min-width: 0; padding: 8px 4px; border: 0; border-radius: 8px; background: none; color: var(--leise); font: inherit; font-size: 14px; cursor: pointer; }
|
||||
.handy-reiter button.aktiv { background: var(--fl); color: var(--text); font-weight: 700; box-shadow: 0 1px 3px rgb(0 0 0 / 0.12); }
|
||||
.stand-zahlen { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 8px; }
|
||||
.stand-zahlen { display: grid; grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); gap: 8px; }
|
||||
.stand-zahlen > div { display: flex; flex-direction: column; min-width: 0; }
|
||||
.stand-zahlen small { color: var(--leise); font-size: 12px; }
|
||||
.stand-zahlen b { font-size: 17px; font-variant-numeric: tabular-nums; overflow: hidden; text-overflow: ellipsis; }
|
||||
@@ -2183,3 +2243,73 @@ button.klein, a.klein { padding: 5px 10px; font-size: 14px; }
|
||||
.am-anrede { margin: 14px 0 4px; font-size: 15px; }
|
||||
.pj-rechnung-an { margin-top: 8px; display: grid; gap: 6px; justify-items: start; }
|
||||
.pj-rechnung-an pre { margin: 0; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 7px; background: var(--titel-bg); font: inherit; font-size: 14px; white-space: pre-wrap; max-width: 100%; }
|
||||
|
||||
/* UX-Prüfung Handy (Henning 08.11.2026) */
|
||||
.th-verzug { display: block; color: var(--warnung-text); font-weight: 600; font-size: 13px; margin-top: 2px; }
|
||||
@media (max-width: 640px) {
|
||||
/* zwei große Knöpfe unter dem Kopf; fehlt Nummer oder Adresse, ausgegraut mit Hinweis */
|
||||
.handy-aktionen.nur-handy { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; margin: 0 0 12px; }
|
||||
.handy-knopf { display: flex; flex-direction: column; justify-content: center; align-items: center; min-height: 52px; padding: 8px 10px; border: 1.5px solid var(--akzent); border-radius: 10px;
|
||||
background: var(--fl); color: var(--akzent); text-decoration: none; text-align: center; min-width: 0; }
|
||||
.handy-knopf b { font-size: 16px; }
|
||||
.handy-knopf small { font-size: 12px; color: var(--leise); max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.handy-knopf.aus { border-color: var(--linie); color: var(--leise); background: var(--bg); cursor: default; }
|
||||
/* Tippziele mindestens 44 px */
|
||||
.chip-knopf, .chip-wahl, .handy-reiter button, .teile button, .einst-reiter a { min-height: 44px; }
|
||||
.chip-knopf, .chip-wahl { display: inline-flex; align-items: center; }
|
||||
.einst-reiter a { display: inline-flex; align-items: center; }
|
||||
.leiste .chip { min-height: 36px; }
|
||||
.leiste .chip button { min-width: 36px; min-height: 36px; }
|
||||
/* kein Auge auf den Karten, Wischen blendet weiter aus */
|
||||
.liste table.karten-handy tr[data-i] > td.auge-spalte .auge { display: none; }
|
||||
.liste table.karten-handy tr[data-i] > td.auge-spalte:not(.mit-weg) { display: none; }
|
||||
/* der schwebende Hauptknopf deckt die letzte Karte nicht zu */
|
||||
main:has(> .kopf > button.haupt) { padding-bottom: calc(156px + env(safe-area-inset-bottom, 0px)); }
|
||||
/* Haken in Karten: 24-px-Kästchen in 44-px-Fläche */
|
||||
.liste table.karten-handy td.h-links input[type=checkbox] { width: 24px; height: 24px; margin: 10px; }
|
||||
.liste table.karten-handy tr[data-i] > td.h-links { margin: -10px 0 -10px -10px; }
|
||||
}
|
||||
|
||||
/* Zahlungsplan nach Auftragswert (Einstellungen › Vorlagen) */
|
||||
#einst-zp { display: grid; gap: 12px; margin-bottom: 20px; }
|
||||
.zp-stufe { padding: 12px 14px; }
|
||||
.zp-kopf { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 14px; margin-bottom: 6px; }
|
||||
.zp-kopf h3 { margin: 0; font-size: 15px; flex: 1 1 auto; }
|
||||
.zp-kopf h3 small { color: var(--leise); font-weight: 500; margin-left: 6px; }
|
||||
.zp-kopf input.zp-ab { width: 110px; text-align: right; }
|
||||
table.zp-raten { width: 100%; border-collapse: collapse; }
|
||||
table.zp-raten th, table.zp-raten td { padding: 5px 6px; }
|
||||
table.zp-raten th { font-size: 12.5px; color: var(--leise); font-weight: 600; }
|
||||
table.zp-raten td:first-child { width: 50%; }
|
||||
table.zp-raten input.zp-text { width: 100%; }
|
||||
table.zp-raten input.zp-pz { width: 64px; text-align: right; }
|
||||
table.zp-raten .zahl { text-align: right; white-space: nowrap; }
|
||||
.zp-rest { color: var(--leise); }
|
||||
.zp-knoepfe { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
|
||||
.zp-knoepfe .haupt { margin-left: auto; }
|
||||
.erfolg-text { color: var(--gut-text); font-size: 13px; flex-basis: 100%; text-align: right; }
|
||||
@media (max-width: 640px) {
|
||||
table.zp-raten thead { display: none; }
|
||||
table.zp-raten tr { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 4px 8px; padding: 6px 0; border-bottom: 1px solid var(--linie); }
|
||||
table.zp-raten td { padding: 0; border: 0; width: auto !important; }
|
||||
table.zp-raten td:nth-child(3) { grid-column: 1; }
|
||||
}
|
||||
|
||||
/* Zahlungsplan im Angebot (0.52) */
|
||||
.am-zp { margin: 14px 0 6px; padding-top: 10px; border-top: 1px solid var(--linie); }
|
||||
.am-zp-kopf { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 12px; }
|
||||
.am-zp-kopf h3 { margin: 0; }
|
||||
.am-zp-tab { display: grid; gap: 4px; margin: 6px 0; }
|
||||
.am-zp-zeile { display: grid; grid-template-columns: minmax(0, 1fr) 84px 190px 110px 28px; gap: 8px; align-items: center; }
|
||||
.am-zp-zeile .z, .am-zp-rest { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
.am-zp-rest { color: var(--leise); padding-right: 18px; }
|
||||
ol.am-zp-lese { margin: 6px 0; padding-left: 20px; }
|
||||
ol.am-zp-lese li span { display: inline-block; }
|
||||
ol.am-zp-lese li span:first-child { min-width: 50%; }
|
||||
ol.am-zp-lese li .z { min-width: 70px; text-align: right; }
|
||||
ol.am-zp-lese li .z + .z { min-width: 150px; }
|
||||
@media (max-width: 640px) {
|
||||
.am-zp-zeile { grid-template-columns: minmax(0, 1fr) auto 28px; }
|
||||
.am-zp-zeile select { grid-column: 1; }
|
||||
.am-zp-zeile > .z:not(.am-zp-rest) { grid-column: 2; }
|
||||
}
|
||||
|
||||
@@ -7,6 +7,8 @@ import { wer } from "../domain/einsatz.js";
|
||||
import { projektFarbe } from "../domain/farbe.js";
|
||||
import { type Arbeitswoche, feiertag, istArbeitstag, naechsterArbeitstag, viertelTage, wocheVon } from "../domain/kalender.js";
|
||||
import { type Hilfen, type Plan, besetzungBearbeiten, dauerText, freitagFragen, istReserveFreitag, kalenderwoche } from "./gantt.js";
|
||||
import { imVerzug, sollFortschritt } from "../domain/fortschritt.js";
|
||||
import { heute as heuteOrt } from "./ui.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
type Modus = "tag" | "woche" | "personen";
|
||||
@@ -16,6 +18,8 @@ let montag: Datum | null = null;
|
||||
let tag: Datum | null = null;
|
||||
const TAGE = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"];
|
||||
const OHNE = "(ohne Besetzung)";
|
||||
/** „Mo–Do“ aus den Arbeitstagen der Firma */
|
||||
const tageText = (w: Arbeitswoche) => { const t = [...w.tage].sort(); return t.length ? `${TAGE[t[0]! % 7]}–${TAGE[t.at(-1)! % 7]}` : ""; };
|
||||
const kurzDatum = (d: Datum) => `${TAGE[wochentag(d) % 7]} ${formatDatum(d).slice(0, 6)}`;
|
||||
/** von „Wer macht was“: diesen Vorgang beim nächsten Aufbau öffnen, die Woche des angetippten Tags zeigen */
|
||||
let oeffnen: string | null = null;
|
||||
@@ -30,9 +34,11 @@ export async function terminplanHandy(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const plan = vorhanden ?? await h.api<Plan>("terminplan");
|
||||
const neuLaden = () => void terminplanHandy(h);
|
||||
const woche: Arbeitswoche = { tage: plan.arbeitstage };
|
||||
const heute = new Date().toISOString().slice(0, 10);
|
||||
montag ??= montagDerWoche(heute);
|
||||
tag ??= heute;
|
||||
const heute = heuteOrt();
|
||||
// ab Samstag öffnet die nächste KW (UX-Prüfung, Henning 08.11.2026)
|
||||
const wochenende = wochentag(heute) >= 6;
|
||||
montag ??= montagDerWoche(wochenende ? plusTage(heute, 7) : heute);
|
||||
tag ??= wochenende ? montag : heute;
|
||||
h.seite("Terminplan").remove();
|
||||
|
||||
// Filter wie am PC (gleiche gespeicherte Ansicht)
|
||||
@@ -75,12 +81,16 @@ export async function terminplanHandy(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const ist = Number(v.fortschritt) || 0;
|
||||
const meilenstein = Number(v.dauer) === 0;
|
||||
const pille = meilenstein ? '<span class="marke">◆</span>'
|
||||
: !bs.length ? '<span class="marke schlecht">0 P.</span>'
|
||||
: `<span class="marke${imKonflikt.has(v.id) ? " schlecht" : ""}">${String(zahl).replace(".", ",")} P.</span>`;
|
||||
: !bs.length ? '<span class="marke schlecht">0 Mann</span>'
|
||||
: `<span class="marke${imKonflikt.has(v.id) ? " schlecht" : ""}">${String(zahl).replace(".", ",")} Mann</span>`;
|
||||
// im Verzug wie im Gantt, nur bei beauftragten und laufenden Projekten
|
||||
const fv = { anfang: v.anfang, ende: v.ende, dauer: Number(v.dauer), stunden: v.stunden, fortschritt: v.fortschritt, freitage: v.freitage };
|
||||
const verzug = ["auftrag", "ausfuehrung", "intern"].includes(p.status) && imVerzug(fv, heute, woche)
|
||||
? `<span class="th-verzug">⚠ im Verzug: ${ist} % statt ${sollFortschritt(fv, heute, woche)} %</span>` : "";
|
||||
const unter = meilenstein ? `Meilenstein ${formatDatum(v.anfang)}`
|
||||
: !bs.length ? '<span class="rot">niemand eingeteilt</span>'
|
||||
: `${leute ? esc(leute) : "nur vorgemerkt"}${imKonflikt.has(v.id) ? ' · <span class="rot">doppelt eingeplant</span>' : ""}${ist ? ` · ${ist} % erledigt` : ""}`;
|
||||
return `<li class="th-vorgang" style="--farbe:${farbe(p)}"><button data-v="${v.id}"><span><b>${esc(p.nummer)} ${esc(p.bezeichnung)} · ${esc(v.name)}</b><span class="unter">${unter}</span></span>${pille}</button></li>
|
||||
return `<li class="th-vorgang" style="--farbe:${farbe(p)}"><button data-v="${v.id}"><span><b>${esc(p.nummer)} ${esc(p.bezeichnung)} · ${esc(v.name)}</b><span class="unter">${unter}</span>${verzug}</span>${pille}</button></li>
|
||||
${bs.filter((b) => !b.freigegeben).map((b) => `<li class="th-vorgemerkt"><span><b>${esc(b.anzeige)}</b><span class="unter">${esc(p.nummer)} · ${esc(v.name)} · vorgemerkt</span></span><button class="haupt klein" data-frei="${b.id}">Freigeben</button></li>`).join("")}`;
|
||||
};
|
||||
|
||||
@@ -99,7 +109,9 @@ export async function terminplanHandy(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const kopf = `${kurzDatum(g.von)}${g.bis !== g.von ? ` – ${kurzDatum(g.bis)}` : ""}${g.von <= heute && heute <= g.bis ? ' <span class="th-heute">heute</span>' : ""}${ft ? ` · ${esc(ft.name)}` : g.buero ? " · Bürotag" : ""}`;
|
||||
const liste = g.ids.map((id) => karte(vorgaenge.find((v) => v.id === id)!)).join("");
|
||||
const laufen = g.buero ? vorgaenge.filter((v) => Number(v.dauer) > 0 && v.anfang <= g.von && g.von <= v.ende && !(v.freitage ?? []).includes(g.von)) : [];
|
||||
const reserve = g.buero ? `<li class="th-reserve"><button data-freitag="${g.von}"${laufen.length ? "" : " disabled"}><span>Reserve.${laufen.length ? " Für einzelne Vorgänge freigeben" : " Kein Vorgang läuft über diesen Freitag."}</span>${laufen.length ? "<span>›</span>" : ""}</button></li>` : "";
|
||||
// Freitag-Satz (UX-Prüfung, 08.11.2026): stehen Termine am Freitag, sagt er, dass nur diese fest eingeplant sind
|
||||
const fest = g.ids.length ? (g.ids.length === 1 ? " Nur dieser Termin ist für Freitag fest eingeplant." : " Nur diese Termine sind für Freitag fest eingeplant.") : "";
|
||||
const reserve = g.buero ? `<li class="th-reserve"><button data-freitag="${g.von}"${laufen.length ? "" : " disabled"}><span>Reserve.${fest || (laufen.length ? " Für einzelne Vorgänge freigeben" : " Kein Vorgang läuft über diesen Freitag.")}</span>${laufen.length ? "<span>›</span>" : ""}</button></li>` : "";
|
||||
const leer = !liste && !reserve ? `<li class="th-leer">${ft || !istArbeitstag(g.von, woche) ? "frei" : "nichts geplant"}</li>` : "";
|
||||
return `<h3 class="th-tag">${kopf}</h3><ul class="th-liste">${liste}${reserve}${leer}</ul>`;
|
||||
}).join("");
|
||||
@@ -146,7 +158,7 @@ export async function terminplanHandy(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
${filterChip("person", "Personal", personAus, personWerte)}${filterChip("projekt", "Projekte", projektAus, projektWerte)}</div>
|
||||
${modus === "tag" ? tageHtml([tag]) : modus === "woche" ? tageHtml(wochenTage) : personenHtml()}
|
||||
${modus !== "tag" ? `<section class="karte th-auslastung"><h3>Auslastung KW ${kw}</h3>${prozent === null ? '<p class="hinweis">Keine Verfügbarkeit des Teams in dieser Woche.</p>'
|
||||
: `<div class="balkenanzeige${prozent > 100 ? " ueber" : ""}"><i style="width:${Math.min(100, prozent)}%"></i></div><p class="hinweis">${prozent} % (${Math.round(auslastung!.geplant)} von ${Math.round(auslastung!.verfuegbar)} Std.)${unbesetzt ? ` · <span class="rot">${unbesetzt} ${unbesetzt === 1 ? "Vorgang" : "Vorgänge"} unbesetzt</span>` : ""}</p>`}</section>` : ""}
|
||||
: `<div class="balkenanzeige${prozent > 100 ? " ueber" : ""}"><i style="width:${Math.min(100, prozent)}%"></i></div><p class="hinweis">${prozent === 100 ? "Woche voll: " : prozent > 100 ? "Überplant: " : `${prozent} %: `}${Math.round(auslastung!.geplant)} von ${Math.round(auslastung!.verfuegbar)} Std. (${tageText(woche)})${unbesetzt ? ` · <span class="rot">${unbesetzt} ${unbesetzt === 1 ? "Vorgang" : "Vorgänge"} unbesetzt</span>` : ""}</p>`}</section>` : ""}
|
||||
<p class="hinweis">Vorgänge anlegen und verschieben per Ziehen geht im Gantt am PC.</p></div>`);
|
||||
|
||||
h.inhalt.querySelector<HTMLElement>(".terminplan-handy")!.onclick = async (ev) => {
|
||||
|
||||
@@ -82,7 +82,8 @@ export async function dateiSpeichern(pfad: string, dateiname: string): Promise<s
|
||||
|
||||
export const inhalt = document.getElementById("inhalt")!;
|
||||
export const huelle = document.getElementById("dialog-huelle")!;
|
||||
export const heute = () => new Date().toISOString().slice(0, 10);
|
||||
/** heutiges Datum in Ortszeit (nicht UTC wie toISOString, sonst ist es nach Mitternacht noch „gestern“) */
|
||||
export const heute = () => { const d = new Date(); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`; };
|
||||
export const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
||||
export const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
||||
export const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||||
@@ -360,7 +361,14 @@ export function vorschlaegeAn(feld: HTMLInputElement, uebernehmen: (t: Adressvor
|
||||
let treffer: Adressvorschlag[] = [];
|
||||
let aktiv = -1, zaehler = 0, uhr: ReturnType<typeof setTimeout> | undefined;
|
||||
const zu = () => { liste.hidden = true; feld.setAttribute("aria-expanded", "false"); aktiv = -1; };
|
||||
// Testversion (Henning, 08.11.2026): die Kartensuche geht nur vom Server aus, das Artifact darf nicht nach außen
|
||||
const nurTest = () => !!(globalThis as { betriebTestversion?: unknown }).betriebTestversion && feld.value.trim().length >= 4;
|
||||
const zeichnen = () => {
|
||||
if (!treffer.length && nurTest()) {
|
||||
liste.innerHTML = '<p class="adr-fuss">Keine eigene Adresse gefunden. Neue Adressen aus der Karte (OpenStreetMap) gibt es erst auf dem Server, in der Testversion nur Adressen aus Kontakten und Projekten.</p>';
|
||||
liste.hidden = false;
|
||||
return;
|
||||
}
|
||||
if (!treffer.length) return zu();
|
||||
const karte = treffer.some((t) => t.quelle === "karte");
|
||||
liste.innerHTML = treffer.map((t, i) => `<button type="button" role="option" data-i="${i}" aria-selected="${i === aktiv}"${i === aktiv ? ' class="aktiv"' : ""}>
|
||||
|
||||
@@ -300,14 +300,17 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect(u.aufgaben.ueberfaellig.map((a: { text: string }) => a.text)).toContain("Statik anfragen");
|
||||
const arten = u.warnungen.map((w: { art: string }) => w.art);
|
||||
// vorerst ohne Kontostand (Henning, 23.10.2026): keine Kontostand-Warnung, dafür Geldfluss je Woche
|
||||
expect(arten).toContain("aufgabe");
|
||||
// überfällige Aufgaben stehen in der Zahlenleiste, nicht mehr unter den Warnungen (UX-Prüfung, 08.11.2026)
|
||||
expect(arten).not.toContain("aufgabe");
|
||||
expect(arten).not.toContain("kontostand");
|
||||
expect(u.brennt.map((b: { art: string }) => b.art)).not.toContain("kontostand");
|
||||
expect(u.geld).toEqual(expect.objectContaining({ von: expect.any(String), bis: expect.any(String), betrag: expect.any(Number) }));
|
||||
expect((await app.inject("/api/liquiditaet/lage?wochen=4")).json().mitKontostand).toBe(false);
|
||||
expect(u.fluss[0]).toEqual(expect.objectContaining({ einnahmen: expect.any(Number), projektkosten: expect.any(Number), laufend: expect.any(Number), ust: expect.any(Number) }));
|
||||
const e = (await app.inject("/api/einstellungen")).json();
|
||||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, liquiditaetMitKontostand: true } });
|
||||
const mit = (await app.inject(`/api/uebersicht?heute=${t.ueberschneidungen[0].ab}`)).json();
|
||||
expect(mit.warnungen.find((w: { art: string }) => w.art === "kontostand").text).toMatch(/nicht eingetragen/);
|
||||
expect(mit.brennt.find((w: { art: string }) => w.art === "kontostand")).toMatchObject({ text: "Kontostand nicht eingetragen", ziel: "einstellungen-programmteile" });
|
||||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
|
||||
expect(u.einsatz.tage).toHaveLength(8);
|
||||
// am Handy bis zu vier Wochen und eine Auswahl aller Mitarbeiter, Kolonnen und Subunternehmer
|
||||
@@ -337,6 +340,29 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect((await app.inject(`/api/projekte/${p.id}`)).json().baustelle_ort).toBe("Mölln");
|
||||
});
|
||||
|
||||
it("Zahlungsplan: Zahl der Raten nach Auftragswert, Staffel in den Einstellungen (Henning, 09.11.2026)", async () => {
|
||||
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
|
||||
const raten = async (id: string) => (await app.inject("/api/zahlungen")).json()
|
||||
.filter((z: { projekt_id: string }) => z.projekt_id === id).sort((a: { reihenfolge: number }, b: { reihenfolge: number }) => a.reihenfolge - b.reihenfolge);
|
||||
const p = await neu("projekte", { nummer: "P-26-097", bezeichnung: "Carport Staffel", umsatz_netto: 1_500_000 });
|
||||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Ausführung" });
|
||||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2026-11-09", dauer: 1 });
|
||||
await neu("vorgaenge", { abschnitt_id: a.id, name: "Abnahme", start: "2026-11-16", dauer: 1 });
|
||||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["abschlag", 750_000], ["schluss", 750_000]]);
|
||||
// kleiner geworden: eine Schlussrechnung
|
||||
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 900_000 } });
|
||||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["schluss", 900_000]]);
|
||||
// eigene Staffel: schon ab 5.000 € zwei Raten 30/70
|
||||
const e = (await app.inject("/api/einstellungen")).json();
|
||||
expect(e.zahlungsStaffel).toHaveLength(3);
|
||||
const staffel = [e.zahlungsStaffel[0], { ab: 500_000, raten: [
|
||||
{ bezeichnung: "Anzahlung", prozent: 30, ziel: "auftrag" }, { bezeichnung: "Schluss", prozent: 70, ziel: "schluss" }] }];
|
||||
expect((await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, zahlungsStaffel: staffel } })).statusCode).toBe(200);
|
||||
await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { umsatz_netto: 1_000_000 } });
|
||||
expect((await raten(p.id)).map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["anzahlung", 300_000], ["schluss", 700_000]]);
|
||||
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: e });
|
||||
});
|
||||
|
||||
it("Zahlungsplan entsteht automatisch, folgt Auftragswert und Terminen, bis er von Hand geändert wird", async () => {
|
||||
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
|
||||
const raten = async (id: string) => (await app.inject("/api/zahlungen")).json()
|
||||
@@ -1091,7 +1117,7 @@ describe.skipIf(!url)("Zahlungen, Kosten und Aufgaben im Terminplan", () => {
|
||||
expect(tp.kosten.find((x: { id: string }) => x.id === k.id)).toMatchObject({ vorgang_id: v.id, bezug_art: "AA", bezug_tage: -2 });
|
||||
// Raten: EE mit Versatz
|
||||
const z = (await hole("zahlungen")).filter((x: { projekt_id: string }) => x.projekt_id === p.id);
|
||||
expect(z).toHaveLength(4);
|
||||
expect(z).toHaveLength(2); // 10.000 € netto: zwei Raten (Staffel 09.11.2026)
|
||||
const schluss = z.find((x: { art: string }) => x.art === "schluss");
|
||||
await aendern(`zahlungen/${schluss.id}`, { termin: "2027-06-23" });
|
||||
expect((await hole(`zahlungen/${schluss.id}`))).toMatchObject({ vorgang_id: v.id, bezug_art: "EE", bezug_tage: 3 });
|
||||
@@ -1308,6 +1334,28 @@ describe.skipIf(!url)("Angebote mit Kalkulation (Stufe 3a)", () => {
|
||||
expect((await post(`angebote/${a.id}/annehmen`)).statusCode).toBe(409);
|
||||
});
|
||||
|
||||
it("Zahlungsplan im Angebot: Vorschlag nach Angebotssumme, je Angebot änderbar, beim Annehmen ins Projekt (Henning, 09.11.2026)", async () => {
|
||||
const p = await neu("projekte", { nummer: "A-26-141", bezeichnung: "Vordach Zahlungsplan" });
|
||||
const a = await neu("angebote/neu", { projekt_id: p.id });
|
||||
await neu("angebot-positionen", { angebot_id: a.id, kurztext: "Vordach pauschal", menge: 1, einheit: "psch", ep_fest: 1_500_000 });
|
||||
let voll = await hole(`angebote/${a.id}/voll`);
|
||||
expect(voll.ergebnis.netto).toBe(1_500_000);
|
||||
expect(voll.zahlungsplan).toMatchObject({ eigen: false, raten: [{ prozent: 50, ziel: "richten", netto: 750_000 }, { prozent: 50, ziel: "schluss", netto: 750_000 }] });
|
||||
expect(voll.zahlungsplan.raten.reduce((x: number, r: { brutto: number }) => x + r.brutto, 0)).toBe(voll.ergebnis.brutto);
|
||||
// eigener Plan: 30 % Anzahlung, Rest Schluss
|
||||
const eigen = [{ bezeichnung: "Anzahlung", prozent: 30, ziel: "auftrag" }, { bezeichnung: "Schlussrechnung", prozent: 70, ziel: "schluss" }];
|
||||
const pa = await app.inject({ method: "PATCH", url: `/api/angebote/${a.id}`, payload: { zahlungsplan: eigen } });
|
||||
expect(pa.statusCode, pa.body).toBe(200);
|
||||
voll = await hole(`angebote/${a.id}/voll`);
|
||||
expect(voll.zahlungsplan.eigen).toBe(true);
|
||||
expect(voll.zahlungsplan.raten.map((r: { netto: number }) => r.netto)).toEqual([450_000, 1_050_000]);
|
||||
await post(`angebote/${a.id}/annehmen`, { start: "2027-03-01" });
|
||||
expect((await hole(`projekte/${p.id}`)).zahlungsplan_raten).toEqual(eigen);
|
||||
const raten = (await hole("zahlungen")).filter((z: { projekt_id: string }) => z.projekt_id === p.id)
|
||||
.sort((x: { reihenfolge: number }, y: { reihenfolge: number }) => x.reihenfolge - y.reihenfolge);
|
||||
expect(raten.map((z: { art: string; netto: number }) => [z.art, z.netto])).toEqual([["anzahlung", 450_000], ["schluss", 1_050_000]]);
|
||||
});
|
||||
|
||||
it("Bindefrist: Erinnerung auf der Startseite 5 Tage vorher und Termin im Aufgaben-Kalender (A35)", async () => {
|
||||
const p = await neu("projekte", { nummer: "A-26-140", bezeichnung: "Dachgaube Lüders" });
|
||||
const a = await neu("angebote/neu", { projekt_id: p.id });
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { flussJeWoche } from "../src/domain/lage.js";
|
||||
import { flussJeWoche, geldAbHeute } from "../src/domain/lage.js";
|
||||
import { projektFarbe, FARBEN } from "../src/domain/farbe.js";
|
||||
|
||||
describe("Geldfluss ohne Kontostand und Projektfarben", () => {
|
||||
@@ -14,11 +14,25 @@ describe("Geldfluss ohne Kontostand und Projektfarben", () => {
|
||||
expect(w).toEqual({ von: "2026-11-02", bis: "2026-11-08", einnahmen: 100000, projektkosten: 40000, laufend: 5000, ust: -2000 });
|
||||
});
|
||||
|
||||
it("Geld bis: vier Wochen ab heute, Überfälliges zählt mit, Vergangenes und Späteres nicht (UX-Prüfung 08.11.2026)", () => {
|
||||
const g = geldAbHeute([{ von: "2026-11-09", bis: "2026-11-15", einnahmen: 0, ausgaben: 0, saldo: 0, kontostand: 0, posten: [
|
||||
{ datum: "2026-11-02", gruppe: "Projekteinnahmen", bezeichnung: "überfällig", betrag: 50000, ueberfaelligSeit: "2026-11-02" },
|
||||
{ datum: "2026-11-05", gruppe: "Laufende Kosten", bezeichnung: "schon bezahlt", betrag: -7000 },
|
||||
{ datum: "2026-11-10", gruppe: "Projektkosten", bezeichnung: "Material", betrag: -20000 },
|
||||
{ datum: "2026-11-12", gruppe: "Umsatzsteuer", bezeichnung: "USt", betrag: -3000 },
|
||||
{ datum: "2026-12-07", gruppe: "Projekteinnahmen", bezeichnung: "zu spät", betrag: 99999 },
|
||||
] }] as never, "2026-11-09");
|
||||
expect(g).toEqual({ von: "2026-11-09", bis: "2026-12-06", einnahmen: 50000, projektkosten: 20000, laufend: 0, ust: 3000, betrag: 27000 });
|
||||
});
|
||||
|
||||
it("Farbe nach Stelle unter den nicht abgeschlossenen Projekten, eigene Farbe geht vor", () => {
|
||||
const alle = [{ id: "a", status: "abgeschlossen" }, { id: "b", status: "auftrag" }, { id: "c", status: "angebot" }];
|
||||
expect(projektFarbe({ id: "b" }, alle)).toBe(FARBEN[0]);
|
||||
expect(projektFarbe({ id: "c" }, alle)).toBe(FARBEN[1]);
|
||||
expect(projektFarbe({ id: "a" }, alle)).toBe("#718096");
|
||||
expect(projektFarbe({ id: "c", farbe: "#123456" }, alle)).toBe("#123456");
|
||||
// Rot ist keine Projektfarbe mehr
|
||||
expect(FARBEN).not.toContain("#c53030");
|
||||
expect(projektFarbe({ id: "c", farbe: "#c53030" }, alle)).toBe("#7a4a24");
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe, schlageZahlungsplanVor } from "../src/domain/geld.js";
|
||||
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe, schlageZahlungsplanVor, ratenFuer, STANDARD_STAFFEL } from "../src/domain/geld.js";
|
||||
import { stundenZuArbeitstagen } from "../src/domain/arbeitszeit.js";
|
||||
|
||||
describe("Prozent und Umsatzsteuer", () => {
|
||||
@@ -93,6 +93,18 @@ describe("Zahlungsplan als Meilensteine vorschlagen", () => {
|
||||
]);
|
||||
});
|
||||
|
||||
it("Anzahl der Raten nach Auftragswert: unter 10.000 € eine, bis 20.000 € zwei, darüber vier (Henning, 09.11.2026)", () => {
|
||||
expect(ratenFuer(999_999).map((r) => r.prozent)).toEqual([100]);
|
||||
expect(ratenFuer(1_000_000).map((r) => r.prozent)).toEqual([50, 50]);
|
||||
expect(ratenFuer(1_999_999)).toHaveLength(2);
|
||||
expect(ratenFuer(2_000_000).map((r) => r.prozent)).toEqual([30, 40, 20, 10]);
|
||||
expect(ratenFuer(500, [{ ab: 1000, raten: STANDARD_STAFFEL[1]!.raten }])).toHaveLength(2);
|
||||
const eine = schlageZahlungsplanVor(800_000, vs, "2026-10-20", ratenFuer(800_000));
|
||||
expect(eine.map((r) => [r.art, r.netto, r.vorgang_id])).toEqual([["schluss", 800_000, "abnahme"]]);
|
||||
const zwei = schlageZahlungsplanVor(1_500_001, vs, "2026-10-20", ratenFuer(1_500_001));
|
||||
expect(zwei.map((r) => [r.art, r.netto, r.vorgang_id])).toEqual([["abschlag", 750_001, "richten"], ["schluss", 750_000, "abnahme"]]);
|
||||
});
|
||||
|
||||
it("geht auch ohne passende Namen und ohne Vorgänge", () => {
|
||||
const z = schlageZahlungsplanVor(100_001, vs.slice(2, 4), "2026-12-01");
|
||||
expect(z.map((r) => r.vorgang_id)).toEqual([null, "dach", "rest", "rest"]);
|
||||
|
||||
@@ -65,13 +65,13 @@ describe("Auslastung je Woche (T16)", () => {
|
||||
});
|
||||
|
||||
describe("freigegebener Freitag (Henning, 21.10.2026)", () => {
|
||||
it("zählt bei Dauer und Auslastung nur für den Vorgang und seine Leute", () => {
|
||||
it("zählt bei der Dauer mit, die Auslastung rechnet nur Mo–Do (UX-Prüfung, 08.11.2026)", () => {
|
||||
const v = { id: "v", start: "2026-11-16", stunden: 38.5, freitage: ["2026-11-20"] };
|
||||
// Jan arbeitet freitags 6,5 Std.: Mo–Do 32 + Fr 6,5 = 38,5 in einer Woche
|
||||
expect(dauerNachBesetzung(v, [{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }], p, W)).toBe(5);
|
||||
const w = auslastung("2026-11-16", "2026-11-22", ["jan", "tim"],
|
||||
[{ id: "v", anfang: "2026-11-16", ende: "2026-11-20", dauer: 5, freitage: ["2026-11-20"] }],
|
||||
[{ vorgang_id: "v", kontakt_id: "jan", personen: 1 }], p, W);
|
||||
expect(w[0]!.personen).toEqual([{ kontakt_id: "jan", geplant: 38.5, verfuegbar: 38.5 }, { kontakt_id: "tim", geplant: 0, verfuegbar: 16 }]);
|
||||
expect(w[0]!.personen).toEqual([{ kontakt_id: "jan", geplant: 32, verfuegbar: 32 }, { kontakt_id: "tim", geplant: 0, verfuegbar: 16 }]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -4,12 +4,12 @@ import { STANDARDWOCHE as W } from "../src/domain/kalender.js";
|
||||
|
||||
describe("Aufgaben wie in V70 gruppiert", () => {
|
||||
const a = (id: string, faellig_am: string | null, extra = {}) => ({ id, text: id, faellig_am, ...extra });
|
||||
it("überfällig, diese Woche bis Sonntag, langfristig; erledigte fallen weg", () => {
|
||||
it("überfällig, nächste 7 Tage, später; erledigte fallen weg", () => {
|
||||
// Mittwoch, 21.10.2026
|
||||
const g = aufgabenGruppen([a("alt", "2026-10-20"), a("so", "2026-10-25"), a("mo", "2026-10-26"), a("ohne", null), a("fertig", "2026-10-21", { erledigt_am: "x" }), a("lang", "2026-10-22", { langfristig: true })], "2026-10-21");
|
||||
expect(g.ueberfaellig.map((x) => x.id)).toEqual(["alt"]);
|
||||
expect(g.dieseWoche.map((x) => x.id)).toEqual(["so"]);
|
||||
expect(g.langfristig.map((x) => x.id)).toEqual(["lang", "mo", "ohne"]);
|
||||
expect(g.naechste7.map((x) => x.id)).toEqual(["so", "mo"]);
|
||||
expect(g.spaeter.map((x) => x.id)).toEqual(["lang", "ohne"]);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user