feat(dashboard): Analytics-Dashboard als Gestaltungsvorlage zur Übergabe

UI/UX-Prototyp der Analytics-Dashboards in HiveGrid, fachlich auf einen
SHK-/Handwerksbetrieb zugeschnitten. Ziel ist die Übergabe an die Entwicklung,
nicht der Produktivbetrieb.

Inhalt: sechs Seiten (Übersicht, Finanzen, Aufträge, Kunden, Team, Komponenten),
26 KPIs, neun Chart-Bausteine, Filtersystem mit seitenabhängiger Relevanz und ein
deterministischer Demo-Datensatz (420 Kunden, 1.900 Aufträge, Stichtag 30.07.2026).

Drei Quellen sind zusammengeführt: die fachliche Planung mit dem Branchenpartner
(Januar 2026), die Subframe-Komponentenbibliothek aus dem HiveGrid-Pitch und
IBM Carbon Data Visualization für die Diagrammregeln. Herkunft und bewusste
Abweichungen stehen in docs/HERKUNFT.md.

Dokumentation: README, HANDOVER (was echte Logik braucht), docs/DESIGN-SYSTEM,
KPI-KATALOG, DATENMODELL, NAVIGATION, HERKUNFT, ZIELSYSTEM (Einbauort in
HiveGrid Cloud) und LEITPLANKEN (welche Cloud-Screens als Vorbild taugen).

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:25:20 +02:00
commit b8bf987d0e
250 files changed
+33153

No files matched your search

