feat(rechnungen): Laufzeiten bestaetigen, Rechnungen erfassen und Status setzen (#008)

Rechnungen mit Positionen: gleiche Nummer ergibt eine Sammelrechnung ueber mehrere
Laufzeiten. PDF-Upload mit Inhaltspruefung und Ablage unter der Pruefsumme,
Haekchen direkt in der Tabelle, Filter nach Status, Kunde und Jahr. 78 Tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/server/actions/rechnungen.ts

@@ -0,0 +1,168 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { anhangSpeichern, UploadFehler } from "@/lib/uploads";
+import {
+  einkaufBezahltSetzen,
+  kundenrechnungErfassen,
+  laufzeitAnlegen,
+  laufzeitBestaetigen,
+  laufzeitVerwerfen,
+  proxmoxRechnungErfassen,
+  RechnungsFehler,
+  verkaufBezahltSetzen,
+  verkaufErstelltSetzen,
+} from "@/server/services/rechnungen";
+import type { AktionsErgebnis } from "./kunden";
+
+function datum(wert: FormDataEntryValue | null): Date | null {
+  const text = wert?.toString().trim();
+  return text ? new Date(`${text}T00:00:00Z`) : null;
+}
+
+function betrag(wert: FormDataEntryValue | null): number | null {
+  const text = wert?.toString().trim().replace(",", ".");
+  if (!text) return null;
+  const zahl = Number(text);
+  return Number.isFinite(zahl) ? zahl : null;
+}
+
+function seitenNeuLaden(hostId?: string | null) {
+  revalidatePath("/rechnungen");
+  revalidatePath("/");
+  revalidatePath("/kunden");
+  if (hostId) revalidatePath(`/hosts/${hostId}`);
+}
+
+/** Wandelt Fehler aus der Fachlogik in eine Rückmeldung für das Formular. */
+async function ausfuehren(arbeit: () => Promise<string | void>): Promise<AktionsErgebnis> {
+  try {
+    const meldung = await arbeit();
+    return { erfolg: meldung || "Gespeichert." };
+  } catch (fehler) {
+    if (fehler instanceof RechnungsFehler || fehler instanceof UploadFehler) {
+      return { fehler: fehler.message };
+    }
+    throw fehler;
+  }
+}
+
+export async function laufzeitBestaetigenAktion(formular: FormData) {
+  const id = formular.get("laufzeitId")?.toString();
+  if (!id) return;
+  await laufzeitBestaetigen(id);
+  seitenNeuLaden(formular.get("hostId")?.toString());
+}
+
+export async function laufzeitVerwerfenAktion(formular: FormData) {
+  const id = formular.get("laufzeitId")?.toString();
+  if (!id) return;
+  await laufzeitVerwerfen(id);
+  seitenNeuLaden(formular.get("hostId")?.toString());
+}
+
+/** Häkchen aus der Rechnungstabelle. */
+export async function statusUmschalten(formular: FormData): Promise<void> {
+  const laufzeitId = formular.get("laufzeitId")?.toString();
+  const feld = formular.get("feld")?.toString();
+  const wert = formular.get("wert")?.toString() === "true";
+  if (!laufzeitId || !feld) return;
+
+  try {
+    if (feld === "einkaufBezahlt") await einkaufBezahltSetzen(laufzeitId, wert);
+    if (feld === "verkaufErstellt") await verkaufErstelltSetzen(laufzeitId, wert);
+    if (feld === "verkaufBezahlt") await verkaufBezahltSetzen(laufzeitId, wert);
+  } catch (fehler) {
+    if (!(fehler instanceof RechnungsFehler)) throw fehler;
+    // Fehlt die Rechnung, bleibt der Status unverändert; die Tabelle zeigt weiterhin „Fehlt“.
+  }
+
+  seitenNeuLaden(formular.get("hostId")?.toString());
+}
+
+export async function proxmoxRechnungSpeichern(
+  _vorher: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  const laufzeitId = formular.get("laufzeitId")?.toString();
+  if (!laufzeitId) return { fehler: "Laufzeit fehlt." };
+
+  return ausfuehren(async () => {
+    const pdf = formular.get("pdf");
+    const anhangId = pdf instanceof File && pdf.size > 0 ? await anhangSpeichern(pdf) : null;
+    const rechnungsdatum = datum(formular.get("datum"));
+
+    if (!rechnungsdatum) throw new RechnungsFehler("Bitte ein Rechnungsdatum angeben.");
+    const netto = betrag(formular.get("nettoBetrag"));
+    if (netto === null) throw new RechnungsFehler("Bitte einen Nettobetrag angeben.");
+
+    const ergebnis = await proxmoxRechnungErfassen(laufzeitId, {
+      nummer: formular.get("nummer")?.toString() ?? "",
+      datum: rechnungsdatum,
+      faelligAm: datum(formular.get("faelligAm")),
+      nettoBetrag: netto,
+      ustSatz: betrag(formular.get("ustSatz")) ?? 19,
+      rabatt: betrag(formular.get("rabatt")),
+      zahlungsart: formular.get("zahlungsart")?.toString().trim() || null,
+      bezahlt: formular.get("bezahlt") === "on",
+      bezahltAm: datum(formular.get("bezahltAm")),
+      anhangId,
+      notizen: formular.get("notizen")?.toString().trim() || null,
+    });
+
+    seitenNeuLaden(formular.get("hostId")?.toString());
+    return ergebnis.sammelrechnung
+      ? "Gespeichert – die Laufzeit hängt jetzt als weitere Position an dieser Sammelrechnung."
+      : "Proxmox-Rechnung gespeichert.";
+  });
+}
+
+export async function kundenrechnungSpeichern(
+  _vorher: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  const laufzeitId = formular.get("laufzeitId")?.toString();
+  if (!laufzeitId) return { fehler: "Laufzeit fehlt." };
+
+  return ausfuehren(async () => {
+    const pdf = formular.get("pdf");
+    const anhangId = pdf instanceof File && pdf.size > 0 ? await anhangSpeichern(pdf) : null;
+
+    const ergebnis = await kundenrechnungErfassen(laufzeitId, {
+      erstellt: formular.get("erstellt") === "on",
+      nummer: formular.get("nummer")?.toString().trim() || null,
+      datum: datum(formular.get("datum")),
+      nettoBetrag: betrag(formular.get("nettoBetrag")),
+      ustSatz: betrag(formular.get("ustSatz")) ?? 19,
+      bezahlt: formular.get("bezahlt") === "on",
+      bezahltAm: datum(formular.get("bezahltAm")),
+      anhangId,
+      notizen: formular.get("notizen")?.toString().trim() || null,
+    });
+
+    seitenNeuLaden(formular.get("hostId")?.toString());
+    return ergebnis.sammelrechnung
+      ? "Gespeichert – die Laufzeit hängt jetzt als weitere Position an dieser Sammelrechnung."
+      : "Kundenrechnung gespeichert.";
+  });
+}
+
+export async function laufzeitAnlegenAktion(
+  _vorher: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  const hostId = formular.get("hostId")?.toString();
+  const key = formular.get("key")?.toString().trim();
+  const start = datum(formular.get("start"));
+  const ende = datum(formular.get("ende"));
+
+  if (!hostId || !key || !start || !ende) {
+    return { fehler: "Bitte Host, Key, Beginn und Ende angeben." };
+  }
+
+  return ausfuehren(async () => {
+    await laufzeitAnlegen({ hostId, key, start, ende, notizen: null });
+    seitenNeuLaden(hostId);
+    return "Laufzeit angelegt.";
+  });
+}

src/server/queries/dashboard.ts

@@ -66,7 +66,19 @@ export async function offeneAufgaben() {
     },
   });
 
