@7365admin1/core 3.131.0 → 3.132.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/core",
   "license": "MIT",
-  "version": "3.131.0",
+  "version": "3.132.0",
   "author": "7365admin1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/test/ounitech-api-2025-10.test.mjs

@@ -6,7 +6,7 @@ import { after, before, test } from "node:test";
 
 import { ROBOT_CLOUD_PATHS, OUNITECH_TIMESTAMP_SKEW_S } from "./.build/utils/robot-cloud.util.mjs";
 import { RobotCloudError, useRobotCloudService } from "./.build/services/robot-cloud.service.mjs";
-import { createOunitechAdapter, ounitechRobotFromHomeRow, ounitechFault } from "./.build/services/ounitech.adapter.mjs";
+import { createOunitechAdapter, ounitechRobotFromHomeRow, ounitechFault, ounitechJobWords, OUNITECH_FRESH_MS } from "./.build/services/ounitech.adapter.mjs";
 
 /* --------------------------------------------------------------------------
  * Ounitech "Robot Cloud API Document (2025.10.22)", received 2026-09-28.
@@ -53,8 +53,45 @@ const ROWS = [
     robotId: 427, robotSn: "ERROR1", modelCode: "Q3W", sceneId: 438, floorNo: 2,
     robotState: { x: 0, y: 0, theta: 0, statusFlag: 7, properties: [prop("battery-percent", 55)] },
   },
+  // Prod 2026-09-30: the list said offline while the live state (below) answered Idle.
+  {
+    robotId: 430, robotSn: "LISTOFFLINE", modelCode: "Q3", sceneId: 438, floorNo: 3,
+    robotState: { x: 0, y: 0, theta: 0, statusFlag: 99, properties: [prop("battery-percent", 0)] },
+  },
 ];
 
+/**
+ * The shape of get-robot-state-v2.0's reply for robot 424 (Q3, 4G) on prod,
+ * 2026-09-30 ~02:04Z, while our UI showed it offline. Readings as the cloud
+ * sends them: every value a string, labels Chinese. No credential in it.
+ */
+const RECORDED_UPDATE_ON = Date.parse("2026-09-30T02:04:08Z");
+const s = (key, value, type = "string", unit = "") => ({ key, name: "", type, value: String(value), unit });
+const recordedState = (robotId, updateOn = RECORDED_UPDATE_ON) => ({
+  robotId,
+  updateOn,
+  x: 0.4213, y: -1.0875, theta: 1.5708,
+  statusFlag: 1,
+  statusName: "待机",
+  subStatusFlag: 0,
+  subStatusName: "",
+  rtFaultList: [],
+  properties: [
+    s("battery-percent", 100, "int", "%"),
+    s("left-battery-percent", 100, "int", "%"),
+    s("right-battery-percent", 100, "int", "%"),
+    s("clean-water", 62, "int", "%"),
+    s("dirty-water", 8, "int", "%"),
+    s("job", "已结束"),
+    s("status", "待机"),
+    s("top-cover", 1, "int"),
+    s("clean-water-tank", 1, "int"),
+    s("waste-water-tank", 1, "int"),
+    s("collision-left", 0, "int"),
+    s("collision-right", 0, "int"),
+  ],
+});
+
 let server;
 let base;
 const seen = [];
