feat(kunden): Kundenverwaltung, Hostzuweisung und Token-Verwaltung (#006)

Kunden und Standorte pflegen, nicht zugeordnete Hosts in einem Schritt zuweisen, Enrollment- und Host-Tokens verwalten, Audit-Log. Dashboard, Kundenseiten und globale Suche laufen jetzt auf der Datenbank. 45 Tests. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-17 21:02:44 +02:00
parent f591b45aac
commit f9a5ad2daa
40 changed files with 2060 additions and 415 deletions
@@ -0,0 +1,106 @@
+import { prisma } from "@/lib/db";
+import { meldungsGrenze } from "./hosts";
+
+/**
+ * Hosts nach Ablaufdatum mit der Laufzeit, die zu diesem Ablauf gehört.
+ * Gezeigt wird bewusst die Verlängerung (die Laufzeit, die am `nextduedate` beginnt),
+ * denn deren Rechnungen sind offen – nicht die der laufenden Periode.
+ */
+export async function hostsNachAblauf(jetzt: Date = new Date()) {
+  const hosts = await prisma.host.findMany({
+    where: { subNextduedate: { not: null } },
+    orderBy: { subNextduedate: "asc" },
+    include: {
+      kunde: { select: { id: true, name: true } },
+      laufzeiten: {
+        where: { status: "BESTAETIGT" },
+        orderBy: { start: "desc" },
+        include: {
+          proxmoxPosition: { include: { rechnung: { select: { nummer: true, bezahlt: true } } } },
+          kundenPosition: { include: { rechnung: { select: { erstellt: true, bezahlt: true } } } },
+        },
+      },
+    },
+  });
+
+  const grenze = meldungsGrenze(jetzt);
+
+  return hosts.map((host) => {
+    const ablauf = host.subNextduedate;
+    const verlaengerung = host.laufzeiten.find(
+      (laufzeit) => ablauf && laufzeit.start.getTime() === ablauf.getTime(),
+    );
+    const laufend = host.laufzeiten[0];
+    const laufzeit = verlaengerung ?? laufend;
+
+    return {
+      id: host.id,
+      hostname: host.hostname,
+      kunde: host.kunde,
+      subKey: host.subKey,
+      nextduedate: ablauf,
+      meldetNicht: !host.letzterReportAm || host.letzterReportAm < grenze,
+      einkaufBezahlt: laufzeit?.proxmoxPosition ? laufzeit.proxmoxPosition.rechnung.bezahlt : null,
+      verkaufErstellt: laufzeit?.kundenPosition?.rechnung.erstellt ?? false,
+      verkaufBezahlt: laufzeit?.kundenPosition?.rechnung.bezahlt ?? false,
+    };
+  });
+}
+
+/** Offene Rechnungspunkte als Aufgabenliste fürs Dashboard. */
+export async function offeneAufgaben() {
+  const laufzeiten = await prisma.laufzeit.findMany({
+    where: {
+      status: "BESTAETIGT",
+      OR: [
+        { proxmoxPosition: { rechnung: { bezahlt: false } } },
+        { kundenPosition: null },
+        { kundenPosition: { rechnung: { erstellt: false } } },
+      ],
+    },
+    orderBy: { start: "asc" },
+    include: {
+      host: { select: { id: true, hostname: true, kunde: { select: { name: true } } } },
+      proxmoxPosition: { include: { rechnung: true } },
+      kundenPosition: { include: { rechnung: true } },
+    },
+  });
+
+  const aufgaben = [];
+  for (const laufzeit of laufzeiten) {
+    const basis = `${laufzeit.host.hostname} · ${laufzeit.host.kunde?.name ?? "Nicht zugeordnet"}`;
+    const einkauf = laufzeit.proxmoxPosition?.rechnung;
+
+    if (einkauf && !einkauf.bezahlt) {
+      aufgaben.push({
+        id: `${laufzeit.id}-einkauf`,
+        titel: `Proxmox-Rechnung ${einkauf.nummer} bezahlen`,
+        detail: basis,
+        betrag: Number(laufzeit.proxmoxPosition?.nettoBetrag ?? 0),
+        faelligAm: einkauf.faelligAm,
+        dringlichkeit: "gefahr" as const,
+        badgeText: "Einkauf",
+        href: `/hosts/${laufzeit.hostId}`,
+        start: laufzeit.start,
+        ende: laufzeit.ende,
+      });
+    }
+
+    if (einkauf && !laufzeit.kundenPosition?.rechnung.erstellt) {
+      aufgaben.push({
+        id: `${laufzeit.id}-verkauf`,
+        titel: "Kundenrechnung erstellen",
+        detail: basis,
+        betrag: null,
+        faelligAm: null,
+        dringlichkeit: "warnung" as const,
+        badgeText: "Verkauf",
+        href: "/rechnungen",
+        start: laufzeit.start,
+        ende: laufzeit.ende,
+      });
+    }
+  }
+
+  return aufgaben;
+}
@@ -0,0 +1,136 @@
+import { prisma } from "@/lib/db";
+
+/** Frist, nach der ein Host als „meldet sich nicht“ gilt (konfigurierbar ab #011). */
+export const MELDUNG_FRIST_STUNDEN = 48;
+
+export function meldungsGrenze(jetzt: Date = new Date()): Date {
+  return new Date(jetzt.getTime() - MELDUNG_FRIST_STUNDEN * 3_600_000);
+}
+
+export async function hostsOhneKunde() {
+  return prisma.host.findMany({
+    where: { kundeId: null },
+    orderBy: { erstmalsGesehenAm: "desc" },
+  });
+}
+
+export async function hostAnzahl() {
+  return prisma.host.count();
+}
+
+/** Kennzahlen für Dashboard-Kacheln und Sidebar-Badges. */
+export async function kennzahlen(jetzt: Date = new Date()) {
+  const in30Tagen = new Date(jetzt.getTime() + 30 * 86_400_000);
+
+  const [gesamt, aktiv, ohneKunde, baldAblaufend, ohneMeldung, offeneAlerts] = await Promise.all([
+    prisma.host.count(),
+    prisma.host.count({ where: { subStatus: "ACTIVE" } }),
+    prisma.host.count({ where: { kundeId: null } }),
+    prisma.host.count({ where: { subNextduedate: { gte: jetzt, lte: in30Tagen } } }),
+    prisma.host.count({
+      where: { OR: [{ letzterReportAm: null }, { letzterReportAm: { lt: meldungsGrenze(jetzt) } }] },
+    }),
+    prisma.alert.count({ where: { erledigtAm: null } }),
+  ]);
+
+  const [offeneEinkaufsrechnungen, fehlendeKundenrechnungen] = await Promise.all([
+    prisma.laufzeit.count({
+      where: { status: "BESTAETIGT", proxmoxPosition: { rechnung: { bezahlt: false } } },
+    }),
+    prisma.laufzeit.count({
+      where: {
+        status: "BESTAETIGT",
+        proxmoxPosition: { isNot: null },
+        OR: [{ kundenPosition: null }, { kundenPosition: { rechnung: { erstellt: false } } }],
+      },
+    }),
+  ]);
+
+  return {
+    hostsGesamt: gesamt,
+    aktivLizenziert: aktiv,
+    ohneSubscription: gesamt - aktiv,
+    ohneKunde,
+    baldAblaufend,
+    ohneMeldung,
+    offeneAlerts,
+    offeneEinkaufsrechnungen,
+    fehlendeKundenrechnungen,
+    offeneRechnungspunkte: offeneEinkaufsrechnungen + fehlendeKundenrechnungen,
+  };
+}
+
+export async function offeneAlerts(anzahl = 20) {
+  return prisma.alert.findMany({
+    where: { erledigtAm: null },
+    orderBy: [{ schwere: "asc" }, { geoeffnetAm: "desc" }],
+    take: anzahl,
+  });
+}
+
+/** Einträge für die globale Suche (Strg+K). */
+export async function suchIndex() {
+  const [hosts, kunden, proxmoxRechnungen, kundenrechnungen] = await Promise.all([
+    prisma.host.findMany({
+      select: {
+        id: true,
+        hostname: true,
+        fqdn: true,
+        serverId: true,
+        subKey: true,
+        ips: true,
+        produkt: true,
+        kunde: { select: { name: true } },
+      },
+    }),
+    prisma.kunde.findMany({
+      select: { id: true, name: true, kundennummer: true, ansprechpartner: true, email: true },
+    }),
+    prisma.proxmoxRechnung.findMany({
+      select: { id: true, nummer: true, positionen: { select: { laufzeit: { select: { hostId: true } } } } },
+    }),
+    prisma.kundenrechnung.findMany({
+      where: { nummer: { not: null } },
+      select: { id: true, nummer: true, kunde: { select: { id: true, name: true } } },
+    }),
+  ]);
+
+  const eintraege = [
+    ...hosts.map((host) => ({
+      typ: "Host" as const,
+      titel: host.hostname,
+      untertitel: `${host.produkt} · ${host.kunde?.name ?? "Nicht zugeordnet"}${
+        host.subKey ? ` · ${host.subKey}` : ""
+      }`,
+      href: `/hosts/${host.id}`,
+      begriffe: [host.hostname, host.fqdn, host.serverId, host.subKey, ...host.ips]
+        .filter((w): w is string => Boolean(w))
+        .map((w) => w.toLowerCase()),
+    })),
+    ...kunden.map((kunde) => ({
+      typ: "Kunde" as const,
+      titel: kunde.name,
+      untertitel: `${kunde.kundennummer}${kunde.ansprechpartner ? ` · ${kunde.ansprechpartner}` : ""}`,
+      href: `/kunden/${kunde.id}`,
+      begriffe: [kunde.name, kunde.kundennummer, kunde.ansprechpartner, kunde.email]
+        .filter((w): w is string => Boolean(w))
+        .map((w) => w.toLowerCase()),
+    })),
+    ...proxmoxRechnungen.map((rechnung) => ({
+      typ: "Rechnung" as const,
+      titel: rechnung.nummer,
+      untertitel: `Proxmox-Rechnung · ${rechnung.positionen.length} Position(en)`,
+      href: `/rechnungen?q=${encodeURIComponent(rechnung.nummer)}`,
+      begriffe: [rechnung.nummer.toLowerCase()],
+    })),
+    ...kundenrechnungen.map((rechnung) => ({
+      typ: "Rechnung" as const,
+      titel: rechnung.nummer ?? "",
+      untertitel: `Kundenrechnung · ${rechnung.kunde.name}`,
+      href: `/kunden/${rechnung.kunde.id}`,
+      begriffe: [(rechnung.nummer ?? "").toLowerCase()],
+    })),
+  ];
+
+  return eintraege;
+}
@@ -0,0 +1,138 @@
+import { prisma } from "@/lib/db";
+
+/** Abfragen rund um Kunden. Beträge kommen als Decimal aus der Datenbank und werden hier zu Zahlen. */
+
+export async function kundenListe() {
+  const kunden = await prisma.kunde.findMany({
+    orderBy: { name: "asc" },
+    include: {
+      standorte: true,
+      hosts: {
+        select: { id: true, subStatus: true, subNextduedate: true },
+      },
+      _count: { select: { hosts: true } },
+    },
+  });
+
+  const offeneAlerts = await prisma.alert.groupBy({
+    by: ["kundeId"],
+    where: { erledigtAm: null, kundeId: { not: null } },
+    _count: { _all: true },
+  });
+
+  const alertsProKunde = new Map(offeneAlerts.map((e) => [e.kundeId, e._count._all]));
+
+  return kunden.map((kunde) => {
+    const ablaufDaten = kunde.hosts
+      .map((h) => h.subNextduedate)
+      .filter((d): d is Date => d !== null)
+      .sort((a, b) => a.getTime() - b.getTime());
+
+    return {
+      id: kunde.id,
+      name: kunde.name,
+      kundennummer: kunde.kundennummer,
+      ansprechpartner: kunde.ansprechpartner,
+      hosts: kunde._count.hosts,
+      aktiv: kunde.hosts.filter((h) => h.subStatus === "ACTIVE").length,
+      naechsterAblauf: ablaufDaten[0] ?? null,
+      offeneAlerts: alertsProKunde.get(kunde.id) ?? 0,
+    };
+  });
+}
+
+export async function kundeMitDetails(id: string) {
+  return prisma.kunde.findUnique({
+    where: { id },
+    include: {
+      standorte: { orderBy: { name: "asc" } },
+      hosts: { orderBy: { hostname: "asc" } },
+      alerts: { where: { erledigtAm: null }, orderBy: { geoeffnetAm: "desc" } },
+    },
+  });
+}
+
+/** Laufzeiten eines Kunden samt Rechnungsangaben, aufbereitet für Tabellen und Summen. */
+export async function laufzeitenVonKunde(kundeId: string) {
+  const laufzeiten = await prisma.laufzeit.findMany({
+    where: { host: { kundeId } },
+    orderBy: { start: "desc" },
+    include: {
+      host: { select: { id: true, hostname: true } },
+      proxmoxPosition: { include: { rechnung: true } },
+      kundenPosition: { include: { rechnung: true } },
+    },
+  });
+
+  return laufzeiten.map((laufzeit) => ({
+    id: laufzeit.id,
+    hostId: laufzeit.hostId,
+    hostname: laufzeit.host.hostname,
+    key: laufzeit.key,
+    start: laufzeit.start,
+    ende: laufzeit.ende,
+    vorschlag: laufzeit.status === "VORSCHLAG",
+    einkauf: laufzeit.proxmoxPosition
+      ? {
+          nummer: laufzeit.proxmoxPosition.rechnung.nummer,
+          nettoBetrag: Number(laufzeit.proxmoxPosition.nettoBetrag),
+          bezahlt: laufzeit.proxmoxPosition.rechnung.bezahlt,
+          faelligAm: laufzeit.proxmoxPosition.rechnung.faelligAm,
+        }
+      : null,
+    verkauf: laufzeit.kundenPosition
+      ? {
+          nummer: laufzeit.kundenPosition.rechnung.nummer,
+          nettoBetrag: Number(laufzeit.kundenPosition.nettoBetrag),
+          erstellt: laufzeit.kundenPosition.rechnung.erstellt,
+          bezahlt: laufzeit.kundenPosition.rechnung.bezahlt,
+        }
+      : null,
+  }));
+}
+
+export type KundenLaufzeit = Awaited<ReturnType<typeof laufzeitenVonKunde>>[number];
+
+export function summen(laufzeiten: KundenLaufzeit[]) {
+  const einkauf = laufzeiten.reduce((s, l) => s + (l.einkauf?.nettoBetrag ?? 0), 0);
+  const verkauf = laufzeiten.reduce((s, l) => s + (l.verkauf?.nettoBetrag ?? 0), 0);
+  return { einkauf, verkauf, marge: verkauf - einkauf };
+}
+
+export function summenProJahr(laufzeiten: KundenLaufzeit[]) {
+  const proJahr = new Map<string, { einkauf: number; verkauf: number }>();
+  for (const laufzeit of laufzeiten) {
+    const jahr = String(laufzeit.start.getUTCFullYear());
+    const eintrag = proJahr.get(jahr) ?? { einkauf: 0, verkauf: 0 };
+    eintrag.einkauf += laufzeit.einkauf?.nettoBetrag ?? 0;
+    eintrag.verkauf += laufzeit.verkauf?.nettoBetrag ?? 0;
+    proJahr.set(jahr, eintrag);
+  }
+  return [...proJahr.entries()]
+    .sort((a, b) => b[0].localeCompare(a[0]))
+    .map(([jahr, werte]) => ({ jahr, ...werte, marge: werte.verkauf - werte.einkauf }));
+}
+
+/** Offene Rechnungspunkte je Kunde: unbezahlter Einkauf bzw. fehlende Kundenrechnung. */
+export async function offeneRechnungspunkteProKunde() {
+  const laufzeiten = await prisma.laufzeit.findMany({
+    where: { status: "BESTAETIGT", host: { kundeId: { not: null } } },
+    select: {
+      host: { select: { kundeId: true } },
+      proxmoxPosition: { select: { rechnung: { select: { bezahlt: true } } } },
+      kundenPosition: { select: { rechnung: { select: { erstellt: true } } } },
+    },
+  });
+
+  const proKunde = new Map<string, { offen: number; gesamt: number }>();
+  for (const laufzeit of laufzeiten) {
+    const kundeId = laufzeit.host.kundeId;
+    if (!kundeId) continue;
+    const eintrag = proKunde.get(kundeId) ?? { offen: 0, gesamt: 0 };
+    eintrag.gesamt += 2;
+    if (!laufzeit.proxmoxPosition?.rechnung.bezahlt) eintrag.offen += 1;
+    if (!laufzeit.kundenPosition?.rechnung.erstellt) eintrag.offen += 1;
+    proKunde.set(kundeId, eintrag);
+  }
+  return proKunde;
+}