-  const aufgaben = [];
+  const aufgaben: {
+    id: string;
+    titel: string;
+    detail: string;
+    betrag: number | null;
+    faelligAm: Date | null;
+    dringlichkeit: "gefahr" | "warnung";
+    badgeText: string;
+    href: string;
+    start: Date;
+    ende: Date;
+    aktion: { laufzeitId: string; hostId: string; feld: "einkaufBezahlt" | "verkaufErstellt" };
+  }[] = [];
   for (const laufzeit of laufzeiten) {
     const basis = `${laufzeit.host.hostname} · ${laufzeit.host.kunde?.name ?? "Nicht zugeordnet"}`;
     const einkauf = laufzeit.proxmoxPosition?.rechnung;
@@ -80,9 +92,10 @@ export async function offeneAufgaben() {
         faelligAm: einkauf.faelligAm,
         dringlichkeit: "gefahr" as const,
         badgeText: "Einkauf",
-        href: `/hosts/${laufzeit.hostId}`,
+        href: `/rechnungen/${laufzeit.id}`,
         start: laufzeit.start,
         ende: laufzeit.ende,
+        aktion: { laufzeitId: laufzeit.id, hostId: laufzeit.hostId, feld: "einkaufBezahlt" as const },
       });
     }
 
@@ -95,9 +108,10 @@ export async function offeneAufgaben() {
         faelligAm: null,
         dringlichkeit: "warnung" as const,
         badgeText: "Verkauf",
-        href: "/rechnungen",
+        href: `/rechnungen/${laufzeit.id}`,
         start: laufzeit.start,
         ende: laufzeit.ende,
+        aktion: { laufzeitId: laufzeit.id, hostId: laufzeit.hostId, feld: "verkaufErstellt" as const },
       });
     }
   }

