Refactor: große Dateien in kleinere Module/Komponenten aufgeteilt

Explizite Vorgabe: keine wachsenden Monolith-Dateien. AdminPage.tsx (349 Zeilen) in pages/admin/{Standort,Material,Objekt}Section.tsx aufgeteilt, KontrollPage.tsx (277 Zeilen) in pages/kontrolle/{useKontrolle, PositionCard,StatusBadge,types} aufgeteilt, services/kontrolle.py (332 Zeilen) in ein Package (lifecycle/erfassung/exceptions) aufgeteilt - öffentliche API bleibt über __init__.py unverändert re-exportiert, kein bestehender Import musste angepasst werden. Reines Refactoring, keine Verhaltensänderung. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01L85hmKbvX7Cqkq47KnQhFt
2026-09-04 00:45:18 +02:00
parent 08b10c7c37
commit f6084e2d5a
14 changed files with 1079 additions and 661 deletions
@@ -0,0 +1,171 @@
+import { useEffect, useMemo, useState } from "react";
+
+import { apiRequest, ApiError } from "../../api/client";
+import type { Kontrolle, Material, Objekt, Objektposition } from "../../api/types";
+import { enqueue, eintraegeFuerKontrolle, entferneFehlerEintrag, synchronisiereQueue } from "../../offline/queue";
+import { useOnlineStatus } from "../../offline/useOnlineStatus";
+import type { PositionZustand, Sperrmeldung } from "./types";
+
+/**
+ * Bündelt den kompletten Zustand/Ablauf einer Kontrolle (Prompt 11 Screens 2-6
+ * + Prompt 17 Offline-Härtung), damit KontrollPage.tsx nur noch die Darstellung
+ * übernimmt. Start -> Positionen erfassen (über die lokale Queue, nie direkt
+ * blockierend) -> Abschluss erst möglich, wenn nichts mehr unbestätigt liegt.
+ */
+export function useKontrolle(objektId: string | undefined) {
+  const online = useOnlineStatus();
+
+  const [objekt, setObjekt] = useState<Objekt | null>(null);
+  const [kontrolle, setKontrolle] = useState<Kontrolle | null>(null);
+  const [sperre, setSperre] = useState<Sperrmeldung | null>(null);
+  const [positionen, setPositionen] = useState<PositionZustand[]>([]);
+  const [startFehler, setStartFehler] = useState<string | null>(null);
+  const [wirdAbgeschlossen, setWirdAbgeschlossen] = useState(false);
+  const [abschlussFehler, setAbschlussFehler] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!objektId) return;
+    apiRequest<Objekt>(`/objekte/${objektId}`).then(setObjekt).catch(() => undefined);
+  }, [objektId]);
+
+  async function starteKontrolle(uebernehmen: boolean) {
+    if (!objektId) return;
+    setStartFehler(null);
+    try {
+      const neueKontrolle = await apiRequest<Kontrolle>(`/objekte/${objektId}/kontrollen`, {
+        method: "POST",
+        body: { uebernehmen },
+      });
+      setKontrolle(neueKontrolle);
+      setSperre(null);
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 409) {
+        const detail = error.detail as { benutzer?: string; seit?: string } | null;
+        setSperre({ benutzer: detail?.benutzer ?? null, seit: detail?.seit ?? "" });
+      } else {
+        setStartFehler("Kontrolle konnte nicht gestartet werden (keine Verbindung?).");
+      }
+    }
+  }
+
+  useEffect(() => {
+    void starteKontrolle(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [objektId]);
+
+  useEffect(() => {
+    if (!kontrolle) return;
+    Promise.all([
+      apiRequest<Objektposition[]>(`/objekte/${kontrolle.objekt_id}/positionen`),
+      apiRequest<Material[]>("/materialien"),
+    ]).then(([positionsListe, materialListe]) => {
+      const materialById = new Map(materialListe.map((m) => [m.id, m]));
+      setPositionen(
+        positionsListe
+          .filter((p) => p.ist_status === "aktiv")
+          .map((p) => ({
+            position: p,
+            material: materialById.get(p.material_id),
+            status: "unbestaetigt",
+            eingabe: p.sollmenge_effektiv,
+            fehlerText: null,
+          }))
+      );
+    });
+  }, [kontrolle]);
+
+  // Reconciliation-Loop: gleicht lokalen Anzeigezustand mit der Offline-Queue ab.
+  // Ein Eintrag, der aus der Queue verschwunden ist, wurde erfolgreich übertragen
+  // (queue.ts entfernt Einträge ausschließlich bei Erfolg, siehe dort).
+  useEffect(() => {
+    if (!kontrolle) return;
+    const interval = window.setInterval(async () => {
+      const eintraege = await eintraegeFuerKontrolle(kontrolle.id);
+      const byMaterial = new Map(eintraege.map((e) => [e.materialId, e]));
+      setPositionen((bisherige) =>
+        bisherige.map((zustand) => {
+          const inQueue = byMaterial.get(zustand.position.material_id);
+          if (inQueue) {
+            return { ...zustand, status: inQueue.status, fehlerText: inQueue.fehlerText };
+          }
+          if (zustand.status === "wartet" || zustand.status === "wird_uebertragen") {
+            return { ...zustand, status: "gespeichert", fehlerText: null };
+          }
+          return zustand;
+        })
+      );
+    }, 2000);
+    return () => window.clearInterval(interval);
+  }, [kontrolle]);
+
+  useEffect(() => {
+    if (online) void synchronisiereQueue();
+  }, [online]);
+
+  function eingabeAendern(materialId: number, wert: string) {
+    setPositionen((bisherige) =>
+      bisherige.map((z) => (z.position.material_id === materialId ? { ...z, eingabe: wert } : z))
+    );
+  }
+
+  async function positionSenden(materialId: number, istmenge: string) {
+    if (!kontrolle) return;
+    await enqueue(kontrolle.id, materialId, istmenge);
+    setPositionen((bisherige) =>
+      bisherige.map((z) => (z.position.material_id === materialId ? { ...z, status: "wartet" } : z))
+    );
+    void synchronisiereQueue();
+  }
+
+  async function fehlerErneutVersuchen(materialId: number, istmenge: string) {
+    if (!kontrolle) return;
+    await entferneFehlerEintrag(kontrolle.id, materialId);
+    await positionSenden(materialId, istmenge);
+  }
+
+  const alleUebertragen = useMemo(
+    () => positionen.length > 0 && positionen.every((p) => p.status === "gespeichert"),
+    [positionen]
+  );
+
+  async function abschliessen() {
+    if (!kontrolle) return false;
+    setWirdAbgeschlossen(true);
+    setAbschlussFehler(null);
+    try {
+      await apiRequest(`/kontrollen/${kontrolle.id}/abschliessen`, { method: "POST" });
+      return true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 409) {
+        setAbschlussFehler("Nicht alle Positionen wurden erfasst.");
+      } else {
+        setAbschlussFehler("Abschluss fehlgeschlagen (keine Verbindung?).");
+      }
+      return false;
+    } finally {
+      setWirdAbgeschlossen(false);
+    }
+  }
+
+  async function abbrechen(grund: string | undefined) {
+    if (!kontrolle) return;
+    await apiRequest(`/kontrollen/${kontrolle.id}/abbrechen`, { method: "POST", body: { grund } });
+  }
+
+  return {
+    online,
+    objekt,
+    sperre,
+    positionen,
+    startFehler,
+    wirdAbgeschlossen,
+    abschlussFehler,
+    alleUebertragen,
+    starteKontrolle,
+    eingabeAendern,
+    positionSenden,
+    fehlerErneutVersuchen,
+    abschliessen,
+    abbrechen,
+  };
+}