@7365admin1/core 3.52.5-staging.251 → 3.52.6-staging.252

package/.changeset/bulk-upsert-fail-closed.md

@@ -0,0 +1,5 @@
+---
+"@7365admin1/core": patch
+---
+
+Spreadsheet vehicle import is fail-closed. `bulkUpsertVehicles` wrote every row to the database whatever the ANPR cameras answered, so an imported blocklist plate that no camera accepted was saved as blocked while the car still opened the barrier. Rows are now run through the shared `sweepExpiredVehicles` decision — every camera must confirm — and only confirmed rows are saved; the rest are rolled back off any camera that did take them and returned in `failedRows` with the camera and the reason.

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @iservice365/core
 
+## 3.52.5
+
+### Patch Changes
+
+- 9bad426: Revoke each expired vehicle's plate only from its own site's cameras, and fail closed
+
+  The hourly expired-vehicle sweep declared its `siteCameras` array outside the
+  per-vehicle loop and only ever pushed to it, so the list grew as the run went
+  on: the second vehicle was revoked from its own site's cameras AND from the
+  first vehicle's. `recNo` is a per-device sequence number, so those extra calls
+  did not simply miss - they addressed whatever record carried that number on the
+  other site's camera and took an unrelated, still-valid plate off the barrier.
+  Cameras are now resolved per vehicle, cached by site id so each site is still
+  paged only once per run.
+
+  The sweep also marked every expired vehicle deleted with one blanket
+  `updateMany`, regardless of what the cameras answered, so a record could read
+  "deleted" while its plate still opened the gate. Only vehicles whose every
+  camera confirmed are now marked deleted; the rest are left expired, logged at
+  error level naming the vehicle, plate, site and camera, and retried on the next
+  hourly run. `deleteExpiredVehicles` now requires the list of ids.
+
+  Also: each camera is asked for its own record id before the removal (the same
+  thing manual delete does), the ANPR list is chosen from the vehicle's type
+  instead of always TRAFFIC_REDLIST, a site with no ANPR camera no longer aborts
+  the whole run, and the transaction that wrapped nothing - the only write was
+  issued without the session - has been removed.
+
+- 082a865: Fail closed in the visitor ANPR sweep, and remove the dead invitation transaction
+
+  `processTransactionDahuaStatus`, the hourly job that takes an expired or
+  checked-out visitor's plate off the site's ANPR camera, marked the transaction
+  `dahuaSyncStatus: "removed"` on the line after the camera call and only skipped
+  on a thrown error. `removePlateNumber` does not throw for a device failure - it
+  returns an outcome object - so a camera answering 401 or 500, or not answering
+  at all, still had the transaction recorded as removed while the visitor's plate
+  was still on the barrier. Nothing retried it either, because the query that
+  feeds the sweep skips anything already marked removed.
+
+  It now uses the same decision logic as the expired-vehicle sweep: only a
+  transaction every camera confirmed is marked removed, and the rest are logged at
+  error level naming the plate, the site and the camera, then retried on the next
+  run. Each camera is also asked for its own record id before the removal, which
+  is what the old "not found" message sniff was reaching for and what stops a
+  transaction whose record is already gone from being retried for ever.
+
+  `checkExpiredInvitation` opened a session and a transaction and then issued
+  every write without that session, never committing: the transaction protected no
+  write and the rollback rolled back nothing. Each invitation is independent, so
+  there is no invariant spanning them and nothing for a transaction to protect -
+  it is removed rather than wired up.
+
 ## 3.52.4
 
 ### Patch Changes

package/dist/index.d.ts

