@7365admin1/core 3.83.0 → 3.85.0

package/dist/index.js

@@ -77,6 +77,7 @@ __export(src_exports, {
   ConsoleAuditAction: () => ConsoleAuditAction,
   ConsoleAuditTarget: () => ConsoleAuditTarget,
   DEFAULT_RING_SECONDS: () => DEFAULT_RING_SECONDS,
+  DEFAULT_SCALE_M_PER_PX: () => DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE: () => DEFAULT_SITE_TIMEZONE,
   DEVICE_STATUS: () => DEVICE_STATUS,
   DOBStatus: () => DOBStatus,
@@ -247,6 +248,7 @@ __export(src_exports, {
   ROBOT_CAPABILITIES: () => ROBOT_CAPABILITIES,
   ROBOT_CLOUD_DOC_CONFIRMATIONS: () => ROBOT_CLOUD_DOC_CONFIRMATIONS,
   ROBOT_CLOUD_PATHS: () => ROBOT_CLOUD_PATHS,
+  ROBOT_CLOUD_TIMEOUT_MS: () => ROBOT_CLOUD_TIMEOUT_MS,
   ROBOT_MODULE: () => ROBOT_MODULE,
   ROBOT_PERMISSIONS: () => ROBOT_PERMISSIONS,
   ROBOT_STATUS_NAMES: () => ROBOT_STATUS_NAMES,
@@ -296,6 +298,8 @@ __export(src_exports, {
   VerificationType: () => VerificationType,
   VisitorSort: () => VisitorSort,
   VisitorStatus: () => VisitorStatus,
+  WALL_HEIGHT_M: () => WALL_HEIGHT_M,
+  WALL_THICKNESS_M: () => WALL_THICKNESS_M,
   addressSchema: () => addressSchema,
   allowedFieldsSite: () => allowedFieldsSite,
   allowedNatures: () => allowedNatures,
@@ -307,6 +311,8 @@ __export(src_exports, {
   attendanceSchema: () => attendanceSchema,
   attendanceSettingsSchema: () => attendanceSettingsSchema,
   buildSelfServiceEmailContext: () => buildSelfServiceEmailContext,
+  buildingMapFromRobotMaps: () => buildingMapFromRobotMaps,
+  buildingSolids: () => buildingSolids,
   building_level_namespace_collection: () => building_level_namespace_collection,
   building_units_namespace_collection: () => building_units_namespace_collection,
   buildings_namespace_collection: () => buildings_namespace_collection,
@@ -413,6 +419,9 @@ __export(src_exports, {
   isTermsCurrent: () => isTermsCurrent,
   isTrackingStale: () => isTrackingStale,
   isValidTimezone: () => isValidTimezone,
+  levelPixelToMetres: () => levelPixelToMetres,
+  levelScale: () => levelScale,
+  levelSolids: () => levelSolids,
   listStaffUserIds: () => listStaffUserIds,
   liveStatusFor: () => liveStatusFor,
   manpowerDesignationsSchema: () => manpowerDesignationsSchema,
@@ -511,6 +520,7 @@ __export(src_exports, {
   robotTier: () => robotTier,
   robotTypesVisibleTo: () => robotTypesVisibleTo,
   rtspUrl: () => rtspUrl,
+  scaleFromMeasurement: () => scaleFromMeasurement,
   schema: () => schema,
   schemaAppSlugNotification: () => schemaAppSlugNotification,
   schemaApprovedBy: () => schemaApprovedBy,
@@ -677,6 +687,7 @@ __export(src_exports, {
   snapshotEndpoint: () => snapshotEndpoint,
   snapshotRefusalReason: () => snapshotRefusalReason,
   staffMayBypass: () => staffMayBypass,
+  startRobotTracking: () => startRobotTracking,
   startTodaysBookForSite: () => startTodaysBookForSite,
   stringifyHidJson: () => stringifyHidJson,
   stripFacialImageMetadata: () => stripFacialImageMetadata,
@@ -928,8 +939,10 @@ __export(src_exports, {
   vehicleSchema: () => vehicleSchema,
   vehicleViewOf: () => vehicleViewOf,
   vehicles_namespace_collection: () => vehicles_namespace_collection,
+  vertexDistancePx: () => vertexDistancePx,
   visitors_namespace_collection: () => visitors_namespace_collection,
   wallConfig: () => wallConfig,
+  wallsFromOccupancyGrid: () => wallsFromOccupancyGrid,
   withLiveLink: () => withLiveLink,
   workOrderSchema: () => workOrderSchema,
   work_orders2_namespace_collection: () => work_orders2_namespace_collection,
@@ -60127,6 +60140,179 @@ function createLiftSimulator(options) {
   };
 }
 
+// src/utils/building-map.util.ts
+var WALL_HEIGHT_M = 2.5;
+var WALL_THICKNESS_M = 0.1;
+var DEFAULT_SCALE_M_PER_PX = 0.05;
+function scaleFromMeasurement(pixelDistance, realDistanceM) {
+  if (!Number.isFinite(pixelDistance) || pixelDistance <= 0) {
+    throw new Error("A measurement needs a positive pixel distance.");
+  }
+  if (!Number.isFinite(realDistanceM) || realDistanceM <= 0) {
+    throw new Error("A measurement needs a positive real distance in metres.");
+  }
+  return realDistanceM / pixelDistance;
+}
+function vertexDistancePx(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function levelScale(level) {
+  const measurement = level.measurements?.find((m) => {
+    const a = level.vertices[m.start];
+    const b = level.vertices[m.end];
+    return a && b && m.distanceM > 0 && vertexDistancePx(a, b) > 0;
+  });
+  if (measurement) {
+    return scaleFromMeasurement(
+      vertexDistancePx(level.vertices[measurement.start], level.vertices[measurement.end]),
+      measurement.distanceM
+    );
+  }
+  return level.scaleMPerPx > 0 ? level.scaleMPerPx : DEFAULT_SCALE_M_PER_PX;
+}
+function levelPixelToMetres(level, px, py, imageHeightPx) {
+  const scale = levelScale(level);
+  return {
+    x: level.originXM + px * scale,
+    y: level.originYM + (imageHeightPx - py) * scale
+  };
+}
+function levelSolids(level, imageHeightPx) {
+  const toM = (v) => levelPixelToMetres(level, v.x, v.y, imageHeightPx);
+  const walls = [];
+  for (const wall of level.walls ?? []) {
+    const a = level.vertices[wall.start];
+    const b = level.vertices[wall.end];
+    if (!a || !b)
+      continue;
+    const pa = toM(a);
+    const pb = toM(b);
+    const lengthM = Math.hypot(pb.x - pa.x, pb.y - pa.y);
+    if (lengthM <= 0)
+      continue;
+    const heightM = wall.heightM ?? WALL_HEIGHT_M;
+    walls.push({
+      centre: {
+        x: (pa.x + pb.x) / 2,
+        y: (pa.y + pb.y) / 2,
+        // Boxes are centred, so a wall standing ON the floor sits at half its
+        // own height above the level's elevation.
+        z: level.elevationM + heightM / 2
+      },
+      lengthM,
+      thicknessM: wall.thicknessM ?? WALL_THICKNESS_M,
+      heightM,
+      yaw: Math.atan2(pb.y - pa.y, pb.x - pa.x)
+    });
+  }
+  const floors = [];
+  for (const floor of level.floors ?? []) {
+    const points = (floor.vertices ?? []).map((i) => level.vertices[i]).filter(Boolean).map(toM);
+    if (points.length < 3)
+      continue;
+    floors.push({ points, elevationM: level.elevationM, hole: floor.hole === true });
+  }
+  return { level: level.name, elevationM: level.elevationM, walls, floors };
+}
+function buildingSolids(map, imageHeightFor) {
+  return (map.levels ?? []).map((level) => levelSolids(level, imageHeightFor(level)));
+}
+function wallsFromOccupancyGrid(grid, options) {
+  const threshold = options?.threshold ?? 100;
+  const minRun = Math.max(2, options?.minRunPx ?? 6);
+  const { data, width, height } = grid;
+  if (!width || !height || !data || data.length < width * height) {
+    return { vertices: [], walls: [] };
+  }
+  const occupied = (x, y) => Number(data[y * width + x]) <= threshold;
+  const consumed = new Uint8Array(width * height);
+  const vertices = [];
+  const walls = [];
+  const index = /* @__PURE__ */ new Map();
+  const vertexAt = (x, y) => {
+    const key = `${x}:${y}`;
+    const found = index.get(key);
+    if (found !== void 0)
+      return found;
+    vertices.push({ x, y, z: 0 });
+    index.set(key, vertices.length - 1);
+    return vertices.length - 1;
+  };
+  const addRun = (x1, y1, x2, y2) => {
+    walls.push({ start: vertexAt(x1, y1), end: vertexAt(x2, y2) });
+  };
+  for (let y = 0; y < height; y++) {
+    let run = 0;
+    for (let x = 0; x <= width; x++) {
+      const on = x < width && occupied(x, y);
+      if (on) {
+        run++;
+        continue;
+      }
+      if (run >= minRun) {
+        const startX = x - run;
+        addRun(startX, y, x - 1, y);
+        for (let i = startX; i < x; i++)
+          consumed[y * width + i] = 1;
+      }
+      run = 0;
+    }
+  }
+  for (let x = 0; x < width; x++) {
+    let run = 0;
+    for (let y = 0; y <= height; y++) {
+      const on = y < height && occupied(x, y) && !consumed[y * width + x];
+      if (on) {
+        run++;
+        continue;
+      }
+      if (run >= minRun) {
+        addRun(x, y - run, x, y - 1);
+      }
+      run = 0;
+    }
+  }
+  return { vertices, walls };
+}
+function buildingMapFromRobotMaps(name, maps, floorHeightM = 3) {
+  const levels = [...maps ?? []].sort((a, b) => a.floorNo - b.floorNo).map((map) => {
+    const vertices = [];
+    if (map.baseX || map.baseY) {
+      vertices.push({
+        x: map.baseX ?? 0,
+        y: map.baseY ?? 0,
+        z: 0,
+        name: `L${map.floorNo}_charger`,
+        isCharger: true,
+        theta: map.baseTheta ?? 0
+      });
+    }
+    for (const area of map.areaList ?? []) {
+      vertices.push({
+        x: area.x,
+        y: area.y,
+        z: 0,
+        name: area.areaName,
+        isCleaningZone: true
+      });
+    }
+    return {
+      name: map.mapName?.trim() || `L${map.floorNo}`,
+      elevationM: (map.floorNo - 1) * floorHeightM,
+      drawing: { fileKey: map.backgroundFileKey },
+      scaleMPerPx: map.resolution && map.resolution > 0 ? map.resolution : DEFAULT_SCALE_M_PER_PX,
+      originXM: map.originX ?? 0,
+      originYM: map.originY ?? 0,
+      vertices,
+      walls: [],
+      floors: [],
+      doors: [],
+      measurements: []
+    };
+  });
+  return { name, levels, lifts: [] };
+}
+
 // src/services/robot-fleet.service.ts
 var import_node_server_utils157 = require("@7365admin1/node-server-utils");
 
@@ -60507,6 +60693,145 @@ function registerOunitechBrand() {
   });
 }
 
+// src/services/robot-tracking.service.ts
+var import_axios4 = __toESM(require("axios"));
+async function openWithAxios(url, body) {
+  const response = await import_axios4.default.post(url, body, {
+    responseType: "stream",
+    // No read timeout: this connection is SUPPOSED to stay open and mostly
+    // silent. A request timeout here would sever a healthy stream on a quiet
+    // robot. The idle watchdog is what decides a stream is dead, because it can
+    // tell silence from a closed socket.
+    timeout: 0,
+    headers: { "Content-Type": "application/json", Accept: "text/event-stream" }
+  });
+  return response.data;
+}
+function startRobotTracking(options) {
+  const {
+    credentials,
+    robotSn,
+    onEvent,
+    baseUrl = ROBOT_CLOUD_BASE_URL,
+    idleTimeoutMs = TRACKING_IDLE_TIMEOUT_MS,
+    openStream = openWithAxios,
+    now = Date.now
+  } = options;
+  if (!baseUrl)
+    throw new Error("Robot cloud: ROBOT_CLOUD_BASE_URL is not configured.");
+  let stopped = false;
+  let attempt = 0;
+  let current = null;
+  let watchdog = null;
+  let retry = null;
+  let lastActivityAt = now();
+  let everConnected = false;
+  const parser = createSseParser();
+  function clearTimers() {
+    if (watchdog) {
+      clearInterval(watchdog);
+      watchdog = null;
+    }
+    if (retry) {
+      clearTimeout(retry);
+      retry = null;
+    }
+  }
+  function dropUpstream() {
+    if (!current)
+      return;
+    try {
+      current.destroy();
+    } catch {
+    }
+    current = null;
+  }
+  function lose(reason) {
+    if (stopped)
+      return;
+    onEvent({ type: "lost", reason, at: now() });
+    dropUpstream();
+    scheduleReconnect();
+  }
+  function scheduleReconnect() {
+    if (stopped)
+      return;
+    clearTimers();
+    const delay2 = trackingBackoffMs(attempt++);
+    retry = setTimeout(connect2, delay2);
+  }
+  async function connect2() {
+    if (stopped)
+      return;
+    const body = robotCloudBody(
+      credentials.appid,
+      credentials.secret,
+      ROBOT_CLOUD_PATHS.tracking,
+      { robotSn }
+    );
+    let stream;
+    try {
+      stream = await openStream(
+        `${baseUrl.replace(/\/+$/, "")}${ROBOT_CLOUD_PATHS.tracking}`,
+        body
+      );
+    } catch (error) {
+      lose(error?.message ?? "Could not open the robot's tracking stream.");
+      return;
+    }
+    if (stopped) {
+      try {
+        stream.destroy();
+      } catch {
+      }
+      return;
+    }
+    parser.reset();
+    current = stream;
+    lastActivityAt = now();
+    if (everConnected)
+      onEvent({ type: "reconnected", at: now() });
+    everConnected = true;
+    attempt = 0;
+    stream.on("data", (chunk) => {
+      if (stopped)
+        return;
+      const { events, sawActivity } = parser.push(chunk.toString("utf8"));
+      if (sawActivity)
+        lastActivityAt = now();
+      for (const event of events) {
+        const pose = decodeTrackingFrame(event.data);
+        if (pose)
+          onEvent({ type: "pose", pose, at: now() });
+      }
+    });
+    stream.on("error", (error) => lose(error?.message ?? "The tracking stream failed."));
+    stream.on("end", () => lose("The robot cloud closed the tracking stream."));
+    stream.on("close", () => {
+      if (!stopped && current === stream)
+        lose("The tracking stream closed.");
+    });
+    clearTimers();
+    watchdog = setInterval(() => {
+      if (stopped)
+        return;
+      if (now() - lastActivityAt >= idleTimeoutMs) {
+        lose("The robot stopped reporting.");
+      }
+    }, Math.max(1e3, Math.floor(idleTimeoutMs / 3)));
+  }
+  void connect2();
+  return {
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      clearTimers();
+      dropUpstream();
+    }
+  };
+}
+
 // src/controllers/robot-fleet.controller.ts
 var import_joi76 = __toESM(require("joi"));
 var import_node_server_utils158 = require("@7365admin1/node-server-utils");
@@ -60585,7 +60910,55 @@ function useRobotFleetController(deps) {
       fail(next, error);
     }
   }
-  return { getState, getMaps, getMapImages, getPlans, sendCommand: sendCommand2 };
+  async function trackRobot(req, res, next) {
+    let robot;
+    let robotSn;
+    try {
+      robot = await entitleRobot(req, req.params.id);
+      robotSn = await getFleet().resolveRobotSn(robot);
+    } catch (error) {
+      fail(next, error);
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      // Nginx buffers proxied responses by default, which holds an SSE stream
+      // until the buffer fills - the stream appears dead for minutes.
+      "X-Accel-Buffering": "no"
+    });
+    res.flushHeaders?.();
+    const send2 = (event) => {
+      if (res.writableEnded)
+        return;
+      res.write(`data: ${JSON.stringify(event)}
+
+`);
+    };
+    const handle = startRobotTracking({
+      credentials: {
+        appid: (robot.appKey ?? "").trim(),
+        secret: (robot.appToken ?? "").trim()
+      },
+      robotSn,
+      onEvent: send2
+    });
+    const keepAlive = setInterval(() => {
+      if (!res.writableEnded)
+        res.write(": keep-alive\n\n");
+    }, 15e3);
+    const close = () => {
+      clearInterval(keepAlive);
+      handle.stop();
+      if (!res.writableEnded)
+        res.end();
+    };
+    req.on("close", close);
+    req.on("aborted", close);
+    res.on("error", close);
+  }
+  return { getState, getMaps, getMapImages, getPlans, sendCommand: sendCommand2, trackRobot };
 }
 
 // src/models/patrol-question.model.ts
@@ -80902,7 +81275,7 @@ var MManpowerMonitoring = class {
 var import_node_server_utils248 = require("@7365admin1/node-server-utils");
 
 // src/utils/hrmlabs-attendance.util.ts
-var import_axios4 = __toESM(require("axios"));
+var import_axios5 = __toESM(require("axios"));
 var import_moment_timezone7 = __toESM(require("moment-timezone"));
 var default_early_checkIn = 4;
 async function hrmLabsAuthentication({
@@ -80911,7 +81284,7 @@ async function hrmLabsAuthentication({
   password,
   domain
 }) {
-  const res = await import_axios4.default.post(
+  const res = await import_axios5.default.post(
     authUrl,
     {
       grant_type: "password",
@@ -80941,7 +81314,7 @@ async function fetchAttendanceData({
   search
 }) {
   try {
-    const res = await import_axios4.default.post(
+    const res = await import_axios5.default.post(
       attendanceUrl,
       {
         start: startDate,
@@ -81141,7 +81514,7 @@ async function fetchSites({ siteUrl, token }) {
   do {
     try {
       attempt++;
-      const res = await import_axios4.default.get(siteUrl, {
+      const res = await import_axios5.default.get(siteUrl, {
         headers: { Authorization: `Bearer ${token}` },
         timeout: 15e3
       });
@@ -84739,7 +85112,7 @@ async function manpowerEvents(io) {
 }
 
 // src/services/reddot-payment.service.ts
-var import_axios5 = __toESM(require("axios"));
+var import_axios6 = __toESM(require("axios"));
 
 // src/utils/payment-signature.util.ts
 var crypto9 = __toESM(require("crypto"));
@@ -85373,7 +85746,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_PAYMENT;
-      const response = await import_axios5.default.post(url, dataString, { headers });
+      const response = await import_axios6.default.post(url, dataString, { headers });
       const result = response.data;
       return result;
     } catch (error) {
@@ -85407,7 +85780,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_ENQUIRY;
-      const response = await import_axios5.default.post(url, dataString, { headers });
+      const response = await import_axios6.default.post(url, dataString, { headers });
       const result = response.data;
       const transactionId = result.transaction_id;
       const amount = result.request_amount || 0;
@@ -93944,6 +94317,7 @@ function usePersonalEmergencyChainController() {
   ConsoleAuditAction,
   ConsoleAuditTarget,
   DEFAULT_RING_SECONDS,
+  DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE,
   DEVICE_STATUS,
   DOBStatus,
@@ -94114,6 +94488,7 @@ function usePersonalEmergencyChainController() {
   ROBOT_CAPABILITIES,
   ROBOT_CLOUD_DOC_CONFIRMATIONS,
   ROBOT_CLOUD_PATHS,
+  ROBOT_CLOUD_TIMEOUT_MS,
   ROBOT_MODULE,
   ROBOT_PERMISSIONS,
   ROBOT_STATUS_NAMES,
@@ -94163,6 +94538,8 @@ function usePersonalEmergencyChainController() {
   VerificationType,
   VisitorSort,
   VisitorStatus,
+  WALL_HEIGHT_M,
+  WALL_THICKNESS_M,
   addressSchema,
   allowedFieldsSite,
   allowedNatures,
@@ -94174,6 +94551,8 @@ function usePersonalEmergencyChainController() {
   attendanceSchema,
   attendanceSettingsSchema,
   buildSelfServiceEmailContext,
+  buildingMapFromRobotMaps,
+  buildingSolids,
   building_level_namespace_collection,
   building_units_namespace_collection,
   buildings_namespace_collection,
@@ -94280,6 +94659,9 @@ function usePersonalEmergencyChainController() {
   isTermsCurrent,
   isTrackingStale,
   isValidTimezone,
+  levelPixelToMetres,
+  levelScale,
+  levelSolids,
   listStaffUserIds,
   liveStatusFor,
   manpowerDesignationsSchema,
@@ -94378,6 +94760,7 @@ function usePersonalEmergencyChainController() {
   robotTier,
   robotTypesVisibleTo,
   rtspUrl,
+  scaleFromMeasurement,
   schema,
   schemaAppSlugNotification,
   schemaApprovedBy,
@@ -94544,6 +94927,7 @@ function usePersonalEmergencyChainController() {
   snapshotEndpoint,
   snapshotRefusalReason,
   staffMayBypass,
+  startRobotTracking,
   startTodaysBookForSite,
   stringifyHidJson,
   stripFacialImageMetadata,
@@ -94795,8 +95179,10 @@ function usePersonalEmergencyChainController() {
   vehicleSchema,
   vehicleViewOf,
   vehicles_namespace_collection,
+  vertexDistancePx,
   visitors_namespace_collection,
   wallConfig,
+  wallsFromOccupancyGrid,
   withLiveLink,
   workOrderSchema,
   work_orders2_namespace_collection,