refactor(dashboard): Seiten von der Datenquelle entkoppeln

Die Seiten holten ihre Zahlen selbst aus einem globalen Store. HiveGrid Cloud
verlangt reine Screens nach dem Muster <XPage vm={} actions={} /> — jede Seite
hätte beim Einbau auseinandergenommen werden müssen.

Neue Schichtung:

  view-models/<seite>.vm.ts   baue<Seite>VM(daten, filter) → VMState<…>
                              reine Funktion, kein React, kein Store
  pages/<Seite>.tsx           ({ vm, optionen }) → JSX      wird portiert
  routes/<Seite>Route.tsx     Store + Builder + Seite       wird ersetzt

view-models/index.ts spiegelt VMState wortgleich aus @hivegrid/view-models;
beim Einbau ist es ein Import-Wechsel. Der Loader ruft denselben Builder mit
echten Daten, die Seiten bleiben unberührt.

Dabei abgefallen: die fünf Seitenzustände (idle · loading · ready · empty ·
error) über SeitenZustand — bisher lief der Prototyp nur im Zustand "Daten da",
in der Cloud sind alle fünf DoD-Pflicht. Die Filterleiste bekommt ihre
Auswahllisten jetzt als Prop (in der Software die Facetten aus dem Loader)
statt sie selbst aus dem Datensatz zu ziehen.

Store- und Rohdatenzugriff gibt es damit ausschließlich in routes/. Alle sechs
Seiten rendern pixelgleich; typecheck, lint und build sind grün.

Nicht geändert: Next.js bleibt. Im gesamten Projekt gibt es vier
Next-spezifische Importe, alle in AppShell und app/layout — beide Dateien
entfallen beim Einbau ohnehin, weil die Cloud Shell und Root-Layout mitbringt.
Ein Framework-Wechsel wäre Aufwand ohne Ertrag.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QPeZNwSeU7qG3RRCwaxEZX
This commit is contained in:
dejanandClaude Opus 5 committed 2026-08-29 17:39:41 +02:00
1 parent b8bf987d0e
commit 99be627dad
28 files changed
+1030 -340

No files matched your search