@@ -2910,11 +2910,21 @@ declare function useVehicleService(): {
     reactivateVehicleById: (id: string, orgId: string, siteId: string) => Promise<string>;
     updateVehicleById: (_id: string, value: TVehicle) => Promise<void>;
     bulkUpsertVehicles: (values: TVehicle[], site: string, org: string) => Promise<{
+        savedCount: number;
+        failedRows: {
+            plateNumber: string;
+            message: string;
+        }[];
         matchedCount: number;
         modifiedCount: number;
         upsertedCount: number;
         upsertedIds?: undefined;
     } | {
+        savedCount: number;
+        failedRows: {
+            plateNumber: string;
+            message: string;
+        }[];
         matchedCount: number;
         modifiedCount: number;
         upsertedCount: number;
@@ -4206,7 +4216,7 @@ declare function useCameraViewService(): {
         cameraVerified: null;
         relayVerified: null;
         reachable: boolean;
-        health: "unreachable" | "ok" | "drifted";
+        health: "ok" | "unreachable" | "drifted";
         reason: string | null;
         camera: Record<string, any>;
         snapshotSupported: boolean;
@@ -4263,7 +4273,7 @@ declare function useCameraViewService(): {
             cameraVerified: null;
             relayVerified: null;
             reachable: boolean;
-            health: "unreachable" | "ok" | "drifted";
+            health: "ok" | "unreachable" | "drifted";
             reason: string | null;
             capabilities: CameraCapabilityDescriptor;
             firmwareVersion: null;

package/dist/index.js

@@ -36381,34 +36381,99 @@ function useVehicleService() {
       if (!siteCameras.length) {
         throw new Error("No site cameras found.");
       }
-      await Promise.all(
-        sanitizedValues.map(async (vehicleValue) => {
-          const plateNumber = vehicleValue.plateNumber;
-          const _mode = vehicleValue.type === "whitelist" /* WHITELIST */ ? "TrafficRedList" /* TRAFFIC_REDLIST */ : "TrafficBlackList" /* TRAFFIC_BLACKLIST */;
-          const recNos = await Promise.all(
-            siteCameras.map(async (camera) => {
-              const { host, username, password } = camera;
-              const dahuaPayload = {
-                host,
-                username,
-                password,
-                plateNumber,
-                mode: _mode,
-                ...vehicleValue.start ? { start: String(vehicleValue.start) } : {},
-                ...vehicleValue.end ? { end: String(vehicleValue.end) } : {},
-                ...vehicleValue.name ? { owner: vehicleValue.name } : {},
-                ...vehicleValue.vehicleModel ? { vehicleType: vehicleValue.vehicleModel } : {},
-                ...vehicleValue.vehicleColor ? { vehicleColor: vehicleValue.vehicleColor } : {}
-              };
+      const written = /* @__PURE__ */ new Map();
+      const sweepRows = sanitizedValues.map((value, index) => ({
+        _id: String(index),
+        site,
+        plateNumber: value.plateNumber
+      }));
+      const { deletableIds: savableIds, skipped } = await sweepExpiredVehicles(
+        sweepRows,
+        {
+          camerasForSite: async () => siteCameras,
+          cameraLabel,
+          revoke: async (camera, row) => {
+            const rowId = String(row._id);
+            const vehicleValue = sanitizedValues[Number(rowId)];
+            const plateNumber = vehicleValue.plateNumber;
+            const { host, username, password } = camera;
+            const dahuaPayload = {
+              host,
+              username,
+              password,
+              plateNumber,
+              mode: vehicleValue.type === "whitelist" /* WHITELIST */ ? "TrafficRedList" /* TRAFFIC_REDLIST */ : "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+              ...vehicleValue.start ? { start: String(vehicleValue.start) } : {},
+              ...vehicleValue.end ? { end: String(vehicleValue.end) } : {},
+              ...vehicleValue.name ? { owner: vehicleValue.name } : {},
+              ...vehicleValue.vehicleModel ? { vehicleType: vehicleValue.vehicleModel } : {},
+              ...vehicleValue.vehicleColor ? { vehicleColor: vehicleValue.vehicleColor } : {}
+            };
+            try {
               const dahuaResponse = await _bulkInsertPlateNumber(dahuaPayload);
+              const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
               const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              return responseData.split("=")[1]?.trim();
-            })
+              if (responseStatus !== 200) {
+                logCameraFailure(
+                  "bulk add",
+                  camera,
+                  `HTTP ${responseStatus}: ${responseData.slice(0, 500)}`
+                );
+                return {
+                  ok: false,
+                  reason: anprWriteReason(`HTTP ${responseStatus}`)
+                };
+              }
+              const recNo = String(responseData.split("=")[1]?.trim() ?? "");
+              if (recNo) {
+                vehicleValue.recNo = vehicleValue.recNo || recNo;
+                const entries = written.get(rowId) ?? [];
+                entries.push({ camera, recno: recNo });
+                written.set(rowId, entries);
+              }
+              return { ok: true, reason: "" };
+            } catch (error) {
+              logCameraFailure("bulk add", camera, error);
+              return { ok: false, reason: anprWriteReason(error) };
+            }
+          }
+        }
+      );
+      const failedRows = [];
+      for (const entry of skipped) {
+        const stranded = [];
+        for (const write of written.get(entry.id) ?? []) {
+          const outcome = await _removePlateNumber({
+            host: write.camera.host,
+            username: write.camera.username,
+            password: write.camera.password,
+            recno: write.recno,
+            mode: sanitizedValues[Number(entry.id)]?.type === "whitelist" /* WHITELIST */ ? "TrafficRedList" /* TRAFFIC_REDLIST */ : "TrafficBlackList" /* TRAFFIC_BLACKLIST */
+          }).catch((removeError) => anprRevokeThrew(removeError));
+          if (!outcome?.ok)
+            stranded.push(cameraLabel(write.camera));
+        }
+        let message = anprWriteFailureMessage(entry.failures);
+        if (stranded.length) {
+          import_node_server_utils99.logger.error(
+            `bulkUpsertVehicles could not take the plate back off: ${stranded.join(", ")} (plate ${JSON.stringify(entry.plateNumber)})`
           );
-          vehicleValue.recNo = recNos.find((r) => r) ?? void 0;
-        })
+          message += ` WARNING: the plate number was written to ${stranded.join(", ")} and could not be removed again - it WILL still open the barrier. Remove it on the camera by hand.`;
+        }
+        import_node_server_utils99.logger.error(
+          `bulkUpsertVehicles NOT saving plate ${JSON.stringify(entry.plateNumber)} (site ${entry.site}): ` + entry.failures.map((failure) => `${failure.camera} (${failure.reason})`).join(", ")
+        );
+        failedRows.push({
+          plateNumber: String(entry.plateNumber ?? ""),
+          message
+        });
+      }
+      const savable = new Set(savableIds);
+      const toSave = sanitizedValues.filter(
+        (_, index) => savable.has(String(index))
       );
-      return await _bulkUpsertVehicles(sanitizedValues);
+      const result = toSave.length ? await _bulkUpsertVehicles(toSave) : { matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+      return { ...result, savedCount: toSave.length, failedRows };
     } catch (error) {
       throw error;
     }