florian.wildeandClaude Opus 5
840e902b26
Eigene Hosts brauchen einen Kunden - sonst stehen sie unter "Nicht zugeordnet" und fehlen in jeder Auswertung. Als gewoehnlicher Kunde erzeugen sie aber Aufgaben, die es nicht gibt: Kundenrechnung erstellen, Kundenrechnung unbezahlt, dazu eine negative Marge in jeder Summe. Das Kennzeichen Eigenbedarf am Kunden nimmt die Verkaufsseite heraus: kein Formular fuer die Kundenrechnung, keine Warnungen darueber, keine Aufgabe, keine Marge - und in den Summen zaehlt der Einkauf mit, Verkauf und Marge nicht. Die Einkaufsseite bleibt vollstaendig: Eigene Hosts kosten echtes Geld, und die Rechnung von Proxmox will bezahlt werden. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
516 lines
18 KiB
TypeScript
516 lines
18 KiB
TypeScript
import type { AlertSchwere, SubscriptionStatus } from "@/generated/prisma/enums";
|
||
import { formatDatum, formatEuro } from "@/lib/format";
|
||
|
||
/**
|
||
* Warnregeln als reine Funktionen: Sie bekommen einen Ausschnitt der Daten und geben
|
||
* Kandidaten zurück. Kein Datenbankzugriff, keine Nebenwirkungen – dadurch sind sie einzeln testbar.
|
||
* Das Öffnen und Schließen der Alerts übernimmt der Abgleich (`abgleich.ts`).
|
||
*/
|
||
|
||
export interface AlertKandidat {
|
||
/** Regel + betroffenes Objekt (+ Stufe). Zwei Kandidaten mit gleichem Fingerabdruck sind derselbe Fall. */
|
||
fingerprint: string;
|
||
regel: string;
|
||
schwere: AlertSchwere;
|
||
titel: string;
|
||
beschreibung: string;
|
||
hostId: string | null;
|
||
kundeId: string | null;
|
||
laufzeitId: string | null;
|
||
}
|
||
|
||
export interface HostDaten {
|
||
id: string;
|
||
hostname: string;
|
||
clusterName: string | null;
|
||
clusterMitglieder: string[];
|
||
kundeId: string | null;
|
||
kundeName: string | null;
|
||
subKey: string | null;
|
||
subStatus: SubscriptionStatus;
|
||
subNextduedate: Date | null;
|
||
subLizenzierteSockets: number | null;
|
||
sockets: number | null;
|
||
letzterReportAm: Date | null;
|
||
ips: string[];
|
||
serverIds: { serverId: string; ersteMeldung: Date; letzteMeldung: Date }[];
|
||
}
|
||
|
||
export interface LaufzeitDaten {
|
||
id: string;
|
||
hostId: string;
|
||
hostname: string;
|
||
kundeId: string | null;
|
||
/** Eigene Hosts werden nicht weiterberechnet – die Verkaufsseite entfällt (#044). */
|
||
kundeEigenbedarf: boolean;
|
||
kundeName: string | null;
|
||
key: string;
|
||
start: Date;
|
||
ende: Date;
|
||
einkaufNummer: string | null;
|
||
einkaufBetrag: number | null;
|
||
einkaufBezahlt: boolean | null;
|
||
einkaufFaelligAm: Date | null;
|
||
verkaufNummer: string | null;
|
||
verkaufBetrag: number | null;
|
||
verkaufErstellt: boolean;
|
||
verkaufBezahlt: boolean;
|
||
verkaufDatum: Date | null;
|
||
}
|
||
|
||
export interface RegelKontext {
|
||
jetzt: Date;
|
||
hosts: HostDaten[];
|
||
laufzeiten: LaufzeitDaten[];
|
||
einstellungen: Map<string, { aktiv: boolean; schwellwerte: Record<string, unknown> }>;
|
||
}
|
||
|
||
export interface Regel {
|
||
name: string;
|
||
beschreibung: string;
|
||
/** Wird beim Anlegen der Einstellung als Vorgabe gespeichert (JSON-taugliche Werte). */
|
||
standardSchwellwerte: Record<string, number | number[] | string | boolean>;
|
||
pruefe: (kontext: RegelKontext) => AlertKandidat[];
|
||
}
|
||
|
||
const TAG = 86_400_000;
|
||
|
||
function tageBis(datum: Date, jetzt: Date): number {
|
||
const ziel = Date.UTC(datum.getUTCFullYear(), datum.getUTCMonth(), datum.getUTCDate());
|
||
const start = Date.UTC(jetzt.getUTCFullYear(), jetzt.getUTCMonth(), jetzt.getUTCDate());
|
||
return Math.round((ziel - start) / TAG);
|
||
}
|
||
|
||
function schwellwert<T>(kontext: RegelKontext, regel: string, name: string, standard: T): T {
|
||
const wert = kontext.einstellungen.get(regel)?.schwellwerte?.[name];
|
||
return (wert as T) ?? standard;
|
||
}
|
||
|
||
function kundenHinweis(kundeName: string | null): string {
|
||
return kundeName ?? "Nicht zugeordnet";
|
||
}
|
||
|
||
// ---------------------------------------------------------------- Regeln
|
||
|
||
const subscriptionLaeuftAb: Regel = {
|
||
name: "subscription-laeuft-ab",
|
||
beschreibung: "Subscription läuft in wenigen Tagen ab",
|
||
standardSchwellwerte: { tage: [30, 14, 7] },
|
||
pruefe(kontext) {
|
||
const stufen = [...schwellwert<number[]>(kontext, "subscription-laeuft-ab", "tage", [30, 14, 7])].sort(
|
||
(a, b) => b - a,
|
||
);
|
||
|
||
return kontext.hosts.flatMap((host) => {
|
||
if (!host.subNextduedate || host.subStatus !== "ACTIVE") return [];
|
||
const tage = tageBis(host.subNextduedate, kontext.jetzt);
|
||
if (tage < 0) return [];
|
||
|
||
// Immer nur die strengste erreichte Stufe melden.
|
||
const erreicht = stufen.filter((stufe) => tage <= stufe).sort((a, b) => a - b)[0];
|
||
if (erreicht === undefined) return [];
|
||
|
||
return [
|
||
{
|
||
fingerprint: `subscription-laeuft-ab:${host.id}:${erreicht}`,
|
||
regel: "subscription-laeuft-ab",
|
||
schwere: (erreicht <= 7 ? "GEFAHR" : erreicht <= 14 ? "WARNUNG" : "INFO") as AlertSchwere,
|
||
titel: `Subscription läuft in ${tage} Tag${tage === 1 ? "" : "en"} ab`,
|
||
beschreibung: `${host.hostname} · ${kundenHinweis(host.kundeName)} · ${formatDatum(host.subNextduedate)}`,
|
||
hostId: host.id,
|
||
kundeId: host.kundeId,
|
||
laufzeitId: null,
|
||
},
|
||
];
|
||
});
|
||
},
|
||
};
|
||
|
||
/** Eigene Titel, damit die Meldung ein ganzer Satz bleibt. */
|
||
const STATUS_TITEL: Record<SubscriptionStatus, string> = {
|
||
ACTIVE: "Subscription aktiv",
|
||
NOTFOUND: "Keine Subscription gefunden",
|
||
INVALID: "Subscription ungültig",
|
||
EXPIRED: "Subscription abgelaufen",
|
||
SUSPENDED: "Subscription ausgesetzt",
|
||
UNKNOWN: "Subscription-Status unbekannt",
|
||
};
|
||
|
||
const statusNichtAktiv: Regel = {
|
||
name: "status-nicht-aktiv",
|
||
beschreibung: "Subscription ist nicht aktiv",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
return kontext.hosts
|
||
.filter((host) => host.subStatus !== "ACTIVE")
|
||
.map((host) => ({
|
||
fingerprint: `status-nicht-aktiv:${host.id}`,
|
||
regel: "status-nicht-aktiv",
|
||
schwere: (host.subStatus === "NOTFOUND" || host.subStatus === "UNKNOWN"
|
||
? "WARNUNG"
|
||
: "GEFAHR") as AlertSchwere,
|
||
titel: STATUS_TITEL[host.subStatus],
|
||
beschreibung: `${host.hostname} · ${kundenHinweis(host.kundeName)}${
|
||
host.subKey ? ` · ${host.subKey}` : ""
|
||
}`,
|
||
hostId: host.id,
|
||
kundeId: host.kundeId,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const socketsAbweichung: Regel = {
|
||
name: "sockets-abweichung",
|
||
beschreibung: "Lizenzierte und physische Sockets weichen ab",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
return kontext.hosts
|
||
.filter(
|
||
(host) =>
|
||
host.subLizenzierteSockets !== null &&
|
||
host.sockets !== null &&
|
||
host.subLizenzierteSockets !== host.sockets,
|
||
)
|
||
.map((host) => ({
|
||
fingerprint: `sockets-abweichung:${host.id}`,
|
||
regel: "sockets-abweichung",
|
||
schwere: "WARNUNG" as AlertSchwere,
|
||
titel: "Lizenzierte Sockets weichen ab",
|
||
beschreibung: `${host.hostname} · ${host.subLizenzierteSockets} lizenziert, ${host.sockets} physisch vorhanden`,
|
||
hostId: host.id,
|
||
kundeId: host.kundeId,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const keineMeldung: Regel = {
|
||
name: "keine-meldung",
|
||
beschreibung: "Host hat sich lange nicht gemeldet",
|
||
standardSchwellwerte: { stunden: 48 },
|
||
pruefe(kontext) {
|
||
const stunden = schwellwert(kontext, "keine-meldung", "stunden", 48);
|
||
const grenze = new Date(kontext.jetzt.getTime() - stunden * 3_600_000);
|
||
|
||
return kontext.hosts
|
||
.filter((host) => host.letzterReportAm !== null && host.letzterReportAm < grenze)
|
||
.map((host) => ({
|
||
fingerprint: `keine-meldung:${host.id}`,
|
||
regel: "keine-meldung",
|
||
schwere: "WARNUNG" as AlertSchwere,
|
||
titel: `Host meldet sich seit über ${stunden} Stunden nicht`,
|
||
beschreibung: `${host.hostname} · ${kundenHinweis(host.kundeName)} · letzte Meldung ${formatDatum(
|
||
host.letzterReportAm,
|
||
)}`,
|
||
hostId: host.id,
|
||
kundeId: host.kundeId,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const serverIdGeaendert: Regel = {
|
||
name: "serverid-geaendert",
|
||
beschreibung: "Server-ID hat sich geändert (Hardwaretausch oder Neuinstallation)",
|
||
standardSchwellwerte: { tage: 30 },
|
||
pruefe(kontext) {
|
||
const tage = schwellwert(kontext, "serverid-geaendert", "tage", 30);
|
||
const grenze = new Date(kontext.jetzt.getTime() - tage * TAG);
|
||
|
||
return kontext.hosts.flatMap((host) => {
|
||
if (host.serverIds.length < 2) return [];
|
||
|
||
const nachSortiert = [...host.serverIds].sort(
|
||
(a, b) => b.letzteMeldung.getTime() - a.letzteMeldung.getTime(),
|
||
);
|
||
const aktuell = nachSortiert[0];
|
||
const vorher = nachSortiert[1];
|
||
|
||
// Nur melden, solange der Wechsel frisch ist – ein alter Hardwaretausch ist erledigt.
|
||
if (aktuell.ersteMeldung < grenze) return [];
|
||
|
||
return [
|
||
{
|
||
fingerprint: `serverid-geaendert:${host.id}:${aktuell.serverId}`,
|
||
regel: "serverid-geaendert",
|
||
schwere: "GEFAHR" as AlertSchwere,
|
||
titel: "Server-ID hat sich geändert",
|
||
beschreibung: `${host.hostname} · neu ${aktuell.serverId}, vorher ${vorher.serverId} – der Key muss bei Proxmox neu zugewiesen werden`,
|
||
hostId: host.id,
|
||
kundeId: host.kundeId,
|
||
laufzeitId: null,
|
||
},
|
||
];
|
||
});
|
||
},
|
||
};
|
||
|
||
const keyMehrfach: Regel = {
|
||
name: "key-mehrfach-gemeldet",
|
||
beschreibung: "Derselbe Subscription-Key wird von mehreren Hosts gemeldet",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
const proKey = new Map<string, HostDaten[]>();
|
||
for (const host of kontext.hosts) {
|
||
if (!host.subKey) continue;
|
||
proKey.set(host.subKey, [...(proKey.get(host.subKey) ?? []), host]);
|
||
}
|
||
|
||
return [...proKey.entries()]
|
||
.filter(([, hosts]) => hosts.length > 1)
|
||
.map(([key, hosts]) => ({
|
||
fingerprint: `key-mehrfach-gemeldet:${key}`,
|
||
regel: "key-mehrfach-gemeldet",
|
||
schwere: "GEFAHR" as AlertSchwere,
|
||
titel: "Key wird von mehreren Hosts gemeldet",
|
||
beschreibung: `${key} · ${hosts.map((h) => h.hostname).join(", ")}`,
|
||
hostId: hosts[0].id,
|
||
kundeId: hosts[0].kundeId,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const hostOhneKunde: Regel = {
|
||
name: "host-ohne-kunde",
|
||
beschreibung: "Host ist keinem Kunden zugewiesen",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
return kontext.hosts
|
||
.filter((host) => host.kundeId === null)
|
||
.map((host) => ({
|
||
fingerprint: `host-ohne-kunde:${host.id}`,
|
||
regel: "host-ohne-kunde",
|
||
schwere: "INFO" as AlertSchwere,
|
||
titel: "Host ist keinem Kunden zugewiesen",
|
||
beschreibung: `${host.hostname}${host.subKey ? ` · ${host.subKey}` : ""}`,
|
||
hostId: host.id,
|
||
kundeId: null,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const clusterKnotenOhneAgent: Regel = {
|
||
name: "cluster-knoten-ohne-agent",
|
||
beschreibung: "Ein Cluster-Knoten meldet sich nicht beim Dashboard",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
// Alle gemeldeten Hostnamen – ein Knoten gilt als bekannt, wenn er selbst meldet.
|
||
const meldende = new Set(kontext.hosts.map((host) => host.hostname.toLowerCase()));
|
||
|
||
const fehlende = new Map<string, { cluster: string; melder: HostDaten }>();
|
||
for (const host of kontext.hosts) {
|
||
if (!host.clusterName) continue;
|
||
for (const mitglied of host.clusterMitglieder) {
|
||
const name = mitglied.trim();
|
||
if (!name || meldende.has(name.toLowerCase())) continue;
|
||
if (!fehlende.has(name.toLowerCase())) {
|
||
fehlende.set(name.toLowerCase(), { cluster: host.clusterName, melder: host });
|
||
}
|
||
}
|
||
}
|
||
|
||
return [...fehlende.entries()].map(([name, eintrag]) => ({
|
||
fingerprint: `cluster-knoten-ohne-agent:${eintrag.cluster}:${name}`,
|
||
regel: "cluster-knoten-ohne-agent",
|
||
schwere: "WARNUNG" as AlertSchwere,
|
||
titel: "Cluster-Knoten ohne Agent",
|
||
beschreibung: `${name} gehört zum Cluster ${eintrag.cluster} (gemeldet von ${eintrag.melder.hostname}), meldet sich aber nicht – dort fehlt der Agent`,
|
||
hostId: eintrag.melder.id,
|
||
kundeId: eintrag.melder.kundeId,
|
||
laufzeitId: null,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const proxmoxRechnungFaellig: Regel = {
|
||
name: "proxmox-rechnung-faellig",
|
||
beschreibung: "Proxmox-Rechnung ist unbezahlt und wird fällig",
|
||
standardSchwellwerte: { tage: 7 },
|
||
pruefe(kontext) {
|
||
const tage = schwellwert(kontext, "proxmox-rechnung-faellig", "tage", 7);
|
||
|
||
return kontext.laufzeiten.flatMap((laufzeit) => {
|
||
if (laufzeit.einkaufBezahlt !== false || !laufzeit.einkaufFaelligAm) return [];
|
||
const rest = tageBis(laufzeit.einkaufFaelligAm, kontext.jetzt);
|
||
if (rest > tage) return [];
|
||
|
||
return [
|
||
{
|
||
fingerprint: `proxmox-rechnung-faellig:${laufzeit.id}`,
|
||
regel: "proxmox-rechnung-faellig",
|
||
schwere: (rest < 0 ? "GEFAHR" : "WARNUNG") as AlertSchwere,
|
||
titel: rest < 0 ? "Proxmox-Rechnung überfällig" : "Proxmox-Rechnung wird fällig",
|
||
beschreibung: `${laufzeit.einkaufNummer ?? "ohne Nummer"} · ${formatEuro(
|
||
laufzeit.einkaufBetrag,
|
||
)} netto · fällig am ${formatDatum(laufzeit.einkaufFaelligAm)} · ${laufzeit.hostname}`,
|
||
hostId: laufzeit.hostId,
|
||
kundeId: laufzeit.kundeId,
|
||
laufzeitId: laufzeit.id,
|
||
},
|
||
];
|
||
});
|
||
},
|
||
};
|
||
|
||
const kundenrechnungFehlt: Regel = {
|
||
name: "kundenrechnung-fehlt",
|
||
beschreibung: "Einkauf ist erfasst, die Kundenrechnung fehlt noch",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
return kontext.laufzeiten
|
||
.filter(
|
||
(laufzeit) =>
|
||
laufzeit.einkaufNummer !== null && !laufzeit.verkaufErstellt && !laufzeit.kundeEigenbedarf,
|
||
)
|
||
.filter((laufzeit) => laufzeit.kundeId !== null)
|
||
.map((laufzeit) => ({
|
||
fingerprint: `kundenrechnung-fehlt:${laufzeit.id}`,
|
||
regel: "kundenrechnung-fehlt",
|
||
schwere: "WARNUNG" as AlertSchwere,
|
||
titel: "Kundenrechnung noch nicht erstellt",
|
||
beschreibung: `${laufzeit.hostname} · ${kundenHinweis(laufzeit.kundeName)} · Laufzeit ab ${formatDatum(
|
||
laufzeit.start,
|
||
)} · Einkauf ${laufzeit.einkaufNummer}`,
|
||
hostId: laufzeit.hostId,
|
||
kundeId: laufzeit.kundeId,
|
||
laufzeitId: laufzeit.id,
|
||
}));
|
||
},
|
||
};
|
||
|
||
const kundenrechnungUnbezahlt: Regel = {
|
||
name: "kundenrechnung-unbezahlt",
|
||
beschreibung: "Kundenrechnung ist erstellt, aber noch nicht bezahlt",
|
||
standardSchwellwerte: { tage: 30 },
|
||
pruefe(kontext) {
|
||
const tage = schwellwert(kontext, "kundenrechnung-unbezahlt", "tage", 30);
|
||
|
||
return kontext.laufzeiten.flatMap((laufzeit) => {
|
||
if (laufzeit.kundeEigenbedarf) return [];
|
||
if (!laufzeit.verkaufErstellt || laufzeit.verkaufBezahlt || !laufzeit.verkaufDatum) return [];
|
||
const offenSeit = -tageBis(laufzeit.verkaufDatum, kontext.jetzt);
|
||
if (offenSeit < tage) return [];
|
||
|
||
return [
|
||
{
|
||
fingerprint: `kundenrechnung-unbezahlt:${laufzeit.id}`,
|
||
regel: "kundenrechnung-unbezahlt",
|
||
schwere: "WARNUNG" as AlertSchwere,
|
||
titel: `Kundenrechnung seit ${offenSeit} Tagen offen`,
|
||
beschreibung: `${laufzeit.verkaufNummer ?? "ohne Nummer"} · ${kundenHinweis(
|
||
laufzeit.kundeName,
|
||
)} · ${formatEuro(laufzeit.verkaufBetrag)} netto`,
|
||
hostId: laufzeit.hostId,
|
||
kundeId: laufzeit.kundeId,
|
||
laufzeitId: laufzeit.id,
|
||
},
|
||
];
|
||
});
|
||
},
|
||
};
|
||
|
||
/**
|
||
* Zwei Hosts desselben Kunden mit demselben Namen (#041).
|
||
*
|
||
* Das ist entweder gewollt – zwei Maschinen in getrennten Netzen heißen eben gleich – oder ein
|
||
* Doppeleintrag: Hat eine Maschine ihre Kennung aus `/etc/machine-id` verloren (Neuinstallation,
|
||
* geklonter Container), registriert sie sich als neuer Host, und der alte Eintrag bleibt stehen.
|
||
* Welcher Fall vorliegt, weiß nur der Betreiber – deshalb ein Hinweis mit den IP-Adressen zum
|
||
* Unterscheiden und nicht mehr.
|
||
*/
|
||
const hostnameDoppelt: Regel = {
|
||
name: "hostname-doppelt",
|
||
beschreibung: "Mehrere Hosts desselben Kunden tragen denselben Namen",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
const gruppen = new Map<string, HostDaten[]>();
|
||
for (const host of kontext.hosts) {
|
||
// Ohne Kunde ist der Vergleich wenig wert: Gleiche Namen sind dort der Normalfall.
|
||
if (!host.kundeId) continue;
|
||
const schluessel = `${host.kundeId}:${host.hostname.toLowerCase()}`;
|
||
gruppen.set(schluessel, [...(gruppen.get(schluessel) ?? []), host]);
|
||
}
|
||
|
||
return [...gruppen.values()]
|
||
.filter((gruppe) => gruppe.length > 1)
|
||
.map((gruppe) => {
|
||
const beschreibungen = gruppe.map(
|
||
(host) => `${host.ips.join(", ") || "keine IP gemeldet"}`,
|
||
);
|
||
|
||
return {
|
||
// Der Fingerabdruck hängt an Kunde und Name, nicht an den einzelnen Hosts – sonst gäbe
|
||
// es für jede Maschine eine eigene Warnung über denselben Sachverhalt.
|
||
fingerprint: `hostname-doppelt:${gruppe[0].kundeId}:${gruppe[0].hostname.toLowerCase()}`,
|
||
regel: "hostname-doppelt",
|
||
schwere: "INFO" as AlertSchwere,
|
||
titel: `${gruppe.length} Hosts heißen „${gruppe[0].hostname}“`,
|
||
beschreibung: `${kundenHinweis(gruppe[0].kundeName)} · ${beschreibungen.join(" | ")} · Entweder getrennte Maschinen – dann helfen Schlagworte – oder ein Doppeleintrag nach Neuinstallation; den alten Host dann stilllegen`,
|
||
hostId: gruppe[0].id,
|
||
kundeId: gruppe[0].kundeId,
|
||
laufzeitId: null,
|
||
};
|
||
});
|
||
},
|
||
};
|
||
|
||
/**
|
||
* Der übliche Ablauf: Erst kommt die unbezahlte Rechnung von Proxmox, dann stellt man dem Kunden
|
||
* seine Rechnung, und **nachdem der Kunde gezahlt hat**, zahlt man selbst bei Proxmox. Hat der Kunde
|
||
* bezahlt und die Einkaufsrechnung ist noch offen, liegt das Geld da und die Rechnung auch – das ist
|
||
* der Moment zum Zahlen, unabhängig vom Fälligkeitsdatum (#037).
|
||
*/
|
||
const kundeBezahltEinkaufOffen: Regel = {
|
||
name: "kunde-bezahlt-einkauf-offen",
|
||
beschreibung: "Der Kunde hat bezahlt, die Proxmox-Rechnung ist noch offen",
|
||
standardSchwellwerte: {},
|
||
pruefe(kontext) {
|
||
return kontext.laufzeiten.flatMap((laufzeit) => {
|
||
// Beim Eigenbedarf gibt es keine Kundenzahlung, auf die man warten würde.
|
||
if (laufzeit.kundeEigenbedarf) return [];
|
||
if (!laufzeit.verkaufBezahlt || laufzeit.einkaufBezahlt !== false) return [];
|
||
|
||
return [
|
||
{
|
||
fingerprint: `kunde-bezahlt-einkauf-offen:${laufzeit.id}`,
|
||
regel: "kunde-bezahlt-einkauf-offen",
|
||
schwere: "INFO" as AlertSchwere,
|
||
titel: "Kunde hat bezahlt – Proxmox-Rechnung noch offen",
|
||
beschreibung: `${laufzeit.hostname} · ${kundenHinweis(laufzeit.kundeName)} · Einkauf ${
|
||
laufzeit.einkaufNummer ?? "ohne Nummer"
|
||
} über ${formatEuro(laufzeit.einkaufBetrag)} netto ist noch nicht bezahlt`,
|
||
hostId: laufzeit.hostId,
|
||
kundeId: laufzeit.kundeId,
|
||
laufzeitId: laufzeit.id,
|
||
},
|
||
];
|
||
});
|
||
},
|
||
};
|
||
|
||
export const REGELN: Regel[] = [
|
||
subscriptionLaeuftAb,
|
||
statusNichtAktiv,
|
||
socketsAbweichung,
|
||
keineMeldung,
|
||
serverIdGeaendert,
|
||
keyMehrfach,
|
||
hostOhneKunde,
|
||
clusterKnotenOhneAgent,
|
||
proxmoxRechnungFaellig,
|
||
kundenrechnungFehlt,
|
||
kundenrechnungUnbezahlt,
|
||
kundeBezahltEinkaufOffen,
|
||
hostnameDoppelt,
|
||
];
|
||
|
||
/** Wendet alle aktiven Regeln an. */
|
||
export function alleRegelnPruefen(kontext: RegelKontext): AlertKandidat[] {
|
||
return REGELN.filter((regel) => kontext.einstellungen.get(regel.name)?.aktiv !== false).flatMap((regel) =>
|
||
regel.pruefe(kontext),
|
||
);
|
||
}
|