+287
View File
@@ -0,0 +1,287 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer, Raster } from "../components/layout/PageContainer";
import { AnalyticsToolbar } from "../components/filters/AnalyticsToolbar";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { StatZeile } from "../components/cards/StatZeile";
import { BalkenVertikal } from "../components/charts/BalkenVertikal";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { Donut } from "../components/charts/Donut";
import { Trichter } from "../components/charts/Trichter";
import { DataTable, type Spalte } from "../components/tables/DataTable";
import { AuftragBadge } from "../components/tables/StatusBadge";
import { useAnalyseDaten } from "../hooks/useAnalyseDaten";
import {
abschlussquote,
aktiveAuftraege,
auftraegeImZeitraum,
auftraegeNachGewerk,
auftraegeNachStatus,
auftragseingang,
durchlaufzeit,
foerderQuote,
ueberfaelligeAuftraege,
vertriebsTrichter,
} from "../data/calculations";
import {
berechneTrend,
formatDatum,
formatEuro,
formatEuroKompakt,
formatProzent,
formatTage,
formatZahl,
tageSeit,
tageLabel,
tageLabelDativ,
} from "../utils/formatters";
import { STATUS_TEXT } from "../utils/chartTheme";
import { HEUTE, vorperiode, imFenster } from "../utils/dateUtils";
import type { Auftrag } from "../data/types";
export function AuftraegeSeite() {
const { daten, filter } = useAnalyseDaten("auftraege");
const imZeitraum = auftraegeImZeitraum(daten.auftraege, filter.zeitraum);
const vorher = daten.auftraege.filter((a) => imFenster(a.angelegtAm, vorperiode(filter.zeitraum)));
const aktiv = aktiveAuftraege(daten.auftraege);
const ueberfaellig = ueberfaelligeAuftraege(daten.auftraege);
const quote = abschlussquote(daten.auftraege);
const laufzeit = durchlaufzeit(daten.auftraege);
const foerderung = foerderQuote(daten.auftraege);
const eingang = auftragseingang(daten.auftraege, filter.zeitraum);
const bestand = aktiv.reduce((s, a) => s + a.wert, 0);
const mitarbeiterName = React.useMemo(
() => new Map(daten.mitarbeiter.map((m) => [m.id, m.name])),
[daten.mitarbeiter]
);
const kundeName = React.useMemo(
() => new Map(daten.kunden.map((k) => [k.id, k.name])),
[daten.kunden]
);
const spalten: Spalte<Auftrag>[] = [
{
key: "titel",
titel: "Auftrag",
breite: "28%",
zelle: (a) => (
<div className="flex flex-col">
<span className="font-medium">{a.titel}</span>
<span className="text-[11px] text-text-neutral-tertiary">
{a.nummer} · {kundeName.get(a.kundeId) ?? "Unbekannt"}
</span>
</div>
),
sortWert: (a) => a.titel,
},
{
key: "gewerk",
titel: "Gewerk",
zelle: (a) => <span className="text-text-neutral-secondary">{a.gewerk}</span>,
sortWert: (a) => a.gewerk,
},
{ key: "status", titel: "Status", zelle: (a) => <AuftragBadge status={a.status} /> },
{
key: "monteur",
titel: "Verantwortlich",
zelle: (a) => (
<span className="text-text-neutral-secondary">
{mitarbeiterName.get(a.mitarbeiterId) ?? "—"}
</span>
),
sortWert: (a) => mitarbeiterName.get(a.mitarbeiterId) ?? "",
},
{
key: "faellig",
titel: "Termin",
numerisch: true,
zelle: (a) => {
const tage = tageSeit(a.faelligAm, HEUTE);
return tage > 0 ? (
<span className="font-medium" style={{ color: STATUS_TEXT.negativ }}>
{tageLabel(tage, "über")}
</span>
) : (
<span className="text-text-neutral-secondary">{formatDatum(a.faelligAm)}</span>
);
},
sortWert: (a) => tageSeit(a.faelligAm, HEUTE),
},
{
key: "wert",
titel: "Wert",
numerisch: true,
zelle: (a) => <span className="font-medium">{formatEuro(a.wert)}</span>,
sortWert: (a) => a.wert,
},
];
return (
<>
<PageHeader
titel="Aufträge"
beschreibung="Von der Anfrage bis zur Abnahme — wo die Vorgänge stehen, was gebunden ist und was über Termin läuft."
/>
<AnalyticsToolbar seite="auftraege" />
<PageContainer>
<Raster spalten={5}>
<KPICard
label="Neue Vorgänge"
wert={formatZahl(imZeitraum.length)}
zusatz="Nach Anlagedatum gezählt"
trend={berechneTrend(imZeitraum.length, vorher.length)}
icon="ClipboardList"
verlauf={eingang.slice(-10).map((p) => p.value)}
/>
<KPICard
label="Aktive Aufträge"
wert={formatZahl(aktiv.length)}
zusatz={`${formatEuro(bestand)} Auftragsbestand`}
icon="Package"
bezug="stichtag"
/>
<KPICard
label="Über Termin"
wert={formatZahl(ueberfaellig.length)}
zusatz={
ueberfaellig.length
? `Ältester seit ${tageLabelDativ(tageSeit(ueberfaellig[0].faelligAm, HEUTE))} fällig`
: "Alle Termine gehalten"
}
icon="AlertTriangle"
bezug="stichtag"
akzent={ueberfaellig.length ? "negativ" : "positiv"}
/>
<KPICard
label="Abschlussquote"
wert={formatProzent(quote, 0)}
zusatz="Aus Angebot wird Auftrag"
icon="Target"
bezug="stichtag"
/>
<KPICard
label="Ø Durchlaufzeit"
wert={formatTage(laufzeit)}
zusatz="Anfrage bis Abnahme"
icon="Clock"
bezug="stichtag"
richtungGut="negativ"
/>
</Raster>
<div className="grid grid-cols-1 items-start gap-4 xl:grid-cols-3">
<ChartCard
id="auftraege-eingang"
titel="Auftragseingang"
untertitel="Neu angelegte Vorgänge im Zeitverlauf"
className="xl:col-span-2"
>
<BalkenVertikal daten={eingang} formatWert={(w) => formatZahl(w)} hoehe={250} nurGanzzahlen />
<StatZeile
spalten={2}
eintraege={[
{ label: "Vorperiode", wert: formatZahl(vorher.length) },
{
label: "Ø Auftragswert",
wert: formatEuro(
imZeitraum.length
? imZeitraum.reduce((s, a) => s + a.wert, 0) / imZeitraum.length
: 0
),
},
]}
/>
</ChartCard>
<ChartCard
id="auftraege-trichter"
titel="Vertriebstrichter"
untertitel="Angebotsgeschäft ab 6.000 €, nach erreichter Stufe"
hinweis="Nur Vorhaben mit schriftlichem Angebot. Wartung und Notdienst gehen ohne Angebot direkt in die Ausführung — mitgezählt wäre der Trichter unten breiter als oben. Verlorene Vorgänge zählen bis zu der Stufe, auf der sie abgesprungen sind."
>
<Trichter stufen={vertriebsTrichter(daten.auftraege)} formatWert={(w) => formatZahl(w)} />
</ChartCard>
</div>
<div className="grid grid-cols-1 items-start gap-4 lg:grid-cols-3">
<ChartCard
id="auftraege-status"
titel="Vorgänge nach Status"
untertitel="Alle Vorgänge seit Beginn — unabhängig vom Zeitraumfilter"
>
<Donut
daten={auftraegeNachStatus(daten.auftraege)}
formatWert={(w) => formatZahl(w)}
hoehe={220}
mitteLabel="Vorgänge"
/>
</ChartCard>
<ChartCard
id="auftraege-gewerke"
titel="Vorgänge nach Gewerk"
untertitel="Anzahl seit Beginn, zum Stichtag"
>
<BalkenHorizontal
daten={auftraegeNachGewerk(daten.auftraege)}
formatWert={(w) => formatZahl(w)}
einfarbig={false}
maxBalken={5}
/>
</ChartCard>
<ChartCard
id="auftraege-foerderung"
titel="Förderquote BAFA / KfW"
untertitel={`${formatProzent(foerderung.quote, 0)} der ${formatZahl(
foerderung.foerderfaehig
)} förderfähigen Aufträge`}
hinweis="Bezugsgröße sind nur förderfähige Leistungen: Wärmepumpe, PV-Anlage, Batteriespeicher und Lüftungsanlage. Über alle Aufträge gerechnet wäre die Quote wertlos."
>
<Donut
daten={foerderung.verteilung}
formatWert={(w) => formatZahl(w)}
hoehe={200}
mitteLabel="Förderfähig"
/>
<StatZeile
spalten={2}
eintraege={[
{ label: "Fördersumme", wert: formatEuroKompakt(foerderung.summe) },
{
label: "Ø je Auftrag",
wert: formatEuroKompakt(
foerderung.bewilligt ? foerderung.summe / foerderung.bewilligt : 0
),
},
]}
/>
</ChartCard>
</div>
<ChartCard
id="auftraege-liste"
titel={`Aktive Aufträge (${aktiv.length})`}
untertitel="Beauftragt oder in Arbeit"
>
<DataTable
zeilen={aktiv}
spalten={spalten}
proSeite={8}
suchFelder={(a) =>
`${a.titel} ${a.nummer} ${a.gewerk} ${mitarbeiterName.get(a.mitarbeiterId) ?? ""}`
}
leerText="Keine aktiven Aufträge"
/>
</ChartCard>
</PageContainer>
</>
);
}
+278
View File
@@ -0,0 +1,278 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer, Raster } from "../components/layout/PageContainer";
import { AnalyticsToolbar } from "../components/filters/AnalyticsToolbar";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { StatZeile } from "../components/cards/StatZeile";
import { AreaVerlauf } from "../components/charts/AreaVerlauf";
import { BalkenVertikal } from "../components/charts/BalkenVertikal";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { Donut } from "../components/charts/Donut";
import { ChartLegende } from "../components/charts/ChartLegende";
import { DataTable, type Spalte } from "../components/tables/DataTable";
import { RechnungBadge } from "../components/tables/StatusBadge";
import { useAnalyseDaten } from "../hooks/useAnalyseDaten";
import {
marge,
offenePosten,
offeneNachStatus,
umsatz,
umsatzNachGewerk,
umsatzVerlauf,
umsatzVorperiode,
zahlungsdauer,
} from "../data/calculations";
import {
berechneTrend,
formatDatum,
formatEuro,
formatEuroAchse,
formatEuroKompakt,
formatProzent,
formatTage,
tageSeit,
tageLabel,
} from "../utils/formatters";
import { HEUTE } from "../utils/dateUtils";
import {
PRIMAER_FARBE,
RISIKO_RAMPE,
STATUS_TEXT,
VERGLEICH_FARBE,
} from "../utils/chartTheme";
import type { Rechnung } from "../data/types";
/** Ampelfarben für die Altersstruktur: je älter die Forderung, desto kritischer. */
const ALTER_FARBEN = [...RISIKO_RAMPE];
export function FinanzenSeite() {
const { daten, filter } = useAnalyseDaten("finanzen");
const umsatzAktuell = umsatz(daten.rechnungen, filter.zeitraum);
const umsatzVorher = umsatzVorperiode(daten.rechnungen, filter.zeitraum);
const verlauf = umsatzVerlauf(daten.rechnungen, filter.zeitraum);
const posten = offenePosten(daten.rechnungen);
const dauer = zahlungsdauer(daten.rechnungen, filter.zeitraum);
const margeProzent = marge(daten.auftraege, filter.zeitraum);
const kundeName = React.useMemo(
() => new Map(daten.kunden.map((k) => [k.id, k.name])),
[daten.kunden]
);
const spalten: Spalte<Rechnung>[] = [
{
key: "nummer",
titel: "Rechnung",
zelle: (r) => (
<div className="flex flex-col">
<span className="font-medium">{r.nummer}</span>
<span className="text-[11px] text-text-neutral-tertiary">
{kundeName.get(r.kundeId) ?? "Unbekannt"}
</span>
</div>
),
sortWert: (r) => r.nummer,
breite: "30%",
},
{ key: "status", titel: "Status", zelle: (r) => <RechnungBadge status={r.status} /> },
{
key: "gestellt",
titel: "Gestellt",
zelle: (r) => formatDatum(r.gestelltAm),
sortWert: (r) => r.gestelltAm,
},
{
key: "faellig",
titel: "Überfällig",
numerisch: true,
zelle: (r) => {
const tage = tageSeit(r.faelligAm, HEUTE);
return tage > 0 ? (
<span
className={tage > 30 ? "font-medium" : ""}
style={{ color: tage > 30 ? STATUS_TEXT.negativ : STATUS_TEXT.warnung }}
>
{tageLabel(tage)}
</span>
) : (
<span className="text-text-neutral-tertiary">
in {Math.abs(tage) === 1 ? "1 Tag" : `${Math.abs(tage)} Tagen`}
</span>
);
},
sortWert: (r) => tageSeit(r.faelligAm, HEUTE),
},
{
key: "betrag",
titel: "Betrag",
numerisch: true,
zelle: (r) => <span className="font-medium">{formatEuro(r.betrag)}</span>,
sortWert: (r) => r.betrag,
},
];
return (
<>
<PageHeader
titel="Finanzen"
beschreibung="Umsatz, Zahlungseingang und offene Forderungen — die Sicht der Buchhaltung auf den Betrieb."
/>
<AnalyticsToolbar seite="finanzen" />
<PageContainer>
<Raster spalten={5}>
<KPICard
label="Umsatz (bezahlt)"
wert={formatEuro(umsatzAktuell)}
zusatz="Zahlungseingang im Zeitraum"
trend={berechneTrend(umsatzAktuell, umsatzVorher)}
icon="Euro"
verlauf={verlauf.slice(-10).map((p) => p.value)}
/>
<KPICard
label="Offene Forderungen"
wert={formatEuro(posten.gesamt)}
zusatz={`${posten.anzahl} Rechnungen`}
icon="FileText"
bezug="stichtag"
/>
<KPICard
label="Überfällig"
wert={formatEuro(posten.ueberfaelligBetrag)}
zusatz={`${posten.ueberfaelligAnzahl} Rechnungen im Mahnlauf`}
icon="AlertTriangle"
bezug="stichtag"
akzent={posten.ueberfaelligBetrag > 0 ? "negativ" : "positiv"}
/>
<KPICard
label="Ø Zahlungsdauer"
wert={formatTage(dauer)}
zusatz="Rechnung bis Zahlungseingang"
icon="Clock"
akzent={dauer > 30 ? "warnung" : "positiv"}
richtungGut="negativ"
/>
<KPICard
label="Deckungsbeitrag"
wert={formatProzent(margeProzent)}
zusatz="Gewichtet über Abschlüsse"
icon="Percent"
/>
</Raster>
<div className="grid grid-cols-1 gap-4 xl:grid-cols-3">
<ChartCard
id="finanzen-verlauf"
titel="Zahlungseingang im Zeitverlauf"
untertitel="Aktueller Zeitraum gegen Vorjahr"
hinweis="Grundlage sind bezahlte Ausgangsrechnungen zum Zahlungsdatum."
className="xl:col-span-2"
legende={
<ChartLegende
eintraege={[
{ name: "Aktueller Zeitraum", farbe: PRIMAER_FARBE },
{ name: "Vorjahr", farbe: VERGLEICH_FARBE, gestrichelt: true },
]}
/>
}
>
<AreaVerlauf
daten={verlauf}
formatWert={formatEuroKompakt}
formatAchse={formatEuroAchse}
zeigeVergleich
hoehe={250}
/>
<StatZeile
spalten={2}
eintraege={[
{ label: "Vorperiode", wert: formatEuro(umsatzVorher) },
{
label: "Veränderung",
wert: `${umsatzAktuell >= umsatzVorher ? "+" : "−"}${formatEuro(Math.abs(umsatzAktuell - umsatzVorher))}`,
},
]}
/>
</ChartCard>
<ChartCard
id="finanzen-status"
titel="Offener Bestand nach Status"
untertitel="Wie viel des offenen Bestands bereits überfällig ist"
hinweis="Bezugsgröße ist ausschließlich der offene Bestand zum Stichtag. Bezahlte Rechnungen sind nicht enthalten — sie würden über 90 % des Rings belegen und die Aussage erdrücken."
>
<Donut
daten={offeneNachStatus(daten.rechnungen)}
formatWert={formatEuroKompakt}
hoehe={200}
mitteLabel="Offen"
formatMitte={formatEuro}
/>
</ChartCard>
</div>
<div className="grid grid-cols-1 items-start gap-4 lg:grid-cols-3">
<ChartCard
className="lg:col-span-2"
id="finanzen-alter"
titel="Offene Forderungen nach Alter"
untertitel={`Gesamt ${formatEuro(posten.gesamt)}`}
hinweis="Alter ab Fälligkeitsdatum. Ab 60 Tagen sinkt die Einbringungsquote erfahrungsgemäß deutlich."
>
<BalkenVertikal
daten={posten.nachAlter}
formatWert={formatEuroKompakt}
formatAchse={formatEuroAchse}
hoehe={240}
farbenProBalken={ALTER_FARBEN}
/>
<StatZeile
spalten={2}
eintraege={[
{
label: "Älter als 90 Tage",
wert: formatEuro(posten.nachAlter.find((b) => b.name === "> 90 Tage")?.value ?? 0),
hinweis: "Abschreibungsrisiko",
},
{ label: "Überfällig gesamt", wert: formatEuro(posten.ueberfaelligBetrag) },
]}
/>
</ChartCard>
<ChartCard
id="finanzen-gewerke"
titel="Umsatz nach Gewerk"
untertitel="Zahlungseingang im Zeitraum"
>
<BalkenHorizontal
daten={umsatzNachGewerk(daten.auftraege, daten.rechnungen, filter.zeitraum)}
formatWert={formatEuroKompakt}
einfarbig={false}
maxBalken={5}
/>
</ChartCard>
</div>
<ChartCard
id="finanzen-offene-liste"
titel={`Offene Rechnungen (${posten.anzahl})`}
untertitel="Sortiert nach Fälligkeit — die Arbeitsliste für den Mahnlauf"
>
<DataTable
zeilen={posten.liste}
spalten={spalten}
proSeite={8}
suchFelder={(r) => `${r.nummer} ${kundeName.get(r.kundeId) ?? ""}`}
leerText="Keine offenen Rechnungen"
/>
</ChartCard>
</PageContainer>
</>
);
}
@@ -0,0 +1,352 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer } from "../components/layout/PageContainer";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { AlertList } from "../components/cards/AlertList";
import { StatZeile } from "../components/cards/StatZeile";
import { AreaVerlauf } from "../components/charts/AreaVerlauf";
import { BalkenVertikal } from "../components/charts/BalkenVertikal";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { Donut } from "../components/charts/Donut";
import { Trichter } from "../components/charts/Trichter";
import { AuslastungsBalken } from "../components/charts/AuslastungsBalken";
import { ChartLeer } from "../components/charts/ChartLeer";
import { ChartLegende } from "../components/charts/ChartLegende";
import { AuftragBadge, RechnungBadge } from "../components/tables/StatusBadge";
import {
KATEGORIE_FARBEN,
MAX_KATEGORIEN,
PRIMAER_FARBE,
STATUS_FARBEN,
VERGLEICH_FARBE,
} from "../utils/chartTheme";
import {
formatEuro,
formatEuroAchse,
formatEuroKompakt,
formatProzent,
formatZahl,
} from "../utils/formatters";
import { DATENSATZ_INFO } from "../data/seed";
/** Beispieldaten, damit die Galerie unabhängig von Filtern immer etwas zeigt. */
const BEISPIEL_REIHE = Array.from({ length: 12 }, (_, i) => ({
datum: `2026-${String(i + 1).padStart(2, "0")}`,
label: ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"][i],
value: [148, 162, 171, 158, 166, 149, 152, 161, 189, 205, 198, 176][i] * 1000,
vergleich: [131, 140, 152, 146, 151, 138, 141, 149, 168, 181, 176, 158][i] * 1000,
}));
const BEISPIEL_KATEGORIEN = [
{ name: "Heizung", value: 842_000 },
{ name: "Sanitär", value: 486_000 },
{ name: "Photovoltaik", value: 421_000 },
{ name: "Klima & Lüftung", value: 268_000 },
{ name: "Elektro", value: 194_000 },
{ name: "Sonstiges", value: 61_000 },
];
export function KomponentenSeite() {
return (
<>
<PageHeader
titel="Komponenten & Regeln"
beschreibung="Alle Bausteine dieses Prototyps an einem Ort — als Referenz für den Einbau in die Software."
/>
<PageContainer>
<Abschnitt
titel="Warum diese Seite existiert"
text="Der Prototyp ist eine Gestaltungsvorlage, kein Produkt. Diese Seite zeigt jeden Baustein isoliert, damit beim Einbau klar ist, welche Komponente wofür gedacht ist und welche Regeln dahinterstehen. Datei-Pfade stehen jeweils darunter."
/>
<ChartCard
id="komp-farben"
titel="Farbpalette"
untertitel="IBM Carbon, kategoriale Palette (14 Farben) — Reihenfolge nie umsortieren"
hinweis="Die Reihenfolge ist auf Unterscheidbarkeit optimiert. Farben immer von vorne vergeben, nicht nach Geschmack auswählen."
>
<div className="flex flex-col gap-4">
<div className="flex flex-wrap gap-2">
{KATEGORIE_FARBEN.map((farbe, index) => (
<div key={farbe} className="flex w-[104px] flex-col gap-1">
<span className="h-10 w-full rounded-md" style={{ background: farbe }} />
<span className="text-[11px] font-medium text-text-neutral-secondary">
{index + 1}. {farbe}
</span>
</div>
))}
</div>
<div className="flex flex-wrap gap-4 border-t border-solid border-border-default pt-3">
{Object.entries(STATUS_FARBEN).map(([name, farbe]) => (
<span key={name} className="flex items-center gap-2 text-[12px] text-text-neutral-secondary">
<span className="h-4 w-4 rounded" style={{ background: farbe }} />
Status „{name}“ · {farbe}
</span>
))}
</div>
<p className="text-[12px] leading-relaxed text-text-neutral-tertiary">
Kategorien nutzen die Carbon-Palette, Statusaussagen die Ampelfarben. Beides nie
mischen: eine grüne Kategorie neben einem grünen Positiv-Status ist nicht mehr lesbar.
Maximal {MAX_KATEGORIEN} Segmente je Chart, der Rest wird zu „Sonstige“
zusammengefasst.
</p>
</div>
</ChartCard>
<Abschnitt titel="Kennzahlen-Karten" text="features/dashboard/components/cards/KPICard.tsx" />
<div className="grid grid-cols-2 gap-4 lg:grid-cols-4">
<KPICard
label="Mit Trend und Sparkline"
wert={formatEuro(238_412)}
zusatz="Zahlungseingang im Zeitraum"
trend={{ wert: 12.4, richtung: "up" }}
icon="Euro"
akzent="positiv"
verlauf={[42, 48, 45, 52, 58, 55, 63, 71]}
/>
<KPICard
label="Negativer Trend"
wert={formatProzent(58.2, 0)}
zusatz="Abschlussquote"
trend={{ wert: 6.1, richtung: "down" }}
icon="Target"
akzent="negativ"
/>
<KPICard
label="Kleiner ist besser"
wert="34,2 Tage"
zusatz="Ø Zahlungsdauer"
trend={{ wert: 8.3, richtung: "down" }}
icon="Clock"
akzent="positiv"
richtungGut="negativ"
/>
<KPICard
label="Ohne Trend"
wert={formatZahl(1900)}
zusatz="Vorgänge im Datensatz"
icon="ClipboardList"
akzent="neutral"
/>
</div>
<Hinweis text="richtungGut='negativ' dreht die Farblogik um: Bei Zahlungsdauer oder Reaktionszeit ist ein Rückgang gut. Ohne diesen Schalter würde die Karte eine Verbesserung rot einfärben." />
<div className="grid grid-cols-1 gap-4 xl:grid-cols-3">
<ChartCard
id="komp-area"
titel="Flächendiagramm mit Vergleich"
untertitel="components/charts/AreaVerlauf.tsx — für Zeitverläufe"
className="xl:col-span-2"
legende={
<ChartLegende
eintraege={[
{ name: "Aktuell", farbe: PRIMAER_FARBE },
{ name: "Vorjahr", farbe: VERGLEICH_FARBE, gestrichelt: true },
]}
/>
}
>
<AreaVerlauf
daten={BEISPIEL_REIHE}
formatWert={formatEuroKompakt}
formatAchse={formatEuroAchse}
zeigeVergleich
hoehe={220}
/>
</ChartCard>
<ChartCard
id="komp-donut"
titel="Ringdiagramm"
untertitel="components/charts/Donut.tsx — für Anteile"
>
<Donut daten={BEISPIEL_KATEGORIEN} formatWert={formatEuroKompakt} hoehe={200} />
</ChartCard>
</div>
<div className="grid grid-cols-1 gap-4 lg:grid-cols-3">
<ChartCard
id="komp-balken"
titel="Säulendiagramm"
untertitel="components/charts/BalkenVertikal.tsx — Mengen mit Nulllinie"
>
<BalkenVertikal
daten={BEISPIEL_REIHE.map((p) => ({ label: p.label, value: p.value / 1000 }))}
formatWert={(w) => formatZahl(w)}
hoehe={200}
nurGanzzahlen
/>
</ChartCard>
<ChartCard
id="komp-hbalken"
titel="Balkendiagramm (liegend)"
untertitel="components/charts/BalkenHorizontal.tsx — Rangfolgen"
>
<BalkenHorizontal
daten={BEISPIEL_KATEGORIEN}
formatWert={formatEuroKompakt}
einfarbig={false}
/>
</ChartCard>
<ChartCard
id="komp-trichter"
titel="Trichter"
untertitel="components/charts/Trichter.tsx — Stufen mit Übergangsquote"
>
<Trichter
stufen={[
{ name: "Anfrage", value: 1900 },
{ name: "Vor-Aufmaß", value: 1420 },
{ name: "Angebot", value: 1180 },
{ name: "Beauftragt", value: 690 },
{ name: "Abgeschlossen", value: 612 },
]}
formatWert={(w) => formatZahl(w)}
/>
</ChartCard>
</div>
<div className="grid grid-cols-1 gap-4 lg:grid-cols-3">
<ChartCard
id="komp-auslastung"
titel="Auslastungsbalken"
untertitel="components/charts/AuslastungsBalken.tsx — mit Ampel und 100-%-Marke"
>
<AuslastungsBalken
zeilen={[
{ name: "Thomas Krause", wert: 104, zusatz: "Meister · Heizung" },
{ name: "Dennis Meyer", wert: 92, zusatz: "Monteur · Sanitär" },
{ name: "Maike Schmidt", wert: 78, zusatz: "Monteur · Photovoltaik" },
{ name: "Kevin Wolf", wert: 54, zusatz: "Auszubildender · Elektro" },
]}
/>
</ChartCard>
<ChartCard
id="komp-alerts"
titel="Handlungsbedarf"
untertitel="components/cards/AlertList.tsx — nach Dringlichkeit sortiert"
>
<AlertList
eintraege={[
{
id: "a",
text: "25 überfällige Rechnungen",
detail: "Zahlungsziel überschritten",
betrag: 96_194,
aktion: "Mahnlauf starten",
art: "kritisch",
},
{
id: "b",
text: "32 Aufträge über Termin",
detail: "Ältester seit 99 Tagen fällig",
betrag: 148_600,
aktion: "Termine neu planen",
art: "warnung",
},
{
id: "c",
text: "23 Förderanträge in Bearbeitung",
detail: "Bescheid ausstehend",
betrag: 116_100,
aktion: "Status prüfen",
art: "hinweis",
},
]}
/>
</ChartCard>
<ChartCard
id="komp-leer"
titel="Leerzustand"
untertitel="components/charts/ChartLeer.tsx — greift, wenn Filter alles wegschneiden"
>
<ChartLeer hoehe={180} />
</ChartCard>
</div>
<ChartCard
id="komp-badges"
titel="Status-Kennzeichnung"
untertitel="components/tables/StatusBadge.tsx"
>
<div className="flex flex-col gap-4">
<div className="flex flex-wrap items-center gap-2">
<span className="w-24 text-[12px] text-text-neutral-tertiary">Auftrag</span>
<AuftragBadge status="anfrage" />
<AuftragBadge status="aufmass" />
<AuftragBadge status="angebot" />
<AuftragBadge status="beauftragt" />
<AuftragBadge status="in_arbeit" />
<AuftragBadge status="abgeschlossen" />
<AuftragBadge status="verloren" />
</div>
<div className="flex flex-wrap items-center gap-2">
<span className="w-24 text-[12px] text-text-neutral-tertiary">Rechnung</span>
<RechnungBadge status="entwurf" />
<RechnungBadge status="gestellt" />
<RechnungBadge status="bezahlt" />
<RechnungBadge status="ueberfaellig" />
</div>
<StatZeile
eintraege={[
{ label: "Aufträge", wert: formatZahl(DATENSATZ_INFO.auftraege), hinweis: "im Demo-Datensatz" },
{ label: "Rechnungen", wert: formatZahl(DATENSATZ_INFO.rechnungen) },
{ label: "Kunden", wert: formatZahl(DATENSATZ_INFO.kunden) },
{ label: "Zeiteinträge", wert: formatZahl(DATENSATZ_INFO.zeiteintraege) },
]}
/>
</div>
</ChartCard>
<ChartCard
id="komp-regeln"
titel="Regeln, die beim Einbau erhalten bleiben sollten"
untertitel="Ausführlich in docs/DESIGN-SYSTEM.md"
>
<ul className="flex flex-col gap-2.5">
{[
"Nur horizontale Gridlines in #e0e0e0. Vertikale Linien lenken vom Verlauf ab.",
"Achsenbeschriftungen 12 px in #525252, keine Tick-Marks, Achsenlinie #8d8d8d.",
"Ein Tooltip für alle Charts: dunkle Fläche #393939, weißer Text, kein Doppelpunkt.",
"Maximal fünf Kategorien je Chart, alles darüber wird zu „Sonstige“ zusammengefasst.",
"Balkenabstand mindestens halbe Balkenbreite; Balken nie breiter als 48 px.",
"Zahlen rechtsbündig und in Tabellenziffern, Text linksbündig.",
"Karten: 16 px Innenabstand, 16 px Abstand zwischen Karten — innen nie größer als außen.",
"Jede Karte braucht einen Leerzustand. Filter können jedes Chart leer laufen lassen.",
].map((regel) => (
<li key={regel} className="flex gap-2.5 text-[13px] leading-relaxed text-text-neutral-secondary">
<span className="mt-1.5 h-1.5 w-1.5 flex-none rounded-full bg-neutral-400" />
{regel}
</li>
))}
</ul>
</ChartCard>
</PageContainer>
</>
);
}
function Abschnitt({ titel, text }: { titel: string; text: string }) {
return (
<div className="flex flex-col gap-1 pt-2">
<h2 className="text-[15px] font-semibold text-text-neutral-primary">{titel}</h2>
<p className="max-w-3xl text-[13px] leading-relaxed text-text-neutral-tertiary">{text}</p>
</div>
);
}
function Hinweis({ text }: { text: string }) {
return (
<p className="rounded-md border border-solid border-border-default bg-white px-3 py-2 text-[12px] leading-relaxed text-text-neutral-secondary">
{text}
</p>
);
}
+241
View File
@@ -0,0 +1,241 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer, Raster } from "../components/layout/PageContainer";
import { AnalyticsToolbar } from "../components/filters/AnalyticsToolbar";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { BalkenVertikal } from "../components/charts/BalkenVertikal";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { Donut } from "../components/charts/Donut";
import { DataTable, type Spalte } from "../components/tables/DataTable";
import { useAnalyseDaten } from "../hooks/useAnalyseDaten";
import {
inaktiveKunden,
kundenEntwicklung,
kundenNach,
neueKunden,
topKunden,
wiederkehrquote,
zahlungsauffaellig,
} from "../data/calculations";
import {
berechneTrend,
formatDatum,
formatEuro,
formatEuroKompakt,
formatProzent,
formatZahl,
tageLabel,
} from "../utils/formatters";
import { STATUS_TEXT } from "../utils/chartTheme";
import { imFenster, vorperiode } from "../utils/dateUtils";
import type { Kunde } from "../data/types";
export function KundenSeite() {
const { daten, filter } = useAnalyseDaten("kunden");
const neu = neueKunden(daten.kunden, filter.zeitraum);
const neuVorher = daten.kunden.filter((k) =>
imFenster(k.angelegtAm, vorperiode(filter.zeitraum))
).length;
const mitAuftrag = daten.kunden.filter((k) => k.auftraegeGesamt > 0);
const wiederkehrend = wiederkehrquote(daten.kunden);
const kundenwert =
mitAuftrag.length > 0
? mitAuftrag.reduce((s, k) => s + k.umsatzGesamt, 0) / mitAuftrag.length
: 0;
const inaktiv = inaktiveKunden(daten.kunden);
const auffaellig = zahlungsauffaellig(daten.kunden);
const entwicklung = kundenEntwicklung(daten.kunden, filter.zeitraum);
const spalten: Spalte<Kunde>[] = [
{
key: "name",
titel: "Kunde",
breite: "26%",
zelle: (k) => (
<div className="flex flex-col">
<span className="font-medium">{k.name}</span>
<span className="text-[11px] text-text-neutral-tertiary">{k.typ}</span>
</div>
),
sortWert: (k) => k.name,
},
{
key: "quelle",
titel: "Quelle",
zelle: (k) => <span className="text-text-neutral-secondary">{k.quelle}</span>,
sortWert: (k) => k.quelle,
},
{
key: "auftraege",
titel: "Aufträge",
numerisch: true,
zelle: (k) => formatZahl(k.auftraegeGesamt),
sortWert: (k) => k.auftraegeGesamt,
},
{
key: "umsatz",
titel: "Umsatz",
numerisch: true,
zelle: (k) => <span className="font-medium">{formatEuro(k.umsatzGesamt)}</span>,
sortWert: (k) => k.umsatzGesamt,
},
{
key: "zahlung",
titel: "Ø Zahlung",
numerisch: true,
zelle: (k) => (
<span
className={k.zahlungsmoralTage > 30 ? "font-medium" : ""}
style={k.zahlungsmoralTage > 30 ? { color: STATUS_TEXT.warnung } : undefined}
>
{tageLabel(k.zahlungsmoralTage)}
</span>
),
sortWert: (k) => k.zahlungsmoralTage,
},
{
key: "letzter",
titel: "Letzter Auftrag",
zelle: (k) =>
k.letzterAuftragAm ? (
formatDatum(k.letzterAuftragAm)
) : (
<span className="text-text-neutral-subtle">—</span>
),
sortWert: (k) => k.letzterAuftragAm ?? "",
},
];
return (
<>
<PageHeader
titel="Kunden"
beschreibung="Woher Kunden kommen, wie viel sie bringen und wo Nachfassen lohnt."
/>
<AnalyticsToolbar seite="kunden" />
<PageContainer>
<Raster spalten={5}>
<KPICard
label="Kunden gesamt"
wert={formatZahl(daten.kunden.length)}
zusatz={`${formatZahl(mitAuftrag.length)} mit mindestens einem Auftrag`}
icon="Users"
bezug="stichtag"
/>
<KPICard
label="Neue Kunden"
wert={formatZahl(neu)}
zusatz="Nach Anlagedatum gezählt"
trend={berechneTrend(neu, neuVorher)}
icon="UserPlus"
verlauf={entwicklung.slice(-10).map((p) => p.value)}
/>
<KPICard
label="Wiederkehrende Kunden"
wert={formatProzent(wiederkehrend, 0)}
zusatz="Mehr als ein Auftrag"
icon="Repeat"
bezug="stichtag"
/>
<KPICard
label="Ø Kundenwert"
wert={formatEuro(kundenwert)}
zusatz="Je Kunde mit mindestens einem Auftrag"
icon="CircleDollarSign"
bezug="gesamt"
/>
<KPICard
label="Reaktivierbar"
wert={formatZahl(inaktiv.length)}
zusatz="Über 12 Monate ohne Auftrag"
icon="Clock"
bezug="stichtag"
akzent={inaktiv.length > 0 ? "warnung" : "neutral"}
/>
</Raster>
<div className="grid grid-cols-1 items-start gap-4 xl:grid-cols-3">
<ChartCard
id="kunden-entwicklung"
titel="Neukunden im Zeitverlauf"
untertitel="Anlagedatum des Kundendatensatzes"
className="xl:col-span-2"
>
<BalkenVertikal daten={entwicklung} formatWert={(w) => formatZahl(w)} hoehe={250} nurGanzzahlen />
</ChartCard>
<ChartCard
id="kunden-quelle"
titel="Kunden nach Quelle"
untertitel="Wie der Erstkontakt zustande kam"
hinweis="Empfehlungen und Bestandskunden zusammen zeigen, wie stark der Betrieb ohne Werbebudget wächst."
>
<Donut
daten={kundenNach(daten.kunden, "quelle")}
formatWert={(w) => formatZahl(w)}
hoehe={220}
mitteLabel="Kunden"
/>
</ChartCard>
</div>
<div className="grid grid-cols-1 items-start gap-4 lg:grid-cols-2">
<ChartCard id="kunden-typ" titel="Kundenstruktur" untertitel="Privat, Gewerbe, Verwaltung">
<Donut
daten={kundenNach(daten.kunden, "typ")}
formatWert={(w) => formatZahl(w)}
hoehe={200}
mitteLabel="Kunden"
/>
</ChartCard>
<ChartCard
id="kunden-top"
titel="Top-Kunden nach Umsatz"
untertitel="Bezahlter Gesamtumsatz"
>
<BalkenHorizontal daten={topKunden(daten.kunden, 6)} formatWert={formatEuroKompakt} />
</ChartCard>
</div>
<div className="grid grid-cols-1 items-start gap-4 xl:grid-cols-2">
<ChartCard
id="kunden-inaktiv"
titel={`Reaktivierungspotenzial (${inaktiv.length})`}
untertitel="Kunden mit Historie, aber über 12 Monate ohne Auftrag"
>
<DataTable
zeilen={inaktiv}
spalten={spalten.filter((s) => s.key !== "zahlung")}
proSeite={6}
suchFelder={(k) => `${k.name} ${k.ort} ${k.quelle}`}
leerText="Alle Kunden waren zuletzt aktiv"
/>
</ChartCard>
<ChartCard
id="kunden-zahlung"
titel={`Auffällige Zahlungsmoral (${auffaellig.length})`}
untertitel="Durchschnittlich über 30 Tage bis zum Zahlungseingang"
>
<DataTable
zeilen={auffaellig}
spalten={spalten.filter((s) => s.key !== "letzter")}
proSeite={6}
suchFelder={(k) => `${k.name} ${k.ort}`}
leerText="Keine Auffälligkeiten"
/>
</ChartCard>
</div>
</PageContainer>
</>
);
}
+248
View File
@@ -0,0 +1,248 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer, Raster } from "../components/layout/PageContainer";
import { AnalyticsToolbar } from "../components/filters/AnalyticsToolbar";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { AuslastungsBalken } from "../components/charts/AuslastungsBalken";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { Donut } from "../components/charts/Donut";
import { DataTable, type Spalte } from "../components/tables/DataTable";
import { useAnalyseDaten } from "../hooks/useAnalyseDaten";
import { teamKennzahlen, type MitarbeiterKennzahl } from "../data/calculations";
import { formatEuro, formatEuroKompakt, formatProzent, formatStunden, formatZahl } from "../utils/formatters";
import { imFenster, zeitfenster } from "../utils/dateUtils";
export function TeamSeite() {
const { daten, filter } = useAnalyseDaten("team");
const kennzahlen = teamKennzahlen(
daten.mitarbeiter,
daten.zeiten,
daten.auftraege,
filter.zeitraum
);
const aktive = kennzahlen.filter((k) => k.mitarbeiter.status === "aktiv");
const durchschnitt =
aktive.length > 0 ? aktive.reduce((s, k) => s + k.auslastungProzent, 0) / aktive.length : 0;
const stundenGesamt = aktive.reduce((s, k) => s + k.stunden, 0);
const produktivGesamt = aktive.reduce((s, k) => s + k.produktivStunden, 0);
const produktivQuote = stundenGesamt > 0 ? (produktivGesamt / stundenGesamt) * 100 : 0;
const fenster = zeitfenster(filter.zeitraum);
const abwesenheiten = daten.zeiten.filter(
(z) => z.art === "abwesenheit" && imFenster(z.datum, fenster)
);
const abwesenheitNach = React.useMemo(() => {
const zaehler = new Map<string, number>();
const label: Record<string, string> = {
urlaub: "Urlaub",
krank: "Krank",
fortbildung: "Fortbildung",
};
for (const eintrag of abwesenheiten) {
const name = label[eintrag.abwesenheitsgrund ?? "sonstige"] ?? "Sonstige";
zaehler.set(name, (zaehler.get(name) ?? 0) + eintrag.stunden);
}
return [...zaehler.entries()].map(([name, value]) => ({ name, value }));
}, [abwesenheiten]);
const spalten: Spalte<MitarbeiterKennzahl & { id: string }>[] = [
{
key: "name",
titel: "Mitarbeiter",
breite: "26%",
zelle: (k) => (
<div className="flex items-center gap-2.5">
<span className="flex h-7 w-7 flex-none items-center justify-center rounded-full bg-neutral-100 text-[11px] font-semibold text-text-neutral-secondary">
{k.mitarbeiter.kuerzel}
</span>
<div className="flex flex-col">
<span className="font-medium">{k.mitarbeiter.name}</span>
<span className="text-[11px] text-text-neutral-tertiary">
{k.mitarbeiter.rolle} · {k.mitarbeiter.gewerk}
</span>
</div>
</div>
),
sortWert: (k) => k.mitarbeiter.name,
},
{
key: "status",
titel: "Status",
zelle: (k) =>
k.mitarbeiter.status === "aktiv" ? (
<span className="rounded-full bg-[#defbe6] px-2 py-0.5 text-[11px] font-medium text-[#0e6027]">
aktiv
</span>
) : (
<span className="rounded-full bg-neutral-100 px-2 py-0.5 text-[11px] font-medium text-neutral-600">
inaktiv
</span>
),
sortWert: (k) => k.mitarbeiter.status,
},
{
key: "stunden",
titel: "Stunden",
numerisch: true,
zelle: (k) => formatStunden(k.stunden),
sortWert: (k) => k.stunden,
},
{
key: "produktiv",
titel: "davon produktiv",
numerisch: true,
zelle: (k) => formatStunden(k.produktivStunden),
sortWert: (k) => k.produktivStunden,
},
{
key: "auslastung",
titel: "Auslastung",
numerisch: true,
zelle: (k) => (
<span
className={
k.auslastungProzent > 95
? "font-medium text-[#8a3800]"
: k.auslastungProzent < 70
? "text-[#00539a]"
: "font-medium text-[#0e6027]"
}
>
{formatProzent(k.auslastungProzent, 0)}
</span>
),
sortWert: (k) => k.auslastungProzent,
},
{
key: "abgeschlossen",
titel: "Abgeschlossen",
numerisch: true,
zelle: (k) => formatZahl(k.abgeschlossen),
sortWert: (k) => k.abgeschlossen,
},
{
key: "umsatz",
titel: "Auftragswert",
numerisch: true,
zelle: (k) => <span className="font-medium">{formatEuro(k.umsatz)}</span>,
sortWert: (k) => k.umsatz,
},
];
const tabellenZeilen = kennzahlen.map((k) => ({ ...k, id: k.mitarbeiter.id }));
return (
<>
<PageHeader
titel="Team"
beschreibung="Auslastung, produktive Stunden und Abschlüsse der Monteure — die Kennzahl hinter der Terminplanung."
/>
<AnalyticsToolbar seite="team" />
<PageContainer>
<Raster spalten={5}>
<KPICard
label="Im Einsatz"
wert={formatZahl(aktive.length)}
zusatz={`von ${formatZahl(kennzahlen.length)} gewerblich Beschäftigten`}
icon="HardHat"
bezug="stichtag"
/>
<KPICard
label="Ø Auslastung"
wert={formatProzent(durchschnitt, 0)}
zusatz="Produktive Stunden zu verfügbaren"
icon="Activity"
akzent={durchschnitt > 95 ? "warnung" : "positiv"}
/>
<KPICard
label="Produktivquote"
wert={formatProzent(produktivQuote, 0)}
zusatz="Anteil auftragsbezogener Stunden"
icon="Target"
/>
<KPICard
label="Erfasste Stunden"
wert={formatStunden(stundenGesamt)}
zusatz={`${formatStunden(produktivGesamt)} auf Aufträge gebucht`}
icon="Clock"
/>
<KPICard
label="Abwesenheit"
wert={formatStunden(abwesenheiten.reduce((s, a) => s + a.stunden, 0))}
zusatz="Urlaub, Krankheit, Fortbildung"
icon="CalendarOff"
richtungGut="negativ"
/>
</Raster>
<ChartCard
id="team-auslastung"
titel="Auslastung je Mitarbeiter"
untertitel="Produktive Stunden gegen vertraglich verfügbare Stunden"
hinweis="Werte über 100 % bedeuten Überstunden. Dauerhaft über 95 % ist ein Warnsignal für Terminrisiken."
>
<AuslastungsBalken
zeilen={aktive.map((k) => ({
name: k.mitarbeiter.name,
wert: k.auslastungProzent,
zusatz: `${k.mitarbeiter.rolle} · ${k.mitarbeiter.gewerk}`,
}))}
maxZeilen={12}
/>
</ChartCard>
<div className="grid grid-cols-1 items-start gap-4 lg:grid-cols-2">
<ChartCard
id="team-abschluesse"
titel="Abschlüsse je Mitarbeiter"
untertitel="Anzahl im gewählten Zeitraum, dahinter der zugehörige Auftragswert"
hinweis="Der Balken zeigt die Anzahl — sie ist die vergleichbare Größe. Der Auftragswert steht daneben, ist aber ausdrücklich kein Leistungsvergleich: Ein Wärmepumpen-Auftrag ist um ein Vielfaches größer als eine Wartung."
>
<BalkenHorizontal
daten={aktive.map((k) => ({
name: k.mitarbeiter.name,
value: k.abgeschlossen,
zweitwert: k.umsatz,
}))}
formatWert={(w) => formatZahl(w)}
formatZweitwert={formatEuroKompakt}
maxBalken={8}
/>
</ChartCard>
<ChartCard
id="team-abwesenheit"
titel="Abwesenheiten"
untertitel="Stunden im gewählten Zeitraum"
>
<Donut
daten={abwesenheitNach}
formatWert={(w) => formatStunden(w)}
hoehe={210}
mitteLabel="Stunden"
/>
</ChartCard>
</div>
<ChartCard
id="team-tabelle"
titel="Mitarbeiterübersicht"
untertitel="Alle gewerblich Beschäftigten mit Kennzahlen"
>
<DataTable
zeilen={tabellenZeilen}
spalten={spalten}
proSeite={10}
suchFelder={(k) => `${k.mitarbeiter.name} ${k.mitarbeiter.rolle} ${k.mitarbeiter.gewerk}`}
/>
</ChartCard>
</PageContainer>
</>
);
}
@@ -0,0 +1,273 @@
"use client";
import React from "react";
import { PageHeader } from "../components/layout/PageHeader";
import { PageContainer, Raster } from "../components/layout/PageContainer";
import { AnalyticsToolbar } from "../components/filters/AnalyticsToolbar";
import { KPICard } from "../components/cards/KPICard";
import { ChartCard } from "../components/cards/ChartCard";
import { AlertList } from "../components/cards/AlertList";
import { StatZeile } from "../components/cards/StatZeile";
import { AreaVerlauf } from "../components/charts/AreaVerlauf";
import { BalkenHorizontal } from "../components/charts/BalkenHorizontal";
import { AuslastungsBalken } from "../components/charts/AuslastungsBalken";
import { Trichter } from "../components/charts/Trichter";
import { ChartLegende } from "../components/charts/ChartLegende";
import { DataTable, type Spalte } from "../components/tables/DataTable";
import { AuftragBadge } from "../components/tables/StatusBadge";
import { useAnalyseDaten } from "../hooks/useAnalyseDaten";
import {
aktiveAuftraege,
handlungsbedarf,
marge,
neueKunden,
neueKundenVorperiode,
zahlungsdauer,
offenePosten,
teamKennzahlen,
ueberfaelligeAuftraege,
umsatz,
umsatzNachGewerk,
umsatzVerlauf,
umsatzVorperiode,
vertriebsTrichter,
} from "../data/calculations";
import {
berechneTrend,
formatEuro,
formatEuroAchse,
formatEuroKompakt,
formatProzent,
formatZahl,
tageSeit,
tageLabel,
formatTage,
} from "../utils/formatters";
import { HEUTE } from "../utils/dateUtils";
import { PRIMAER_FARBE, VERGLEICH_FARBE,
STATUS_TEXT,
} from "../utils/chartTheme";
import type { Auftrag } from "../data/types";
export function UebersichtSeite() {
const { daten, filter } = useAnalyseDaten("uebersicht");
const umsatzAktuell = umsatz(daten.rechnungen, filter.zeitraum);
const umsatzVorher = umsatzVorperiode(daten.rechnungen, filter.zeitraum);
const verlauf = umsatzVerlauf(daten.rechnungen, filter.zeitraum);
const posten = offenePosten(daten.rechnungen);
const aktiv = aktiveAuftraege(daten.auftraege);
const ueberfaellig = ueberfaelligeAuftraege(daten.auftraege);
const team = teamKennzahlen(daten.mitarbeiter, daten.zeiten, daten.auftraege, filter.zeitraum);
const alerts = handlungsbedarf(daten);
const monteureAktiv = team.filter((t) => t.mitarbeiter.status === "aktiv");
const durchschnittAuslastung =
monteureAktiv.length > 0
? monteureAktiv.reduce((s, t) => s + t.auslastungProzent, 0) / monteureAktiv.length
: 0;
const sparkline = verlauf.slice(-10).map((p) => p.value);
const gewerkUmsatz = umsatzNachGewerk(daten.auftraege, daten.rechnungen, filter.zeitraum);
const trichter = vertriebsTrichter(daten.auftraege);
const auftragSpalten: Spalte<Auftrag>[] = [
{
key: "nummer",
titel: "Auftrag",
breite: "26%",
zelle: (a) => (
<div className="flex flex-col">
<span className="font-medium">{a.titel}</span>
<span className="text-[11px] text-text-neutral-tertiary">{a.nummer}</span>
</div>
),
sortWert: (a) => a.nummer,
},
{
key: "gewerk",
titel: "Gewerk",
zelle: (a) => <span className="text-text-neutral-secondary">{a.gewerk}</span>,
sortWert: (a) => a.gewerk,
},
{ key: "status", titel: "Status", zelle: (a) => <AuftragBadge status={a.status} /> },
{
key: "faellig",
titel: "Fällig seit",
numerisch: true,
zelle: (a) => (
<span className="font-medium" style={{ color: STATUS_TEXT.negativ }}>
{tageLabel(tageSeit(a.faelligAm, HEUTE))}
</span>
),
sortWert: (a) => tageSeit(a.faelligAm, HEUTE),
},
{
key: "wert",
titel: "Wert",
numerisch: true,
zelle: (a) => formatEuro(a.wert),
sortWert: (a) => a.wert,
},
];
return (
<>
<PageHeader
titel="Übersicht"
beschreibung="Die Kennzahlen, nach denen der Betrieb gesteuert wird — Umsatz, Auslastung, offene Posten und Handlungsbedarf."
/>
<AnalyticsToolbar seite="uebersicht" />
<PageContainer>
<Raster spalten={5}>
<KPICard
label="Umsatz (Zahlungseingang)"
wert={formatEuro(umsatzAktuell)}
zusatz={`Deckungsbeitrag ${formatProzent(marge(daten.auftraege, filter.zeitraum))}`}
trend={berechneTrend(umsatzAktuell, umsatzVorher)}
icon="Euro"
verlauf={sparkline}
/>
<KPICard
label="Offene Forderungen"
wert={formatEuro(posten.gesamt)}
zusatz={`${posten.anzahl} Rechnungen · ${posten.ueberfaelligAnzahl} überfällig`}
icon="FileText"
bezug="stichtag"
akzent={posten.ueberfaelligAnzahl > 0 ? "warnung" : "neutral"}
/>
<KPICard
label="Aktive Aufträge"
wert={formatZahl(aktiv.length)}
zusatz={`${formatEuro(aktiv.reduce((s, a) => s + a.wert, 0))} Auftragsbestand`}
icon="ClipboardList"
bezug="stichtag"
/>
<KPICard
label="Ø Auslastung Monteure"
wert={formatProzent(durchschnittAuslastung, 0)}
zusatz={`${monteureAktiv.length} Personen im Einsatz`}
icon="HardHat"
akzent={durchschnittAuslastung > 95 ? "warnung" : durchschnittAuslastung < 70 ? "info" : "positiv"}
/>
<KPICard
label="Neue Kunden"
wert={formatZahl(neueKunden(daten.kunden, filter.zeitraum))}
zusatz={`${formatZahl(daten.kunden.filter((k) => k.auftraegeGesamt > 0).length)} Kunden mit Auftrag insgesamt`}
trend={berechneTrend(
neueKunden(daten.kunden, filter.zeitraum),
neueKundenVorperiode(daten.kunden, filter.zeitraum)
)}
icon="Users"
/>
</Raster>
<ChartCard
id="uebersicht-handlungsbedarf"
titel="Handlungsbedarf"
untertitel="Sortiert nach Dringlichkeit — jede Zeile führt in die zugehörige Arbeitsliste"
>
<AlertList eintraege={alerts} spalten={2} />
</ChartCard>
<div className="grid grid-cols-1 items-start gap-4 xl:grid-cols-3">
<ChartCard
id="uebersicht-umsatzverlauf"
titel="Zahlungseingang im Zeitverlauf"
untertitel="Aktueller Zeitraum gegen den Vorjahreszeitraum"
hinweis="Gezählt wird der Tag des Zahlungseingangs, nicht das Rechnungsdatum. Dadurch entspricht die Kurve dem tatsächlichen Geldfluss."
className="xl:col-span-2"
legende={
<ChartLegende
eintraege={[
{ name: "Aktueller Zeitraum", farbe: PRIMAER_FARBE },
{ name: "Vorjahr", farbe: VERGLEICH_FARBE, gestrichelt: true },
]}
/>
}
>
<AreaVerlauf
daten={verlauf}
formatWert={formatEuroKompakt}
formatAchse={formatEuroAchse}
zeigeVergleich
hoehe={268}
/>
<StatZeile
spalten={3}
eintraege={[
{ label: "Vorperiode", wert: formatEuro(umsatzVorher) },
{
label: "Ø Auftragswert",
wert: formatEuro(
daten.auftraege.length
? daten.auftraege.reduce((s, a) => s + a.wert, 0) / daten.auftraege.length
: 0
),
},
{ label: "Ø Zahlungsdauer", wert: formatTage(zahlungsdauer(daten.rechnungen, filter.zeitraum)) },
]}
/>
</ChartCard>
<ChartCard
id="uebersicht-gewerke"
titel="Umsatz nach Gewerk"
untertitel="Zahlungseingang im gewählten Zeitraum"
hinweis="Fünf Gewerke in fester Rangfolge. Dieselbe Kodierung wie auf der Finanzseite — ein Ring und eine Balkenliste für dieselbe Zahl wären zwei Bilder für einen Sachverhalt."
>
<BalkenHorizontal
daten={gewerkUmsatz}
formatWert={formatEuroKompakt}
einfarbig={false}
/>
</ChartCard>
</div>
<div className="grid grid-cols-1 items-start gap-4 lg:grid-cols-2">
<ChartCard
id="uebersicht-trichter"
titel="Vertriebstrichter"
untertitel="Angebotsgeschäft ab 6.000 €, zum Stichtag"
hinweis="Nur Vorhaben, für die ein schriftliches Angebot erstellt wird. Wartung und Notdienst laufen ohne Angebot und würden die Quoten verfälschen. Rechte Spalte: Übergang von der vorherigen Stufe."
>
<Trichter stufen={trichter} formatWert={(w) => formatZahl(w)} />
</ChartCard>
<ChartCard
id="uebersicht-auslastung"
titel="Auslastung Monteure"
untertitel="Produktive Stunden gegen verfügbare Stunden"
hinweis="Nur auf Aufträge gebuchte Stunden zählen als produktiv. Über 100 % bedeutet Überstunden."
>
<AuslastungsBalken
zeilen={monteureAktiv.slice(0, 6).map((t) => ({
name: t.mitarbeiter.name,
wert: t.auslastungProzent,
zusatz: t.mitarbeiter.gewerk,
}))}
/>
</ChartCard>
</div>
<ChartCard
id="uebersicht-ueberfaellig"
titel={`Aufträge über Termin (${ueberfaellig.length})`}
untertitel="Fälligkeitsdatum überschritten, noch nicht abgeschlossen"
>
<DataTable
zeilen={ueberfaellig}
spalten={auftragSpalten}
proSeite={6}
suchFelder={(a) => `${a.titel} ${a.nummer} ${a.gewerk}`}
leerText="Kein Auftrag ist über Termin — sehr gut."
/>
</ChartCard>
</PageContainer>
</>
);
}