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:
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])),
|
||||
});
|
||||
}
|
||||
@@ -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),
|
||||
});
|
||||
}
|
||||
@@ -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,
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user