src/server/queries/rechnungen.ts

@@ -0,0 +1,152 @@
+import type { Prisma } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+
+export interface RechnungsFilter {
+  status?: "offen" | "erledigt" | "alle" | "vorschlaege";
+  kunde?: string;
+  jahr?: string;
+  q?: string;
+}
+
+function bedingung(filter: RechnungsFilter): Prisma.LaufzeitWhereInput {
+  const und: Prisma.LaufzeitWhereInput[] = [];
+
+  if (filter.status === "vorschlaege") {
+    und.push({ status: "VORSCHLAG" });
+  } else {
+    und.push({ status: "BESTAETIGT" });
+  }
+
+  if (filter.status === "offen") {
+    und.push({
+      OR: [
+        { proxmoxPosition: null },
+        { proxmoxPosition: { rechnung: { bezahlt: false } } },
+        { kundenPosition: null },
+        { kundenPosition: { rechnung: { erstellt: false } } },
+      ],
+    });
+  }
+
+  if (filter.status === "erledigt") {
+    und.push({ proxmoxPosition: { rechnung: { bezahlt: true } } });
+    und.push({ kundenPosition: { rechnung: { erstellt: true } } });
+  }
+
+  if (filter.kunde) und.push({ host: { kundeId: filter.kunde } });
+
+  if (filter.jahr) {
+    const jahr = Number(filter.jahr);
+    und.push({
+      start: { gte: new Date(Date.UTC(jahr, 0, 1)), lt: new Date(Date.UTC(jahr + 1, 0, 1)) },
+    });
+  }
+
+  if (filter.q?.trim()) {
+    const suche = filter.q.trim();
+    und.push({
+      OR: [
+        { key: { contains: suche, mode: "insensitive" } },
+        { host: { hostname: { contains: suche, mode: "insensitive" } } },
+        { proxmoxPosition: { rechnung: { nummer: { contains: suche, mode: "insensitive" } } } },
+        { kundenPosition: { rechnung: { nummer: { contains: suche, mode: "insensitive" } } } },
+      ],
+    });
+  }
+
+  return { AND: und };
+}
+
+export async function rechnungsListe(filter: RechnungsFilter) {
+  const laufzeiten = await prisma.laufzeit.findMany({
+    where: bedingung(filter),
+    orderBy: [{ start: "desc" }],
+    include: {
+      host: { select: { id: true, hostname: true, kunde: { select: { id: true, name: true } } } },
+      proxmoxPosition: { include: { rechnung: true } },
+      kundenPosition: { include: { rechnung: true } },
+    },
+  });
+
+  const zeilen = laufzeiten.map((laufzeit) => {
+    const einkauf = laufzeit.proxmoxPosition ? Number(laufzeit.proxmoxPosition.nettoBetrag) : null;
+    const verkauf = laufzeit.kundenPosition ? Number(laufzeit.kundenPosition.nettoBetrag) : null;
+
+    return {
+      id: laufzeit.id,
+      hostId: laufzeit.host.id,
+      hostname: laufzeit.host.hostname,
+      kunde: laufzeit.host.kunde,
+      key: laufzeit.key,
+      start: laufzeit.start,
+      ende: laufzeit.ende,
+      vorschlag: laufzeit.status === "VORSCHLAG",
+      einkaufNummer: laufzeit.proxmoxPosition?.rechnung.nummer ?? null,
+      einkaufBetrag: einkauf,
+      einkaufBezahlt: laufzeit.proxmoxPosition ? laufzeit.proxmoxPosition.rechnung.bezahlt : null,
+      einkaufFaelligAm: laufzeit.proxmoxPosition?.rechnung.faelligAm ?? null,
+      verkaufNummer: laufzeit.kundenPosition?.rechnung.nummer ?? null,
+      verkaufBetrag: verkauf,
+      verkaufErstellt: laufzeit.kundenPosition?.rechnung.erstellt ?? false,
+      verkaufBezahlt: laufzeit.kundenPosition?.rechnung.bezahlt ?? false,
+      marge: einkauf !== null && verkauf !== null ? verkauf - einkauf : null,
+    };
+  });
+
+  const summen = zeilen.reduce(
+    (summe, zeile) => ({
+      einkauf: summe.einkauf + (zeile.einkaufBetrag ?? 0),
+      verkauf: summe.verkauf + (zeile.verkaufBetrag ?? 0),
+    }),
+    { einkauf: 0, verkauf: 0 },
+  );
+
+  return {
+    zeilen,
+    summen: { ...summen, marge: summen.verkauf - summen.einkauf },
+  };
+}
+
+export type RechnungsZeile = Awaited<ReturnType<typeof rechnungsListe>>["zeilen"][number];
+
+/** Jahre, für die Laufzeiten vorliegen – für den Zeitraum-Filter. */
+export async function laufzeitJahre(): Promise<string[]> {
+  const laufzeiten = await prisma.laufzeit.findMany({ select: { start: true } });
+  return [...new Set(laufzeiten.map((l) => String(l.start.getUTCFullYear())))].sort((a, b) =>
+    b.localeCompare(a),
+  );
+}
+
+export async function laufzeitDetail(id: string) {
+  return prisma.laufzeit.findUnique({
+    where: { id },
+    include: {
+      host: {
+        select: {
+          id: true,
+          hostname: true,
+          produkt: true,
+          kunde: { select: { id: true, name: true } },
+        },
+      },
+      proxmoxPosition: {
+        include: {
+          rechnung: {
+            include: { anhang: true, positionen: { include: { laufzeit: { include: { host: true } } } } },
+          },
+        },
+      },
+      kundenPosition: {
+        include: {
+          rechnung: {
+            include: { anhang: true, positionen: { include: { laufzeit: { include: { host: true } } } } },
+          },
+        },
+      },
+    },
+  });
+}
+
+export async function anzahlVorschlaege() {
+  return prisma.laufzeit.count({ where: { status: "VORSCHLAG" } });
+}

