Consolidate GVL deletion workflow and document purge semantics

src/data-maintenance/data-maintenance.js

@@ -1,69 +1,119 @@
 "use strict";
 
-const purgeGvlReferenceDataButton = document.getElementById(
-  "purge-gvl-reference-data-button"
-);
 const gvlReferenceMaintenanceStatus = document.getElementById(
   "gvl-reference-maintenance-status"
 );
+const gvlReferenceProtectedRevisions = document.getElementById(
+  "gvl-reference-protected-revisions"
+);
+const gvlReferenceMaintenanceMessage = document.getElementById(
+  "gvl-reference-maintenance-message"
+);
+const purgeGvlReferenceDataButton = document.getElementById(
+  "purge-gvl-reference-data-button"
+);
 
-document.addEventListener("DOMContentLoaded", () => {
-  purgeGvlReferenceDataButton?.addEventListener("click", async () => {
-    await purgeGvlReferenceData();
+document.addEventListener("DOMContentLoaded", async () => {
+  purgeGvlReferenceDataButton.addEventListener("click", async () => {
+    await purgeUnlockedEvidenceRecords();
   });
+  await renderGvlReferenceMaintenanceStatus();
 });
 
-async function purgeGvlReferenceData() {
-  if (!confirm(buildGvlReferenceDataPurgeConfirmationText())) {
-    renderGvlReferenceMaintenanceStatus("Abgebrochen.");
+async function renderGvlReferenceMaintenanceStatus() {
+  try {
+    const result = await browser.runtime.sendMessage({
+      type: "list_gvl_snapshots"
+    });
+
+    if (!result?.success) {
+      throw new Error(result?.error ?? "list_gvl_snapshots_failed");
+    }
+
+    renderGvlReferenceSnapshotStatus(result.gvlSnapshots ?? []);
+  } catch (error) {
+    renderGvlReferenceStatus("–", true, "Status nicht verfügbar.");
+    renderProtectedRevisions([]);
+    console.warn("VG-Observe GVL maintenance status failed", error);
+  }
+}
+
+function renderGvlReferenceSnapshotStatus(snapshots) {
+  if (!snapshots.length) {
+    renderGvlReferenceStatus("–", true, "Keine GVL-Revisionen.");
+    renderProtectedRevisions([]);
+    return;
+  }
+
+  const protectedRevisions = snapshots
+    .filter((snapshot) => snapshot.workspaceDeleteProtected === true)
+    .map((snapshot) => snapshot.vendorListVersion)
+    .filter((vendorListVersion) => vendorListVersion !== null)
+    .filter((vendorListVersion) => vendorListVersion !== undefined);
+  const allRevisionsDeleteAllowed = snapshots.every((snapshot) => {
+    return snapshot.workspaceDeleteAllowed === true;
+  });
+
+  if (allRevisionsDeleteAllowed) {
+    renderGvlReferenceStatus("🔓", false, "GVL-Revisionen löschbar.");
+  } else if (protectedRevisions.length) {
+    renderGvlReferenceStatus("🔒", true, "GVL-Revisionen geschützt.");
+  } else {
+    renderGvlReferenceStatus("–", true, "Status nicht verfügbar.");
+  }
+
+  renderProtectedRevisions(protectedRevisions);
+}
+
+function renderGvlReferenceStatus(statusSymbol, buttonDisabled, message) {
+  gvlReferenceMaintenanceStatus.textContent = statusSymbol;
+  purgeGvlReferenceDataButton.disabled = buttonDisabled;
+  gvlReferenceMaintenanceMessage.textContent = message;
+}
+
+async function purgeUnlockedEvidenceRecords() {
+  if (
+    !confirm(
+      "Ungesperrte Evidence-Daten mit bestehender Schutzlogik bereinigen?"
+    )
+  ) {
     return;
   }
 
   purgeGvlReferenceDataButton.disabled = true;
-  renderGvlReferenceMaintenanceStatus("GVL-Referenzdaten werden bereinigt...");
+  gvlReferenceMaintenanceMessage.textContent = "Bereinigung läuft...";
 
   try {
     const result = await browser.runtime.sendMessage({
-      type: "purge_gvl_reference_data"
+      type: "purge_unlocked_evidence_records"
     });
 
     if (!result?.success) {
-      throw new Error(result?.error ?? "purge_gvl_reference_data_failed");
+      throw new Error(result?.error ?? "purge_unlocked_evidence_records_failed");
     }
 
-    renderGvlReferenceMaintenanceStatus(
-      buildGvlReferenceDataPurgeSuccessMessage(result)
-    );
+    await renderGvlReferenceMaintenanceStatus();
+    gvlReferenceMaintenanceMessage.textContent = buildPurgeSuccessMessage(result);
   } catch (error) {
-    renderGvlReferenceMaintenanceStatus(
-      "GVL-Referenzdaten konnten nicht bereinigt werden."
-    );
-    console.warn("VG-Observe GVL reference data purge failed", error);
-  } finally {
-    purgeGvlReferenceDataButton.disabled = false;
+    await renderGvlReferenceMaintenanceStatus();
+    gvlReferenceMaintenanceMessage.textContent = "Bereinigung fehlgeschlagen.";
+    console.warn("VG-Observe protected purge failed", error);
   }
 }
 
-function buildGvlReferenceDataPurgeConfirmationText() {
-  return [
-    "GVL-Referenzdaten bereinigen?",
-    "",
-    "Betroffen: GVL-Referenzdaten der Browser-DB.",
-    "Nicht betroffen: Consent-Daten, Request-Beobachtungen, Analyse-Daten.",
-    "",
-    "Diese Aktion entfernt lokale GVL-Referenzdaten aus der Browser-Datenbank."
-  ].join("\n");
+function buildPurgeSuccessMessage(result) {
+  if (Number.isFinite(result.deletedCount)) {
+    return `Bereinigung abgeschlossen: ${result.deletedCount} Records.`;
+  }
+
+  return "Bereinigung abgeschlossen.";
 }
 
-function buildGvlReferenceDataPurgeSuccessMessage(result) {
-  const clearedCount = Object.values(result.clearedStores ?? {}).reduce(
-    (total, count) => total + Number(count ?? 0),
-    0
-  );
-
-  return `GVL-Referenzdaten bereinigt: ${clearedCount} Records entfernt.`;
-}
-
-function renderGvlReferenceMaintenanceStatus(message) {
-  gvlReferenceMaintenanceStatus.textContent = message;
+function renderProtectedRevisions(vendorListVersions) {
+  gvlReferenceProtectedRevisions.hidden = vendorListVersions.length === 0;
+  gvlReferenceProtectedRevisions.textContent = vendorListVersions.length
+    ? `Geschützt: ${vendorListVersions
+        .map((vendorListVersion) => String(vendorListVersion))
+        .join(", ")}`
+    : "";
 }