@@ -0,0 +1,87 @@
/**
* View-Model der Auftragsseite.
*
* Reine Funktion über typisierten Eingangsdaten — kein React, kein Store, kein
* Zugriff auf `DATENSATZ`. Genau diese Grenze macht den Einbau billig: In der
* Software ruft der Loader denselben Builder mit echten Daten auf, die
* Screen-Komponente bleibt unverändert.
*/
import {
abschlussquote,
aktiveAuftraege,
auftraegeImZeitraum,
auftraegeNachGewerk,
auftraegeNachStatus,
auftragseingang,
durchlaufzeit,
foerderQuote,
ueberfaelligeAuftraege,
vertriebsTrichter,
} from "../data/calculations";
import type {
Auftrag,
ChartPunkt,
Datensatz,
FilterState,
ZeitreihePunkt,
} from "../data/types";
import { imFenster, vorperiode } from "../utils/dateUtils";
import { bereit, leer, type VMState } from "./index";
export interface AuftraegeDaten {
readonly imZeitraum: Auftrag[];
readonly vorher: Auftrag[];
readonly aktiv: Auftrag[];
readonly ueberfaellig: Auftrag[];
readonly quote: number;
readonly laufzeit: number;
readonly eingang: ZeitreihePunkt[];
readonly sparkline: number[];
readonly bestand: number;
readonly durchschnittAuftragswert: number;
readonly trichter: ChartPunkt[];
readonly statusVerteilung: ChartPunkt[];
readonly gewerkAnzahl: ChartPunkt[];
readonly foerderung: ReturnType<typeof foerderQuote>;
readonly foerderungJeAuftrag: number;
/**
* Namen je Id. Der Auftrag trägt nur die Ids; die Auflösung gehört zu den
* Daten, nicht in die Zellen-Funktion der Tabelle.
*/
readonly mitarbeiterName: ReadonlyMap<string, string>;
readonly kundeName: ReadonlyMap<string, string>;
}
export function baueAuftraegeVM(daten: Datensatz, filter: FilterState): VMState<AuftraegeDaten> {
// Kein Auftrag und keine Rechnung heisst: Die Filter schneiden alles weg.
// Das ist ein Leerzustand, kein Fehler.
if (!daten.auftraege.length && !daten.rechnungen.length) return leer();
const imZeitraum = auftraegeImZeitraum(daten.auftraege, filter.zeitraum);
const aktiv = aktiveAuftraege(daten.auftraege);
const eingang = auftragseingang(daten.auftraege, filter.zeitraum);
const foerderung = foerderQuote(daten.auftraege);
return bereit({
imZeitraum,
vorher: daten.auftraege.filter((a) => imFenster(a.angelegtAm, vorperiode(filter.zeitraum))),
aktiv,
ueberfaellig: ueberfaelligeAuftraege(daten.auftraege),
quote: abschlussquote(daten.auftraege),
laufzeit: durchlaufzeit(daten.auftraege),
eingang,
sparkline: eingang.slice(-10).map((p) => p.value),
bestand: aktiv.reduce((s, a) => s + a.wert, 0),
durchschnittAuftragswert: imZeitraum.length
? imZeitraum.reduce((s, a) => s + a.wert, 0) / imZeitraum.length
: 0,
trichter: vertriebsTrichter(daten.auftraege),
statusVerteilung: auftraegeNachStatus(daten.auftraege),
gewerkAnzahl: auftraegeNachGewerk(daten.auftraege),
foerderung,
foerderungJeAuftrag: foerderung.bewilligt ? foerderung.summe / foerderung.bewilligt : 0,
mitarbeiterName: new Map(daten.mitarbeiter.map((m) => [m.id, m.name])),
kundeName: new Map(daten.kunden.map((k) => [k.id, k.name])),
});
}
@@ -0,0 +1,34 @@
/**
* Auswahlmöglichkeiten der Filterleiste.
*
* Reine Funktion über dem vollständigen Datensatz — bewusst **nicht** über den
* gefilterten. Sonst verschwindet eine Option, sobald man sie abwählt, und der
* Filter lässt sich nicht mehr zurücknehmen.
*
* In HiveGrid Cloud kommen diese Listen aus dem Loader (dort „Facetten", siehe
* `BoardFilterBar` mit `facets` aus dem View-Model). Deshalb werden sie auch
* hier von außen hereingereicht und nicht in der Leiste selbst ermittelt.
*/
import type { Datensatz } from "../data/types";
export interface FilterOptionen {
readonly quellen: string[];
readonly regionen: string[];
readonly monteure: { wert: string; label: string; zusatz: string }[];
/** Id → Name, für die Beschriftung der aktiven Filter-Chips. */
readonly mitarbeiterNamen: Record<string, string>;
}
export function baueFilterOptionen(daten: Datensatz): FilterOptionen {
const monteure = daten.mitarbeiter
.filter((m) => m.rolle === "Monteur" || m.rolle === "Meister")
.map((m) => ({ wert: m.id, label: m.name, zusatz: m.gewerk }));
return {
quellen: [...new Set(daten.kunden.map((k) => k.quelle))].sort(),
regionen: [...new Set(daten.kunden.map((k) => k.region))].sort(),
monteure,
mitarbeiterNamen: Object.fromEntries(daten.mitarbeiter.map((m) => [m.id, m.name])),
};
}
@@ -0,0 +1,60 @@
/**
* View-Model der Finanzseite.
*
* Reine Funktion über typisierten Eingangsdaten — kein React, kein Store, kein
* Zugriff auf `DATENSATZ`. Genau diese Grenze macht den Einbau billig: In der
* Software ruft der Loader denselben Builder mit echten Daten auf, die
* Screen-Komponente bleibt unverändert.
*/
import {
marge,
offeneNachStatus,
offenePosten,
umsatz,
umsatzNachGewerk,
umsatzVerlauf,
umsatzVorperiode,
zahlungsdauer,
type OffenePosten,
} from "../data/calculations";
import type { ChartPunkt, Datensatz, FilterState, ZeitreihePunkt } from "../data/types";
import { bereit, leer, type VMState } from "./index";
export interface FinanzenDaten {
readonly umsatzAktuell: number;
readonly umsatzVorher: number;
readonly verlauf: ZeitreihePunkt[];
readonly sparkline: number[];
readonly posten: OffenePosten;
readonly zahlungsdauerTage: number;
readonly margeProzent: number;
readonly offenNachStatus: ChartPunkt[];
readonly gewerkUmsatz: ChartPunkt[];
/**
* Kundenname je Id. Die Rechnung trägt nur die Id; die Auflösung gehört zu den
* Daten, nicht in die Zellen-Funktion der Tabelle.
*/
readonly kundeName: ReadonlyMap<string, string>;
}
export function baueFinanzenVM(daten: Datensatz, filter: FilterState): VMState<FinanzenDaten> {
// Kein Auftrag und keine Rechnung heisst: Die Filter schneiden alles weg.
// Das ist ein Leerzustand, kein Fehler.
if (!daten.auftraege.length && !daten.rechnungen.length) return leer();
const verlauf = umsatzVerlauf(daten.rechnungen, filter.zeitraum);
return bereit({
umsatzAktuell: umsatz(daten.rechnungen, filter.zeitraum),
umsatzVorher: umsatzVorperiode(daten.rechnungen, filter.zeitraum),
verlauf,
sparkline: verlauf.slice(-10).map((p) => p.value),
posten: offenePosten(daten.rechnungen),
zahlungsdauerTage: zahlungsdauer(daten.rechnungen, filter.zeitraum),
margeProzent: marge(daten.auftraege, filter.zeitraum),
offenNachStatus: offeneNachStatus(daten.rechnungen),
gewerkUmsatz: umsatzNachGewerk(daten.auftraege, daten.rechnungen, filter.zeitraum),
kundeName: new Map(daten.kunden.map((k) => [k.id, k.name])),
});
}
+48
View File
@@ -0,0 +1,48 @@
/**
* View-Model-Vertrag.
*
* Wortgleicher Spiegel von `VMState` aus `@hivegrid/view-models` in HiveGrid
* Cloud (`packages/view-models/src/index.ts`). Beim Einbau wird dieser Import
* gegen das echte Paket getauscht — die Seiten selbst ändern sich dabei nicht.
*
* Warum das hier überhaupt steht: Die Cloud trennt strikt zwischen Route und
* Screen. Die Route besitzt Loader, Actions und Realtime; die Screen-Komponente
* ist rein und bekommt alles als Prop (`<XPage vm={} actions={} />`). Eine
* Komponente, die sich ihre Daten selbst aus einem Store holt, muss beim Einbau
* auseinandergenommen werden — genau das soll dieser Prototyp ersparen.
*/
export type VMStatus = "idle" | "loading" | "ready" | "empty" | "error";
export type VMState<T> =
| { status: "idle"; data?: undefined; error?: undefined }
| { status: "loading"; data?: T; error?: undefined }
| { status: "ready"; data: T; error?: undefined }
| { status: "empty"; data?: undefined; error?: undefined }
| { status: "error"; data?: T; error: { messageKey: string; code?: string } };
/** Kurzform für den Normalfall im Prototyp: Daten liegen vor. */
export function bereit<T>(data: T): VMState<T> {
return { status: "ready", data };
}
/** Kein Datensatz für die aktuelle Auswahl — nicht dasselbe wie ein Fehler. */
export function leer<T>(): VMState<T> {
return { status: "empty" };
}
/**
* Aktionen einer Seite.
*
* Im Prototyp lösen sie einen Hinweis-Toast aus; in der Software werden daraus
* Navigationen und Schreibpfade. Wichtig ist die Form: Der Screen ruft einen
* Callback auf, er kennt weder Router noch Fetcher.
*/
export interface SeitenAktionen {
/** Absprung in eine Arbeitsliste, z. B. aus dem Handlungsbedarf. */
readonly onAbsprung?: (ziel: string, kontext?: string) => void;
/** Datensatz in der Tabelle geöffnet. */
readonly onZeileOeffnen?: (id: string) => void;
/** Ansicht neu laden. */
readonly onAktualisieren?: () => void;
}
@@ -0,0 +1,66 @@
/**
* View-Model der Kundenseite.
*
* Reine Funktion über typisierten Eingangsdaten — kein React, kein Store, kein
* Zugriff auf `DATENSATZ`. Genau diese Grenze macht den Einbau billig: In der
* Software ruft der Loader denselben Builder mit echten Daten auf, die
* Screen-Komponente bleibt unverändert.
*/
import {
inaktiveKunden,
kundenEntwicklung,
kundenNach,
neueKunden,
neueKundenVorperiode,
topKunden,
wiederkehrquote,
zahlungsauffaellig,
} from "../data/calculations";
import type { ChartPunkt, Datensatz, FilterState, Kunde, ZeitreihePunkt } from "../data/types";
import { bereit, leer, type VMState } from "./index";
export interface KundenDaten {
readonly kundenGesamt: number;
readonly kundenMitAuftrag: number;
readonly neueKunden: number;
readonly neueKundenVorher: number;
readonly entwicklung: ZeitreihePunkt[];
readonly sparkline: number[];
readonly wiederkehrendProzent: number;
readonly kundenwert: number;
readonly inaktive: Kunde[];
readonly auffaellige: Kunde[];
readonly nachQuelle: ChartPunkt[];
readonly nachTyp: ChartPunkt[];
readonly topKunden: ChartPunkt[];
}
export function baueKundenVM(daten: Datensatz, filter: FilterState): VMState<KundenDaten> {
// Kein Kunde in der Auswahl heisst: Die Filter schneiden alles weg.
// Das ist ein Leerzustand, kein Fehler.
if (!daten.kunden.length) return leer();
const entwicklung = kundenEntwicklung(daten.kunden, filter.zeitraum);
const mitAuftrag = daten.kunden.filter((k) => k.auftraegeGesamt > 0);
return bereit({
kundenGesamt: daten.kunden.length,
kundenMitAuftrag: mitAuftrag.length,
neueKunden: neueKunden(daten.kunden, filter.zeitraum),
neueKundenVorher: neueKundenVorperiode(daten.kunden, filter.zeitraum),
entwicklung,
sparkline: entwicklung.slice(-10).map((p) => p.value),
wiederkehrendProzent: wiederkehrquote(daten.kunden),
// Bezugsgrösse ist der Kunde mit Historie — Karteileichen würden den
// Durchschnitt nach unten ziehen.
kundenwert: mitAuftrag.length
? mitAuftrag.reduce((s, k) => s + k.umsatzGesamt, 0) / mitAuftrag.length
: 0,
inaktive: inaktiveKunden(daten.kunden),
auffaellige: zahlungsauffaellig(daten.kunden),
nachQuelle: kundenNach(daten.kunden, "quelle"),
nachTyp: kundenNach(daten.kunden, "typ"),
topKunden: topKunden(daten.kunden, 6),
});
}
+84
View File
@@ -0,0 +1,84 @@
/**
* View-Model der Teamseite.
*
* Reine Funktion über typisierten Eingangsdaten — kein React, kein Store, kein
* Zugriff auf `DATENSATZ`. Genau diese Grenze macht den Einbau billig: In der
* Software ruft der Loader denselben Builder mit echten Daten auf, die
* Screen-Komponente bleibt unverändert.
*/
import { teamKennzahlen, type MitarbeiterKennzahl } from "../data/calculations";
import type { ChartPunkt, Datensatz, FilterState } from "../data/types";
import { imFenster, zeitfenster } from "../utils/dateUtils";
import { bereit, leer, type VMState } from "./index";
/**
* Tabellenzeile der Mitarbeiterübersicht.
*
* Die `id` hängt hier und nicht in der Seite, weil die Tabelle einen stabilen
* Schlüssel braucht — das ist eine Eigenschaft des Datensatzes, keine der
* Darstellung.
*/
export type TeamZeile = MitarbeiterKennzahl & { readonly id: string };
export interface TeamDaten {
readonly mitarbeiterGesamt: number;
readonly aktive: MitarbeiterKennzahl[];
readonly durchschnittAuslastung: number;
readonly stundenGesamt: number;
readonly produktivGesamt: number;
readonly produktivQuote: number;
readonly abwesenheitStunden: number;
readonly abwesenheitNach: ChartPunkt[];
readonly zeilen: TeamZeile[];
}
/** Anzeigenamen der Abwesenheitsgründe — die Rohwerte sind Kleinschreibung. */
const ABWESENHEIT_LABEL: Record<string, string> = {
urlaub: "Urlaub",
krank: "Krank",
fortbildung: "Fortbildung",
};
export function baueTeamVM(daten: Datensatz, filter: FilterState): VMState<TeamDaten> {
// Kein Mitarbeiter in der Auswahl heisst: Die Filter schneiden alles weg.
// Das ist ein Leerzustand, kein Fehler.
if (!daten.mitarbeiter.length) return leer();
const kennzahlen = teamKennzahlen(
daten.mitarbeiter,
daten.zeiten,
daten.auftraege,
filter.zeitraum
);
const aktive = kennzahlen.filter((k) => k.mitarbeiter.status === "aktiv");
// Kennzahlen beziehen sich auf die aktiven Kräfte: Ausgetretene hätten null
// Stunden und würden jeden Durchschnitt verzerren.
const stundenGesamt = aktive.reduce((s, k) => s + k.stunden, 0);
const produktivGesamt = aktive.reduce((s, k) => s + k.produktivStunden, 0);
const fenster = zeitfenster(filter.zeitraum);
const abwesenheiten = daten.zeiten.filter(
(z) => z.art === "abwesenheit" && imFenster(z.datum, fenster)
);
const zaehler = new Map<string, number>();
for (const eintrag of abwesenheiten) {
const name = ABWESENHEIT_LABEL[eintrag.abwesenheitsgrund ?? "sonstige"] ?? "Sonstige";
zaehler.set(name, (zaehler.get(name) ?? 0) + eintrag.stunden);
}
return bereit({
mitarbeiterGesamt: kennzahlen.length,
aktive,
durchschnittAuslastung: aktive.length
? aktive.reduce((s, k) => s + k.auslastungProzent, 0) / aktive.length
: 0,
stundenGesamt,
produktivGesamt,
produktivQuote: stundenGesamt > 0 ? (produktivGesamt / stundenGesamt) * 100 : 0,
abwesenheitStunden: abwesenheiten.reduce((s, a) => s + a.stunden, 0),
abwesenheitNach: [...zaehler.entries()].map(([name, value]) => ({ name, value })),
zeilen: kennzahlen.map((k) => ({ ...k, id: k.mitarbeiter.id })),
});
}
@@ -0,0 +1,89 @@
/**
* View-Model der Übersichtsseite.
*
* Reine Funktion über typisierten Eingangsdaten — kein React, kein Store, kein
* Zugriff auf `DATENSATZ`. Genau diese Grenze macht den Einbau billig: In der
* Software ruft der Loader denselben Builder mit echten Daten auf, die
* Screen-Komponente bleibt unverändert.
*/
import {
aktiveAuftraege,
handlungsbedarf,
marge,
neueKunden,
neueKundenVorperiode,
offenePosten,
teamKennzahlen,
ueberfaelligeAuftraege,
umsatz,
umsatzNachGewerk,
umsatzVerlauf,
umsatzVorperiode,
vertriebsTrichter,
zahlungsdauer,
type AlertEintrag,
type OffenePosten,
type MitarbeiterKennzahl,
} from "../data/calculations";
import type { Auftrag, ChartPunkt, FilterState, Datensatz, ZeitreihePunkt } from "../data/types";
import { bereit, leer, type VMState } from "./index";
export interface UebersichtDaten {
readonly umsatzAktuell: number;
readonly umsatzVorher: number;
readonly margeProzent: number;
readonly zahlungsdauerTage: number;
readonly verlauf: ZeitreihePunkt[];
readonly sparkline: number[];
readonly posten: OffenePosten;
readonly aktiveAuftraege: Auftrag[];
readonly auftragsbestand: number;
readonly ueberfaellige: Auftrag[];
readonly monteureAktiv: MitarbeiterKennzahl[];
readonly durchschnittAuslastung: number;
readonly neueKunden: number;
readonly neueKundenVorher: number;
readonly kundenMitAuftrag: number;
readonly gewerkUmsatz: ChartPunkt[];
readonly trichter: ChartPunkt[];
readonly alerts: AlertEintrag[];
readonly durchschnittAuftragswert: number;
}
export function baueUebersichtVM(daten: Datensatz, filter: FilterState): VMState<UebersichtDaten> {
// Kein Auftrag und keine Rechnung heisst: Die Filter schneiden alles weg.
// Das ist ein Leerzustand, kein Fehler.
if (!daten.auftraege.length && !daten.rechnungen.length) return leer();
const verlauf = umsatzVerlauf(daten.rechnungen, filter.zeitraum);
const team = teamKennzahlen(daten.mitarbeiter, daten.zeiten, daten.auftraege, filter.zeitraum);
const monteureAktiv = team.filter((t) => t.mitarbeiter.status === "aktiv");
const aktiv = aktiveAuftraege(daten.auftraege);
return bereit({
umsatzAktuell: umsatz(daten.rechnungen, filter.zeitraum),
umsatzVorher: umsatzVorperiode(daten.rechnungen, filter.zeitraum),
margeProzent: marge(daten.auftraege, filter.zeitraum),
zahlungsdauerTage: zahlungsdauer(daten.rechnungen, filter.zeitraum),
verlauf,
sparkline: verlauf.slice(-10).map((p) => p.value),
posten: offenePosten(daten.rechnungen),
aktiveAuftraege: aktiv,
auftragsbestand: aktiv.reduce((summe, a) => summe + a.wert, 0),
ueberfaellige: ueberfaelligeAuftraege(daten.auftraege),
monteureAktiv,
durchschnittAuslastung: monteureAktiv.length
? monteureAktiv.reduce((s, t) => s + t.auslastungProzent, 0) / monteureAktiv.length
: 0,
neueKunden: neueKunden(daten.kunden, filter.zeitraum),
neueKundenVorher: neueKundenVorperiode(daten.kunden, filter.zeitraum),
kundenMitAuftrag: daten.kunden.filter((k) => k.auftraegeGesamt > 0).length,
gewerkUmsatz: umsatzNachGewerk(daten.auftraege, daten.rechnungen, filter.zeitraum),
trichter: vertriebsTrichter(daten.auftraege),
alerts: handlungsbedarf(daten),
durchschnittAuftragswert: daten.auftraege.length
? daten.auftraege.reduce((s, a) => s + a.wert, 0) / daten.auftraege.length
: 0,
});
}