@7365admin1/core 3.83.0 → 3.85.0

package/dist/index.mjs

@@ -59696,6 +59696,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
 import { BadRequestError as BadRequestError134, NotFoundError as NotFoundError43 } from "@7365admin1/node-server-utils";
 
@@ -60076,6 +60249,145 @@ function registerOunitechBrand() {
   });
 }
 
+// src/services/robot-tracking.service.ts
+import axios4 from "axios";
+async function openWithAxios(url, body) {
+  const response = await axios4.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
 import Joi76 from "joi";
 import { BadRequestError as BadRequestError135, logger as logger106 } from "@7365admin1/node-server-utils";
@@ -60154,7 +60466,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
@@ -80780,7 +81140,7 @@ import {
 } from "@7365admin1/node-server-utils";
 
 // src/utils/hrmlabs-attendance.util.ts
-import axios4 from "axios";
+import axios5 from "axios";
 import moment8 from "moment-timezone";
 var default_early_checkIn = 4;
 async function hrmLabsAuthentication({
@@ -80789,7 +81149,7 @@ async function hrmLabsAuthentication({
   password,
   domain
 }) {
-  const res = await axios4.post(
+  const res = await axios5.post(
     authUrl,
     {
       grant_type: "password",
@@ -80819,7 +81179,7 @@ async function fetchAttendanceData({
   search
 }) {
   try {
-    const res = await axios4.post(
+    const res = await axios5.post(
       attendanceUrl,
       {
         start: startDate,
@@ -81019,7 +81379,7 @@ async function fetchSites({ siteUrl, token }) {
   do {
     try {
       attempt++;
-      const res = await axios4.get(siteUrl, {
+      const res = await axios5.get(siteUrl, {
         headers: { Authorization: `Bearer ${token}` },
         timeout: 15e3
       });
@@ -84667,7 +85027,7 @@ async function manpowerEvents(io) {
 }
 
 // src/services/reddot-payment.service.ts
-import axios5 from "axios";
+import axios6 from "axios";
 
 // src/utils/payment-signature.util.ts
 import * as crypto9 from "crypto";
@@ -85309,7 +85669,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_PAYMENT;
-      const response = await axios5.post(url, dataString, { headers });
+      const response = await axios6.post(url, dataString, { headers });
       const result = response.data;
       return result;
     } catch (error) {
@@ -85343,7 +85703,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_ENQUIRY;
-      const response = await axios5.post(url, dataString, { headers });
+      const response = await axios6.post(url, dataString, { headers });
       const result = response.data;
       const transactionId = result.transaction_id;
       const amount = result.request_amount || 0;
@@ -93990,6 +94350,7 @@ export {
   ConsoleAuditAction,
   ConsoleAuditTarget,
   DEFAULT_RING_SECONDS,
+  DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE,
   DEVICE_STATUS,
   DOBStatus,
@@ -94160,6 +94521,7 @@ export {
   ROBOT_CAPABILITIES,
   ROBOT_CLOUD_DOC_CONFIRMATIONS,
   ROBOT_CLOUD_PATHS,
+  ROBOT_CLOUD_TIMEOUT_MS,
   ROBOT_MODULE,
   ROBOT_PERMISSIONS,
   ROBOT_STATUS_NAMES,
@@ -94209,6 +94571,8 @@ export {
   VerificationType,
   VisitorSort,
   VisitorStatus,
+  WALL_HEIGHT_M,
+  WALL_THICKNESS_M,
   addressSchema,
   allowedFieldsSite,
   allowedNatures,
@@ -94220,6 +94584,8 @@ export {
   attendanceSchema,
   attendanceSettingsSchema,
   buildSelfServiceEmailContext,
+  buildingMapFromRobotMaps,
+  buildingSolids,
   building_level_namespace_collection,
   building_units_namespace_collection,
   buildings_namespace_collection,
@@ -94326,6 +94692,9 @@ export {
   isTermsCurrent,
   isTrackingStale,
   isValidTimezone,
+  levelPixelToMetres,
+  levelScale,
+  levelSolids,
   listStaffUserIds,
   liveStatusFor,
   manpowerDesignationsSchema,
@@ -94424,6 +94793,7 @@ export {
   robotTier,
   robotTypesVisibleTo,
   rtspUrl,
+  scaleFromMeasurement,
   schema,
   schemaAppSlugNotification,
   schemaApprovedBy,
@@ -94590,6 +94960,7 @@ export {
   snapshotEndpoint,
   snapshotRefusalReason,
   staffMayBypass,
+  startRobotTracking,
   startTodaysBookForSite,
   stringifyHidJson,
   stripFacialImageMetadata,
@@ -94841,8 +95212,10 @@ export {
   vehicleSchema,
   vehicleViewOf,
   vehicles_namespace_collection,
+  vertexDistancePx,
   visitors_namespace_collection,
   wallConfig,
+  wallsFromOccupancyGrid,
   withLiveLink,
   workOrderSchema,
   work_orders2_namespace_collection,