src/server/services/rechnungen.ts

@@ -0,0 +1,312 @@
+import { prisma } from "@/lib/db";
+import { protokolliere } from "@/server/audit";
+
+export class RechnungsFehler extends Error {}
+
+export interface ProxmoxRechnungEingabe {
+  nummer: string;
+  datum: Date;
+  faelligAm: Date | null;
+  nettoBetrag: number;
+  ustSatz?: number;
+  rabatt?: number | null;
+  zahlungsart?: string | null;
+  bezahlt: boolean;
+  bezahltAm?: Date | null;
+  anhangId?: string | null;
+  notizen?: string | null;
+}
+
+export interface KundenrechnungEingabe {
+  erstellt: boolean;
+  nummer?: string | null;
+  datum?: Date | null;
+  nettoBetrag?: number | null;
+  ustSatz?: number;
+  bezahlt: boolean;
+  bezahltAm?: Date | null;
+  anhangId?: string | null;
+  notizen?: string | null;
+}
+
+/** Bestätigt einen vom Agent vorgeschlagenen Lizenzzeitraum. */
+export async function laufzeitBestaetigen(id: string) {
+  const laufzeit = await prisma.laufzeit.update({
+    where: { id },
+    data: { status: "BESTAETIGT" },
+  });
+  await protokolliere("laufzeit.bestaetigt", "Laufzeit", id, {
+    start: laufzeit.start,
+    ende: laufzeit.ende,
+  });
+  return laufzeit;
+}
+
+/** Verwirft einen Vorschlag; bereits bestätigte Laufzeiten bleiben unangetastet. */
+export async function laufzeitVerwerfen(id: string) {
+  const laufzeit = await prisma.laufzeit.findUnique({ where: { id } });
+  if (!laufzeit) throw new RechnungsFehler("Laufzeit nicht gefunden.");
+  if (laufzeit.status !== "VORSCHLAG") {
+    throw new RechnungsFehler("Nur Vorschläge können verworfen werden.");
+  }
+
+  await prisma.laufzeit.delete({ where: { id } });
+  await protokolliere("laufzeit.verworfen", "Laufzeit", id, { start: laufzeit.start });
+}
+
+/**
+ * Erfasst die Proxmox-Rechnung zu einer Laufzeit.
+ * Gibt es die Rechnungsnummer schon, wird eine weitere Position angehängt – so entsteht aus mehreren
+ * Laufzeiten eine Sammelrechnung, ohne dass die Nummer doppelt vergeben wird.
+ */
+export async function proxmoxRechnungErfassen(laufzeitId: string, eingabe: ProxmoxRechnungEingabe) {
+  const laufzeit = await prisma.laufzeit.findUnique({
+    where: { id: laufzeitId },
+    include: { proxmoxPosition: true, host: { select: { hostname: true } } },
+  });
+  if (!laufzeit) throw new RechnungsFehler("Laufzeit nicht gefunden.");
+  if (!eingabe.nummer.trim()) throw new RechnungsFehler("Bitte eine Rechnungsnummer angeben.");
+
+  const nummer = eingabe.nummer.trim();
+  const bezeichnung = `${laufzeit.key} · ${laufzeit.host.hostname} · ${laufzeit.start.toISOString().slice(0, 10)} bis ${laufzeit.ende.toISOString().slice(0, 10)}`;
+
+  return prisma.$transaction(async (tx) => {
+    const vorhanden = await tx.proxmoxRechnung.findUnique({ where: { nummer } });
+
+    const rechnung = vorhanden
+      ? await tx.proxmoxRechnung.update({
+          where: { id: vorhanden.id },
+          data: {
+            datum: eingabe.datum,
+            faelligAm: eingabe.faelligAm,
+            ustSatz: eingabe.ustSatz ?? 19,
+            rabatt: eingabe.rabatt ?? null,
+            zahlungsart: eingabe.zahlungsart ?? null,
+            bezahlt: eingabe.bezahlt,
+            bezahltAm: eingabe.bezahlt ? (eingabe.bezahltAm ?? new Date()) : null,
+            anhangId: eingabe.anhangId ?? vorhanden.anhangId,
+            notizen: eingabe.notizen ?? vorhanden.notizen,
+          },
+        })
+      : await tx.proxmoxRechnung.create({
+          data: {
+            nummer,
+            datum: eingabe.datum,
+            faelligAm: eingabe.faelligAm,
+            nettoBetrag: eingabe.nettoBetrag,
+            ustSatz: eingabe.ustSatz ?? 19,
+            rabatt: eingabe.rabatt ?? null,
+            zahlungsart: eingabe.zahlungsart ?? null,
+            bezahlt: eingabe.bezahlt,
+            bezahltAm: eingabe.bezahlt ? (eingabe.bezahltAm ?? new Date()) : null,
+            anhangId: eingabe.anhangId ?? null,
+            notizen: eingabe.notizen ?? null,
+          },
+        });
+
+    const position = laufzeit.proxmoxPosition
+      ? await tx.proxmoxRechnungPosition.update({
+          where: { id: laufzeit.proxmoxPosition.id },
+          data: { rechnungId: rechnung.id, bezeichnung, nettoBetrag: eingabe.nettoBetrag },
+        })
+      : await tx.proxmoxRechnungPosition.create({
+          data: { rechnungId: rechnung.id, bezeichnung, nettoBetrag: eingabe.nettoBetrag },
+        });
+
+    await tx.laufzeit.update({
+      where: { id: laufzeitId },
+      data: { proxmoxPositionId: position.id, status: "BESTAETIGT" },
+    });
+
+    // Der Rechnungsbetrag ist immer die Summe der Positionen.
+    const positionen = await tx.proxmoxRechnungPosition.findMany({ where: { rechnungId: rechnung.id } });
+    const summe = positionen.reduce((s, p) => s + Number(p.nettoBetrag), 0);
+    await tx.proxmoxRechnung.update({ where: { id: rechnung.id }, data: { nettoBetrag: summe } });
+
+    await protokolliere("proxmox_rechnung.erfasst", "ProxmoxRechnung", rechnung.id, {
+      nummer,
+      laufzeitId,
+      nettoBetrag: eingabe.nettoBetrag,
+      positionen: positionen.length,
+    });
+
+    return { rechnungId: rechnung.id, positionId: position.id, sammelrechnung: positionen.length > 1 };
+  });
+}
+
+/** Erfasst die Kundenrechnung zu einer Laufzeit; gleiche Nummer bedeutet auch hier Sammelrechnung. */
+export async function kundenrechnungErfassen(laufzeitId: string, eingabe: KundenrechnungEingabe) {
+  const laufzeit = await prisma.laufzeit.findUnique({
+    where: { id: laufzeitId },
+    include: { kundenPosition: true, host: { select: { hostname: true, kundeId: true } } },
+  });
+  if (!laufzeit) throw new RechnungsFehler("Laufzeit nicht gefunden.");
+  const kundeId = laufzeit.host.kundeId;
+  if (!kundeId) {
+    throw new RechnungsFehler("Der Host ist keinem Kunden zugewiesen – ohne Kunde keine Kundenrechnung.");
+  }
+
+  const nummer = eingabe.nummer?.trim() || null;
+  const bezeichnung = `${laufzeit.key} · ${laufzeit.host.hostname} · ${laufzeit.start.toISOString().slice(0, 10)} bis ${laufzeit.ende.toISOString().slice(0, 10)}`;
+  const betrag = eingabe.nettoBetrag ?? 0;
+
+  return prisma.$transaction(async (tx) => {
+    const vorhanden = nummer ? await tx.kundenrechnung.findUnique({ where: { nummer } }) : null;
+    if (vorhanden && vorhanden.kundeId !== kundeId) {
+      throw new RechnungsFehler("Diese Rechnungsnummer gehört bereits zu einem anderen Kunden.");
+    }
+
+    const daten = {
+      erstellt: eingabe.erstellt,
+      nummer,
+      datum: eingabe.datum ?? null,
+      ustSatz: eingabe.ustSatz ?? 19,
+      bezahlt: eingabe.bezahlt,
+      bezahltAm: eingabe.bezahlt ? (eingabe.bezahltAm ?? new Date()) : null,
+      anhangId: eingabe.anhangId ?? null,
+      notizen: eingabe.notizen ?? null,
+    };
+
+    // Welche Rechnung ist gemeint? Zuerst die über die Nummer gefundene, sonst die bisher verknüpfte.
+    const zielRechnungId = vorhanden?.id ?? laufzeit.kundenPosition?.rechnungId ?? null;
+
+    const rechnung = zielRechnungId
+      ? await tx.kundenrechnung.update({ where: { id: zielRechnungId }, data: daten })
+      : await tx.kundenrechnung.create({
+          data: { ...daten, kundeId, nettoBetrag: betrag },
+        });
+
+    const position = laufzeit.kundenPosition
+      ? await tx.kundenrechnungPosition.update({
+          where: { id: laufzeit.kundenPosition.id },
+          data: { rechnungId: rechnung.id, bezeichnung, nettoBetrag: betrag },
+        })
+      : await tx.kundenrechnungPosition.create({
+          data: { rechnungId: rechnung.id, bezeichnung, nettoBetrag: betrag },
+        });
+
+    await tx.laufzeit.update({ where: { id: laufzeitId }, data: { kundenPositionId: position.id } });
+
+    const positionen = await tx.kundenrechnungPosition.findMany({ where: { rechnungId: rechnung.id } });
+    const summe = positionen.reduce((s, p) => s + Number(p.nettoBetrag), 0);
+    await tx.kundenrechnung.update({ where: { id: rechnung.id }, data: { nettoBetrag: summe } });
+
+    await protokolliere("kundenrechnung.erfasst", "Kundenrechnung", rechnung.id, {
+      nummer,
+      laufzeitId,
+      nettoBetrag: betrag,
+      positionen: positionen.length,
+    });
+
+    return { rechnungId: rechnung.id, positionId: position.id, sammelrechnung: positionen.length > 1 };
+  });
+}
+
+/** Häkchen „Proxmox bezahlt“ direkt aus der Tabelle. */
+export async function einkaufBezahltSetzen(laufzeitId: string, bezahlt: boolean) {
+  const laufzeit = await prisma.laufzeit.findUnique({
+    where: { id: laufzeitId },
+    include: { proxmoxPosition: true },
+  });
+  if (!laufzeit?.proxmoxPosition) {
+    throw new RechnungsFehler("Für diese Laufzeit ist noch keine Proxmox-Rechnung erfasst.");
+  }
+
+  await prisma.proxmoxRechnung.update({
+    where: { id: laufzeit.proxmoxPosition.rechnungId },
+    data: { bezahlt, bezahltAm: bezahlt ? new Date() : null },
+  });
+
+  await protokolliere(
+    "proxmox_rechnung.bezahlt_gesetzt",
+    "ProxmoxRechnung",
+    laufzeit.proxmoxPosition.rechnungId,
+    {
+      bezahlt,
+      laufzeitId,
+    },
+  );
+}
+
+/**
+ * Häkchen „Kundenrechnung erstellt“ direkt aus der Tabelle.
+ * Fehlt die Rechnung noch, entsteht eine ohne Nummer – sie lässt sich später vervollständigen.
+ */
+export async function verkaufErstelltSetzen(laufzeitId: string, erstellt: boolean) {
+  const laufzeit = await prisma.laufzeit.findUnique({
+    where: { id: laufzeitId },
+    include: { kundenPosition: true, host: { select: { hostname: true, kundeId: true } } },
+  });
+  if (!laufzeit) throw new RechnungsFehler("Laufzeit nicht gefunden.");
+
+  if (laufzeit.kundenPosition) {
+    await prisma.kundenrechnung.update({
+      where: { id: laufzeit.kundenPosition.rechnungId },
+      data: { erstellt },
+    });
+    await protokolliere(
+      "kundenrechnung.erstellt_gesetzt",
+      "Kundenrechnung",
+      laufzeit.kundenPosition.rechnungId,
+      {
+        erstellt,
+        laufzeitId,
+      },
+    );
+    return;
+  }
+
+  if (!erstellt) return;
+  await kundenrechnungErfassen(laufzeitId, { erstellt: true, bezahlt: false, nettoBetrag: 0 });
+}
+
+/** Häkchen „Kundenrechnung bezahlt“. */
+export async function verkaufBezahltSetzen(laufzeitId: string, bezahlt: boolean) {
+  const laufzeit = await prisma.laufzeit.findUnique({
+    where: { id: laufzeitId },
+    include: { kundenPosition: true },
+  });
+  if (!laufzeit?.kundenPosition) {
+    throw new RechnungsFehler("Für diese Laufzeit ist noch keine Kundenrechnung erfasst.");
+  }
+
+  await prisma.kundenrechnung.update({
+    where: { id: laufzeit.kundenPosition.rechnungId },
+    data: { bezahlt, bezahltAm: bezahlt ? new Date() : null },
+  });
+
+  await protokolliere(
+    "kundenrechnung.bezahlt_gesetzt",
+    "Kundenrechnung",
+    laufzeit.kundenPosition.rechnungId,
+    {
+      bezahlt,
+      laufzeitId,
+    },
+  );
+}
+
+/** Legt eine Laufzeit von Hand an – etwa für Käufe, die der Agent noch nicht gemeldet hat. */
+export async function laufzeitAnlegen(daten: {
+  hostId: string;
+  key: string;
+  start: Date;
+  ende: Date;
+  notizen?: string | null;
+}) {
+  const vorhanden = await prisma.laufzeit.findUnique({
+    where: { hostId_start: { hostId: daten.hostId, start: daten.start } },
+  });
+  if (vorhanden) {
+    throw new RechnungsFehler("Für dieses Startdatum gibt es bereits eine Laufzeit.");
+  }
+  if (daten.ende <= daten.start) {
+    throw new RechnungsFehler("Das Ende muss nach dem Beginn liegen.");
+  }
+
+  const laufzeit = await prisma.laufzeit.create({
+    data: { ...daten, status: "BESTAETIGT" },
+  });
+  await protokolliere("laufzeit.angelegt", "Laufzeit", laufzeit.id, daten);
+  return laufzeit;
+}