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

+568
View File
@@ -0,0 +1,568 @@
/**
* Kennzahlen-Berechnungen.
*
* Alle Funktionen sind pure functions über dem gefilterten Datensatz
* (Anforderung INFRA-06) — die Entwicklung kann sie unverändert übernehmen
* und lediglich die Datenquelle austauschen.
*
* Die Definition jeder Kennzahl steht in docs/KPI-KATALOG.md.
*/
import {
AUFTRAG_STATUS_LABEL,
FUNNEL_STUFEN,
RECHNUNG_STATUS_LABEL,
type Auftrag,
type AuftragStatus,
type ChartPunkt,
type Datensatz,
type Kunde,
type Rechnung,
FOERDERFAEHIGE_KATEGORIEN,
type ZeitraumPreset,
type ZeitreihePunkt,
type Zeiteintrag,
type Mitarbeiter,
} from "./types";
import {
HEUTE,
bucketKey,
bucketsFuer,
formatWoche,
imFenster,
vorperiode,
zeitfenster,
addMonate,
} from "../utils/dateUtils";
import { formatDatumKurz, formatMonatKurz, tageSeit } from "../utils/formatters";
/* ------------------------------------------------------------- Umsatz */
/** Umsatz = Summe bezahlter Ausgangsrechnungen im Zeitraum (Zahlungseingang). */
export function umsatz(rechnungen: Rechnung[], zeitraum: ZeitraumPreset): number {
const fenster = zeitfenster(zeitraum);
return rechnungen
.filter((r) => r.status === "bezahlt" && imFenster(r.bezahltAm, fenster))
.reduce((summe, r) => summe + r.betrag, 0);
}
/** Gleiche Berechnung für die Vorperiode — Basis der Trend-Badges. */
export function umsatzVorperiode(rechnungen: Rechnung[], zeitraum: ZeitraumPreset): number {
const fenster = vorperiode(zeitraum);
return rechnungen
.filter((r) => r.status === "bezahlt" && imFenster(r.bezahltAm, fenster))
.reduce((summe, r) => summe + r.betrag, 0);
}
/** Beschriftung eines Buckets — eine Stelle fuer alle drei Zeitreihen. */
function bucketLabel(key: string, art: "tag" | "woche" | "monat"): string {
if (art === "monat") return formatMonatKurz(key);
if (art === "woche") return formatWoche(key);
return formatDatumKurz(key);
}
/**
* Umsatzverlauf mit Vorjahresvergleich.
* Buckets richten sich nach dem Zeitraum (Tage bei ≤ 30 Tagen, sonst Monate).
*/
export function umsatzVerlauf(
rechnungen: Rechnung[],
zeitraum: ZeitraumPreset
): ZeitreihePunkt[] {
const { art, schluessel } = bucketsFuer(zeitraum);
const aktuell = new Map<string, number>();
const vorjahr = new Map<string, number>();
for (const r of rechnungen) {
if (r.status !== "bezahlt" || !r.bezahltAm) continue;
aktuell.set(
bucketKey(r.bezahltAm, art),
(aktuell.get(bucketKey(r.bezahltAm, art)) ?? 0) + r.betrag
);
// Vorjahreswert: dasselbe Datum plus 12 Monate landet im aktuellen Bucket.
const verschoben = addMonate(new Date(r.bezahltAm), 12);
const key = bucketKey(verschoben.toISOString().slice(0, 10), art);
vorjahr.set(key, (vorjahr.get(key) ?? 0) + r.betrag);
}
return schluessel.map((key) => ({
datum: key,
label: bucketLabel(key, art),
value: aktuell.get(key) ?? 0,
vergleich: vorjahr.get(key) ?? 0,
}));
}
/** Deckungsbeitrag: gewichtete Marge über abgeschlossene Aufträge im Zeitraum. */
export function marge(auftraege: Auftrag[], zeitraum: ZeitraumPreset): number {
const fenster = zeitfenster(zeitraum);
const relevant = auftraege.filter(
(a) => a.status === "abgeschlossen" && imFenster(a.abgeschlossenAm, fenster)
);
const gesamtwert = relevant.reduce((s, a) => s + a.wert, 0);
if (gesamtwert === 0) return 0;
const db = relevant.reduce((s, a) => s + (a.wert * a.margeProzent) / 100, 0);
return (db / gesamtwert) * 100;
}
/* --------------------------------------------------------- Rechnungen */
export interface OffenePosten {
gesamt: number;
anzahl: number;
ueberfaelligBetrag: number;
ueberfaelligAnzahl: number;
nachAlter: ChartPunkt[];
liste: Rechnung[];
}
/**
* Offene Posten sind stichtagsbezogen (nicht zeitraumgefiltert):
* Was ist heute noch nicht bezahlt?
*/
export function offenePosten(rechnungen: Rechnung[]): OffenePosten {
const offen = rechnungen.filter((r) => r.status === "gestellt" || r.status === "ueberfaellig");
const buckets: Record<string, { betrag: number; anzahl: number }> = {
"0–30 Tage": { betrag: 0, anzahl: 0 },
"31–60 Tage": { betrag: 0, anzahl: 0 },
"61–90 Tage": { betrag: 0, anzahl: 0 },
"> 90 Tage": { betrag: 0, anzahl: 0 },
};
for (const r of offen) {
const tage = tageSeit(r.faelligAm, HEUTE);
const bucket =
tage <= 30 ? "0–30 Tage" : tage <= 60 ? "31–60 Tage" : tage <= 90 ? "61–90 Tage" : "> 90 Tage";
buckets[bucket].betrag += r.betrag;
buckets[bucket].anzahl += 1;
}
const ueberfaellig = offen.filter((r) => r.status === "ueberfaellig");
return {
gesamt: offen.reduce((s, r) => s + r.betrag, 0),
anzahl: offen.length,
ueberfaelligBetrag: ueberfaellig.reduce((s, r) => s + r.betrag, 0),
ueberfaelligAnzahl: ueberfaellig.length,
nachAlter: Object.entries(buckets).map(([name, v]) => ({ name, value: v.betrag })),
liste: offen.sort((a, b) => (a.faelligAm < b.faelligAm ? -1 : 1)),
};
}
/** Durchschnittliche Zahlungsdauer in Tagen (gestellt → bezahlt). */
export function zahlungsdauer(rechnungen: Rechnung[], zeitraum: ZeitraumPreset): number {
const fenster = zeitfenster(zeitraum);
const bezahlt = rechnungen.filter(
(r) => r.status === "bezahlt" && r.bezahltAm && imFenster(r.bezahltAm, fenster)
);
if (!bezahlt.length) return 0;
const summe = bezahlt.reduce(
(s, r) =>
s + (new Date(r.bezahltAm!).getTime() - new Date(r.gestelltAm).getTime()) / 86_400_000,
0
);
return summe / bezahlt.length;
}
/**
* Zusammensetzung des OFFENEN Bestands.
*
* Nicht zu verwechseln mit rechnungenNachStatus(): dort steht der kumulierte
* Umsatz aus zwei Jahren gegen den heutigen Forderungsbestand — dabei entfallen
* über 90 % auf "Bezahlt", und der Ring zeigt nichts mehr. Der offene Bestand
* ist ein echtes Ganzes: alles, was heute noch aussteht.
*/
export function offeneNachStatus(rechnungen: Rechnung[]): ChartPunkt[] {
// Entwuerfe sind noch nicht gestellt und damit keine Forderung. Wuerden sie
// mitzaehlen, waeche die Ringsumme von der KPI "Offene Forderungen" ab.
const offen = rechnungen.filter(
(r) => r.richtung === "ausgang" && (r.status === "gestellt" || r.status === "ueberfaellig")
);
const summen = new Map<string, number>();
for (const r of offen) {
const label = RECHNUNG_STATUS_LABEL[r.status];
summen.set(label, (summen.get(label) ?? 0) + r.betrag);
}
return [...summen.entries()].map(([name, value]) => ({ name, value }));
}
export function rechnungenNachStatus(rechnungen: Rechnung[]): ChartPunkt[] {
const zaehler = new Map<string, number>();
for (const r of rechnungen) {
const label = RECHNUNG_STATUS_LABEL[r.status];
zaehler.set(label, (zaehler.get(label) ?? 0) + r.betrag);
}
return [...zaehler.entries()].map(([name, value]) => ({ name, value }));
}
/* ------------------------------------------------------------ Aufträge */
export function auftraegeImZeitraum(auftraege: Auftrag[], zeitraum: ZeitraumPreset): Auftrag[] {
const fenster = zeitfenster(zeitraum);
return auftraege.filter((a) => imFenster(a.angelegtAm, fenster));
}
/** "Aktiv" = beauftragt oder in Arbeit — das, was das Team gerade bindet. */
export function aktiveAuftraege(auftraege: Auftrag[]): Auftrag[] {
return auftraege.filter((a) => a.status === "beauftragt" || a.status === "in_arbeit");
}
export function ueberfaelligeAuftraege(auftraege: Auftrag[]): Auftrag[] {
// Einen Termin gibt es erst ab der Beauftragung — eine offene Anfrage kann
// nicht "über Termin" sein.
return auftraege
.filter(
(a) =>
(a.status === "beauftragt" || a.status === "in_arbeit") &&
new Date(a.faelligAm) < HEUTE
)
.sort((a, b) => (a.faelligAm < b.faelligAm ? -1 : 1));
}
export function auftraegeNachStatus(auftraege: Auftrag[]): ChartPunkt[] {
const zaehler = new Map<AuftragStatus, number>();
for (const a of auftraege) zaehler.set(a.status, (zaehler.get(a.status) ?? 0) + 1);
return (Object.keys(AUFTRAG_STATUS_LABEL) as AuftragStatus[])
.map((status) => ({ name: AUFTRAG_STATUS_LABEL[status], value: zaehler.get(status) ?? 0 }))
.filter((p) => p.value > 0);
}
export function auftraegeNachGewerk(auftraege: Auftrag[]): ChartPunkt[] {
const zaehler = new Map<string, number>();
for (const a of auftraege) zaehler.set(a.gewerk, (zaehler.get(a.gewerk) ?? 0) + 1);
return [...zaehler.entries()]
.map(([name, value]) => ({ name, value }))
.sort((a, b) => b.value - a.value);
}
export function umsatzNachGewerk(
auftraege: Auftrag[],
rechnungen: Rechnung[],
zeitraum: ZeitraumPreset
): ChartPunkt[] {
const fenster = zeitfenster(zeitraum);
const gewerkProAuftrag = new Map(auftraege.map((a) => [a.id, a.gewerk]));
const summen = new Map<string, number>();
for (const r of rechnungen) {
if (r.status !== "bezahlt" || !imFenster(r.bezahltAm, fenster)) continue;
const gewerk = gewerkProAuftrag.get(r.auftragId);
if (!gewerk) continue;
summen.set(gewerk, (summen.get(gewerk) ?? 0) + r.betrag);
}
return [...summen.entries()]
.map(([name, value]) => ({ name, value }))
.sort((a, b) => b.value - a.value);
}
/**
* Vertriebstrichter: Wie viele Vorgänge haben eine Stufe mindestens erreicht?
* Verlorene Aufträge zählen nur bis zu ihrer letzten erreichten Stufe.
*/
/**
* Vertriebstrichter — bewusst nur über das Angebotsgeschäft.
*
* Wartung, Notdienst und E-Check laufen ohne Angebot direkt in die Ausführung.
* Zählte man sie mit, würde der Trichter unten breiter als oben und die
* Übergangsquoten wären wertlos.
*/
export function vertriebsTrichter(auftraege: Auftrag[]): ChartPunkt[] {
const rang = (status: AuftragStatus) => FUNNEL_STUFEN.indexOf(status);
const angebotsgeschaeft = auftraege.filter((a) => a.ueberAngebot);
return FUNNEL_STUFEN.map((stufe, index) => {
const anzahl = angebotsgeschaeft.filter((a) => {
// Verlorene Vorgänge zählen bis zu der Stufe, auf der sie abgesprungen sind.
if (a.status === "verloren") {
return a.verlorenAb ? rang(a.verlorenAb) >= index : false;
}
return rang(a.status) >= index;
}).length;
return { name: AUFTRAG_STATUS_LABEL[stufe], value: anzahl };
});
}
export function abschlussquote(auftraege: Auftrag[]): number {
// Bezugsgröße ist ausschließlich das Angebotsgeschäft. Wartungs- und
// Notdienstaufträge laufen ohne Angebot und würden die Quote schönrechnen.
const mitAngebot = auftraege.filter(
(a) =>
a.ueberAngebot &&
(["angebot", "beauftragt", "in_arbeit", "abgeschlossen"].includes(a.status) ||
(a.status === "verloren" && a.verlorenAb === "angebot"))
);
if (!mitAngebot.length) return 0;
const gewonnen = mitAngebot.filter((a) =>
["beauftragt", "in_arbeit", "abgeschlossen"].includes(a.status)
).length;
return (gewonnen / mitAngebot.length) * 100;
}
/** Ø Durchlaufzeit abgeschlossener Aufträge in Tagen. */
export function durchlaufzeit(auftraege: Auftrag[]): number {
const fertig = auftraege.filter((a) => a.status === "abgeschlossen" && a.abgeschlossenAm);
if (!fertig.length) return 0;
const summe = fertig.reduce(
(s, a) =>
s + (new Date(a.abgeschlossenAm!).getTime() - new Date(a.angelegtAm).getTime()) / 86_400_000,
0
);
return summe / fertig.length;
}
export function auftragseingang(auftraege: Auftrag[], zeitraum: ZeitraumPreset): ZeitreihePunkt[] {
const { art, schluessel } = bucketsFuer(zeitraum);
const zaehler = new Map<string, number>();
for (const a of auftraege) {
const key = bucketKey(a.angelegtAm, art);
zaehler.set(key, (zaehler.get(key) ?? 0) + 1);
}
return schluessel.map((key) => ({
datum: key,
label: bucketLabel(key, art),
value: zaehler.get(key) ?? 0,
}));
}
/* -------------------------------------------------------------- Kunden */
export function neueKunden(kunden: Kunde[], zeitraum: ZeitraumPreset): number {
const fenster = zeitfenster(zeitraum);
return kunden.filter((k) => imFenster(k.angelegtAm, fenster)).length;
}
/** Gleiches Fenster davor — Basis fuer den Trend an der Neukunden-Karte. */
export function neueKundenVorperiode(kunden: Kunde[], zeitraum: ZeitraumPreset): number {
const fenster = vorperiode(zeitraum);
return kunden.filter((k) => imFenster(k.angelegtAm, fenster)).length;
}
export function kundenEntwicklung(kunden: Kunde[], zeitraum: ZeitraumPreset): ZeitreihePunkt[] {
const { art, schluessel } = bucketsFuer(zeitraum);
const zaehler = new Map<string, number>();
for (const k of kunden) {
const key = bucketKey(k.angelegtAm, art);
zaehler.set(key, (zaehler.get(key) ?? 0) + 1);
}
return schluessel.map((key) => ({
datum: key,
label: bucketLabel(key, art),
value: zaehler.get(key) ?? 0,
}));
}
export function kundenNach(kunden: Kunde[], feld: "quelle" | "typ" | "region"): ChartPunkt[] {
const zaehler = new Map<string, number>();
for (const k of kunden) zaehler.set(k[feld], (zaehler.get(k[feld]) ?? 0) + 1);
return [...zaehler.entries()]
.map(([name, value]) => ({ name, value }))
.sort((a, b) => b.value - a.value);
}
export function topKunden(kunden: Kunde[], anzahl = 5): ChartPunkt[] {
return [...kunden]
.filter((k) => k.umsatzGesamt > 0)
.sort((a, b) => b.umsatzGesamt - a.umsatzGesamt)
.slice(0, anzahl)
.map((k) => ({ name: k.name, value: k.umsatzGesamt }));
}
/** Anteil Kunden mit mehr als einem Auftrag. */
export function wiederkehrquote(kunden: Kunde[]): number {
const mitAuftrag = kunden.filter((k) => k.auftraegeGesamt > 0);
if (!mitAuftrag.length) return 0;
return (mitAuftrag.filter((k) => k.auftraegeGesamt > 1).length / mitAuftrag.length) * 100;
}
/** Kunden, die seit über 12 Monaten keinen Auftrag hatten. */
export function inaktiveKunden(kunden: Kunde[]): Kunde[] {
const grenze = addMonate(HEUTE, -12);
return kunden
.filter((k) => k.auftraegeGesamt > 0 && k.letzterAuftragAm && new Date(k.letzterAuftragAm) < grenze)
.sort((a, b) => b.umsatzGesamt - a.umsatzGesamt);
}
/** Kunden mit auffälliger Zahlungsmoral (> 30 Tage im Schnitt). */
export function zahlungsauffaellig(kunden: Kunde[]): Kunde[] {
return kunden
.filter((k) => k.zahlungsmoralTage > 30 && k.auftraegeGesamt > 0)
.sort((a, b) => b.zahlungsmoralTage - a.zahlungsmoralTage);
}
/* ---------------------------------------------------------------- Team */
export interface MitarbeiterKennzahl {
mitarbeiter: Mitarbeiter;
stunden: number;
produktivStunden: number;
auslastungProzent: number;
abgeschlossen: number;
umsatz: number;
}
/**
* Auslastung = erfasste Arbeitsstunden / verfügbare Stunden im Zeitraum.
* Verfügbare Stunden werden aus den Wochenstunden hochgerechnet.
*/
export function teamKennzahlen(
mitarbeiter: Mitarbeiter[],
zeiten: Zeiteintrag[],
auftraege: Auftrag[],
zeitraum: ZeitraumPreset
): MitarbeiterKennzahl[] {
const fenster = zeitfenster(zeitraum);
const tageImFenster = Math.max(
1,
Math.round((fenster.bis.getTime() - fenster.von.getTime()) / 86_400_000)
);
const wochen = Math.max(1, tageImFenster / 7);
return mitarbeiter
.filter((m) => m.rolle !== "Büro")
.map((m) => {
const eigene = zeiten.filter((z) => z.mitarbeiterId === m.id && imFenster(z.datum, fenster));
const stunden = eigene.reduce((s, z) => s + z.stunden, 0);
const produktiv = eigene
.filter((z) => z.art === "arbeit" && z.auftragId)
.reduce((s, z) => s + z.stunden, 0);
const verfuegbar = m.wochenstunden * wochen;
const eigeneAuftraege = auftraege.filter((a) => a.mitarbeiterId === m.id);
const abgeschlossen = eigeneAuftraege.filter(
(a) => a.status === "abgeschlossen" && imFenster(a.abgeschlossenAm, fenster)
);
return {
mitarbeiter: m,
stunden,
produktivStunden: produktiv,
auslastungProzent: verfuegbar > 0 ? Math.min(135, (produktiv / verfuegbar) * 100) : 0,
abgeschlossen: abgeschlossen.length,
umsatz: abgeschlossen.reduce((s, a) => s + a.wert, 0),
};
})
.sort((a, b) => b.auslastungProzent - a.auslastungProzent);
}
/* -------------------------------------------------------------- Alerts */
export interface AlertEintrag {
id: string;
text: string;
detail: string;
art: "kritisch" | "warnung" | "hinweis";
/** Betrag, um den es geht — macht die Zeilen untereinander vergleichbar. */
betrag?: number;
/**
* Die Handlung, nicht die Beobachtung. Eine Liste ohne Verb ist ein Bericht;
* "Was ist zu tun" braucht ein Verb je Zeile.
*/
aktion: string;
}
/** Handlungsbedarf für die Übersichtsseite. */
export function handlungsbedarf(daten: Datensatz): AlertEintrag[] {
const eintraege: AlertEintrag[] = [];
const posten = offenePosten(daten.rechnungen);
const ueberfaellig = ueberfaelligeAuftraege(daten.auftraege);
const kritischAlt = posten.nachAlter.find((b) => b.name === "> 90 Tage");
if (posten.ueberfaelligAnzahl > 0) {
eintraege.push({
id: "rechnungen-ueberfaellig",
text: `${posten.ueberfaelligAnzahl} überfällige Rechnungen`,
detail: "Zahlungsziel überschritten",
betrag: posten.ueberfaelligBetrag,
aktion: "Mahnlauf starten",
art: "kritisch",
});
}
if (kritischAlt && kritischAlt.value > 0) {
eintraege.push({
id: "rechnungen-90",
text: "Forderungen älter als 90 Tage",
detail: "Einbringungsquote sinkt deutlich",
betrag: kritischAlt.value,
aktion: "Inkasso prüfen",
art: "kritisch",
});
}
if (ueberfaellig.length > 0) {
eintraege.push({
id: "auftraege-ueberfaellig",
text: `${ueberfaellig.length} Aufträge über Termin`,
detail: `Ältester seit ${tageSeit(ueberfaellig[0].faelligAm, HEUTE)} Tagen fällig`,
betrag: ueberfaellig.reduce((s, a) => s + a.wert, 0),
aktion: "Termine neu planen",
art: "warnung",
});
}
const offeneAngebote = daten.auftraege.filter(
(a) => a.status === "angebot" && tageSeit(a.angelegtAm, HEUTE) > 21
);
if (offeneAngebote.length > 0) {
eintraege.push({
id: "angebote-alt",
text: `${offeneAngebote.length} Angebote ohne Rückmeldung`,
detail: "Seit über 21 Tagen offen",
betrag: offeneAngebote.reduce((s, a) => s + a.wert, 0),
aktion: "Nachfassen",
art: "warnung",
});
}
const foerderOffen = daten.auftraege.filter((a) => a.foerderung === "beantragt");
if (foerderOffen.length > 0) {
eintraege.push({
id: "foerderung",
text: `${foerderOffen.length} Förderanträge in Bearbeitung`,
detail: "Bescheid ausstehend",
betrag: foerderOffen.reduce((s, a) => s + a.foerderbetrag, 0),
aktion: "Status prüfen",
art: "hinweis",
});
}
return eintraege;
}
/* --------------------------------------------------------- Förderung */
/**
* Förderquote BAFA/KfW.
*
* Bezugsgröße sind ausschließlich förderfähige Leistungen (Wärmepumpe, PV,
* Speicher, Lüftung). Über alle Aufträge gerechnet läge die Quote im
* einstelligen Bereich und wäre wertlos — eine Badwartung war nie förderfähig.
*/
export function foerderQuote(auftraege: Auftrag[]): {
quote: number;
foerderfaehig: number;
bewilligt: number;
beantragt: number;
summe: number;
verteilung: ChartPunkt[];
} {
const foerderfaehig = auftraege.filter((a) => FOERDERFAEHIGE_KATEGORIEN.has(a.kategorie));
const bewilligt = foerderfaehig.filter((a) => a.foerderung === "bewilligt");
const beantragt = foerderfaehig.filter((a) => a.foerderung === "beantragt");
const mitFoerderung = bewilligt.length + beantragt.length;
return {
quote: foerderfaehig.length ? (mitFoerderung / foerderfaehig.length) * 100 : 0,
foerderfaehig: foerderfaehig.length,
bewilligt: bewilligt.length,
beantragt: beantragt.length,
summe: bewilligt.reduce((s, a) => s + a.foerderbetrag, 0),
verteilung: [
{ name: "Bewilligt", value: bewilligt.length },
{ name: "Beantragt", value: beantragt.length },
{ name: "Nicht beantragt", value: foerderfaehig.length - mitFoerderung },
],
};
}