@@ -95,6 +132,8 @@ before(async () => {
         case ROBOT_CLOUD_PATHS.robotList:
           return res.end(JSON.stringify({ robotList: [] })); // chapter 1: owner-bound only
         case ROBOT_CLOUD_PATHS.robotState:
+          if (body.robotId === 430 || body.robotId === 424) return ok({ robotState: recordedState(body.robotId, Date.now() - 8000) });
+          if (body.robotId === 425) return ok({ robotState: { robotId: 425, updateOn: Date.now() - 3_600_000, statusFlag: 99, properties: [] } });
           return ok({ robotState: { robotId: body.robotId, statusFlag: 7, rtFaultList: [{ errCode: "621", errMsg: "Right wheel driver reset" }] } });
         case ROBOT_CLOUD_PATHS.floorMaps:
           return ok({
@@ -131,9 +170,11 @@ const adapter = (opts = {}) => createOunitechAdapter({ appid: APPID, secret: SEC
 test("the robot list is the chapter-6 list, signed for its own path, credentials in the body", async () => {
   seen.length = 0;
   const robots = await adapter().listRobots();
-  assert.deepEqual(robots.map((r) => r.robotSn), ["F8FCA9A1B1C4C", "OFFLINE1", "WORKING1", "ERROR1"]);
-  assert.equal(seen.length, 1);
+  assert.deepEqual(robots.map((r) => r.robotSn), ["F8FCA9A1B1C4C", "OFFLINE1", "WORKING1", "ERROR1", "LISTOFFLINE"]);
   assert.equal(seen[0].path, "/portal/home/get-robot-list");
+  // Live state only for the rows the list can't vouch for (99, 7) - never for a known-good status.
+  assert.deepEqual(seen.slice(1).map((x) => x.body.robotId).sort(), [425, 427, 430]);
+  assert.ok(seen.slice(1).every((x) => x.path === ROBOT_CLOUD_PATHS.robotState));
   assert.deepEqual(Object.keys(seen[0].body).sort(), ["appid", "sign", "timestamp"]);
   assert.equal(JSON.stringify(seen).includes(SECRET), false);
 });
@@ -219,7 +260,7 @@ test("refusals are the host's own plain words, with the credential hint", async
 
 test("within the 300 s window is accepted", async () => {
   const early = adapter({ now: () => new Date(Date.now() - (OUNITECH_TIMESTAMP_SKEW_S - 30) * 1000) });
-  assert.equal((await early.listRobots()).length, 4);
+  assert.equal((await early.listRobots()).length, 5);
 });
 
 test("diagnose: every read answered, chapter 1 shows why the old list was empty, never a command", async () => {
@@ -240,3 +281,106 @@ test("row mapping holds on its own (pure)", () => {
   assert.equal(r.floorKnown, false);
   assert.equal(ounitechRobotFromHomeRow({ robotSn: "Y" }).mode, "UNAVAILABLE");
 });
+
+test("prod 2026-09-30: list says offline, live state answers Idle -> Online / Idle / battery 100 (fleet, detail, Diagnose)", async () => {
+  const a = adapter();
+  const listed = (await a.listRobots()).find((r) => r.robotSn === "LISTOFFLINE");
+  const detail = await a.getRobot("LISTOFFLINE");
+  for (const r of [listed, detail]) {
+    assert.equal(r.online, true);
+    assert.equal(r.mode, "IDLE");
+    assert.equal(r.statusName, "Idle");
+    assert.equal(r.batteryPercent, 100);
+    assert.deepEqual(r.position, { x: 0.4213, y: -1.0875, theta: 1.5708 });
+    assert.equal(r.fault, undefined, "empty rtFaultList is no fault");
+  }
+  const steps = await a.diagnose("LISTOFFLINE");
+  const live = steps.find((x) => x.step.startsWith("live state")).data;
+  assert.equal(live.online, true);
+  assert.equal(live.status, "Idle");
+  assert.equal(live.job, "job finished");
+  assert.equal(live.battery, 100);
+  assert.equal(live.cleanWater, 62);
+  assert.equal(live.dirtyWater, 8);
+  assert.equal(live.fault, null);
+});
+
+test("live state mapping, recorded reply (pure)", () => {
+  const row = { robotId: 424, robotSn: "F8FCA9A1B1C4C", modelCode: "Q3", floorNo: 3, robotState: { statusFlag: 99, properties: [prop("battery-percent", 0)] } };
+  const now = RECORDED_UPDATE_ON + 20_000;
+  const r = ounitechRobotFromHomeRow(row, recordedState(424), now);
+  assert.equal(r.online, true);
+  assert.equal(r.statusName, "Idle");
+  assert.equal(r.batteryPercent, 100);
+  assert.equal(ounitechJobWords(recordedState(424)), "job finished");
+
+  // statusFlag as a numeric string
+  assert.equal(ounitechRobotFromHomeRow({ robotSn: "S", robotState: { statusFlag: "1" } }, null, now).mode, "IDLE");
+  // no statusFlag: the Chinese status reading supplies it
+  const noFlag = { ...recordedState(424), statusFlag: undefined };
+  assert.equal(ounitechRobotFromHomeRow({ robotSn: "C" }, noFlag, now).statusName, "Idle");
+  const charging = { properties: [s("status", "充电中")] };
+  assert.equal(ounitechRobotFromHomeRow({ robotSn: "C" }, charging, now).statusName, "Charging");
+  // no status at all: a fresh updateOn is online, a stale one is not
+  const bare = (age) => ({ updateOn: now - age, properties: [s("battery-percent", 70, "int", "%")] });
+  const fresh = ounitechRobotFromHomeRow({ robotSn: "F" }, bare(60_000), now);
+  assert.equal(fresh.online, true);
+  assert.equal(fresh.mode, "UNAVAILABLE", "never dispatchable without a known status");
+  assert.equal(fresh.batteryPercent, 70);
+  const stale = ounitechRobotFromHomeRow({ robotSn: "F" }, bare(OUNITECH_FRESH_MS + 1000), now);
+  assert.equal(stale.online, false);
+  assert.equal(stale.statusName, "Unknown");
+  assert.equal(stale.batteryPercent, null);
+  // the live state saying 99 beats a fresh-looking list row
+  const off = ounitechRobotFromHomeRow({ robotSn: "O", robotState: { statusFlag: 1 } }, { statusFlag: 99, updateOn: now }, now);
+  assert.equal(off.online, false);
+  assert.equal(off.statusName, "Offline");
+  // a fault listed live is named even without status 7
+  const faulty = ounitechRobotFromHomeRow({ robotSn: "E" }, { statusFlag: 1, rtFaultList: [{ errCode: "302", errMsg: "Clean water tank empty" }] }, now);
+  assert.deepEqual(faulty.fault, { code: "302", message: "Clean water tank empty" });
+});
+
+test("cleaning readings: water levels, tanks and covers, job progress only while cleaning (pure)", async () => {
+  const { ounitechCleaning } = await import("./.build/services/ounitech.adapter.mjs");
+  const now = RECORDED_UPDATE_ON + 20_000;
+  const row = { robotId: 424, robotSn: "F8FCA9A1B1C4C", modelCode: "Q3", robotState: { statusFlag: 99 } };
+  // The recorded prod reply: idle, clean 62 %, dirty 8 %, every tank/cover fitted.
+  assert.deepEqual(ounitechRobotFromHomeRow(row, recordedState(424), now).cleaning, {
+    cleanWater: { level: "medium", percent: 62 },
+    dirtyWater: { level: "low", percent: 8 },
+    parts: [
+      { part: "top cover", ok: true },
+      { part: "clean-water tank", ok: true },
+      { part: "dirty-water tank", ok: true },
+    ],
+    job: null,
+  });
+  const st = (props) => ({ properties: props.map(([k, v]) => s(k, v)) });
+  // Cleaning: this job's % and area; low clean water, full dirty water, cover open.
+  const c = ounitechCleaning(st([["clean-water", 12], ["dirty-water", 91], ["top-cover", "false"], ["dust-box", "true"], ["acc-percent", 40], ["acc-area", "120.46"], ["count-area", "300"]]), true);
+  assert.deepEqual(c, {
+    cleanWater: { level: "low", percent: 12 },
+    dirtyWater: { level: "high", percent: 91 },
+    parts: [{ part: "top cover", ok: false }, { part: "dust box", ok: true }],
+    job: { percent: 40, areaDone: 120.5, areaPlanned: 300 },
+  });
+  // Not cleaning: no job line even with acc-* readings.
+  assert.equal(ounitechCleaning(st([["acc-percent", 40]]), false), null);
+  // No % sent: the robot's own level word.
+  assert.deepEqual(ounitechCleaning(st([["clean-water-level", "中"], ["dirty-water-level", "高"]]), false).dirtyWater, { level: "high", percent: null });
+  // Nothing reported: null, never guessed.
+  assert.equal(ounitechCleaning({ properties: [] }, true), null);
+  // Job % falls back to the list's taskState.
+  assert.deepEqual(ounitechCleaning({ properties: [] }, true, 55.4).job, { percent: 55, areaDone: null, areaPlanned: null });
+  // Offline: nothing.
+  assert.equal(ounitechRobotFromHomeRow(row, { ...recordedState(424), statusFlag: 99 }, now).cleaning, undefined);
+});
+
+test("cleaning readings reach the fleet state (waterTanks brands only)", async () => {
+  const { fleetStateItem } = await import("./.build/services/robot-fleet.service.mjs");
+  const cleaning = { cleanWater: { level: "low", percent: 10 }, dirtyWater: null, parts: [], job: null };
+  assert.deepEqual(fleetStateItem("x", { online: true, cleaning }).cleaning, cleaning);
+  assert.equal(fleetStateItem("x", { online: true }).cleaning, null);
+  const r = await adapter().getRobot("LISTOFFLINE");
+  assert.equal(r.cleaning.cleanWater.percent, 62);
+});