feat(alerts): zehn Warnregeln mit Worker, Liste und Einstellungen (#011)

Regeln als reine Funktionen, Abgleich oeffnet und schliesst Warnungen anhand eines Fingerabdrucks. Worker wertet stuendlich aus, zusaetzlich nach jedem Report. 123 Tests. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-17 22:25:33 +02:00
parent 5018589f08
commit 8a299f6c5e
25 changed files with 1638 additions and 21 deletions
@@ -0,0 +1,391 @@
+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;
+  kundeId: string | null;
+  kundeName: string | null;
+  subKey: string | null;
+  subStatus: SubscriptionStatus;
+  subNextduedate: Date | null;
+  subLizenzierteSockets: number | null;
+  sockets: number | null;
+  letzterReportAm: Date | null;
+  serverIds: { serverId: string; ersteMeldung: Date; letzteMeldung: Date }[];
+}
+
+export interface LaufzeitDaten {
+  id: string;
+  hostId: string;
+  hostname: string;
+  kundeId: string | null;
+  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 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)
+      .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.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,
+        },
+      ];
+    });
+  },
+};
+
+export const REGELN: Regel[] = [
+  subscriptionLaeuftAb,
+  statusNichtAktiv,
+  socketsAbweichung,
+  keineMeldung,
+  serverIdGeaendert,
+  keyMehrfach,
+  hostOhneKunde,
+  proxmoxRechnungFaellig,
+  kundenrechnungFehlt,
+  kundenrechnungUnbezahlt,
+];
+
+/** 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),
+  );
+}