@7365admin1/core 3.84.0 → 3.85.0

package/dist/index.mjs

@@ -60249,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";
@@ -60327,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
@@ -80953,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({
@@ -80962,7 +81149,7 @@ async function hrmLabsAuthentication({
   password,
   domain
 }) {
-  const res = await axios4.post(
+  const res = await axios5.post(
     authUrl,
     {
       grant_type: "password",
@@ -80992,7 +81179,7 @@ async function fetchAttendanceData({
   search
 }) {
   try {
-    const res = await axios4.post(
+    const res = await axios5.post(
       attendanceUrl,
       {
         start: startDate,
@@ -81192,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
       });
@@ -84840,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";
@@ -85482,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) {
@@ -85516,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;
@@ -94334,6 +94521,7 @@ export {
   ROBOT_CAPABILITIES,
   ROBOT_CLOUD_DOC_CONFIRMATIONS,
   ROBOT_CLOUD_PATHS,
+  ROBOT_CLOUD_TIMEOUT_MS,
   ROBOT_MODULE,
   ROBOT_PERMISSIONS,
   ROBOT_STATUS_NAMES,
@@ -94772,6 +94960,7 @@ export {
   snapshotEndpoint,
   snapshotRefusalReason,
   staffMayBypass,
+  startRobotTracking,
   startTodaysBookForSite,
   stringifyHidJson,
   stripFacialImageMetadata,