feat: update analogInputs data in mocks

mocks/scripts/retimeAnalogInputs.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Retime mock chart data so the newest entry is "today" and older entries are shifted accordingly.
+ *
+ * Files handled:
+ * - DIA0.json: high-resolution data with many entries, each having a "t" timestamp.
+ *   Strategy: keep original intervals by computing deltas from the first item and rebase to today's date
+ *   at the time-of-day of the original first item.
+ * - DIA1.json: typically contains only values (no "t"). We skip if no "t" exists.
+ * - DIA2.json: daily aggregation with "t" at 00:00:00. Strategy: set top item to today 00:00:00,
+ *   then each subsequent item to one day earlier.
+ *
+ * Usage:
+ *   node ./mocks/scripts/retimeAnalogInputs.mjs [target]
+ *   target options:
+ *     - all                  -> process all slots under analogInputs
+ *     - <n>                  -> process slot n (e.g., 1 .. 8)
+ *     - <path/to/slotDir>    -> process the given directory containing DIA*.json
+ *   Default: all slots under mocks/device-cgi-simulator/chartsData/analogInputs
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const workspaceRoot = path.resolve(__dirname, "../..");
+
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+
+function formatDate(d) {
+  const yyyy = d.getFullYear();
+  const MM = pad(d.getMonth() + 1);
+  const dd = pad(d.getDate());
+  const hh = pad(d.getHours());
+  const mm = pad(d.getMinutes());
+  const ss = pad(d.getSeconds());
+  return `${yyyy}-${MM}-${dd} ${hh}:${mm}:${ss}`;
+}
+
+function parseDateTime(str) {
+  // Expecting "YYYY-MM-DD HH:mm:ss"
+  // Replace space with 'T' to ensure consistent parsing without timezone conversion.
+  // We treat times as local; constructing a Date with year, month-1, day, hours, mins, secs is safer.
+  const m = str.match(/(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})/);
+  if (!m) return new Date(str);
+  const [, y, mo, d, h, mi, s] = m.map(Number);
+  return new Date(y, mo - 1, d, h, mi, s, 0);
+}
+
+function withTodayDateAndTimeOf(baseTime) {
+  const today = new Date();
+  const d = new Date(
+    today.getFullYear(),
+    today.getMonth(),
+    today.getDate(),
+    baseTime.getHours(),
+    baseTime.getMinutes(),
+    baseTime.getSeconds(),
+    0
+  );
+  return d;
+}
+
+async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+
+async function writeJson(filePath, data) {
+  const content = JSON.stringify(data, null, 2);
+  await fs.writeFile(filePath, content + "\n", "utf-8");
+}
+
+async function retimeDIA0(filePath) {
+  const arr = await readJson(filePath);
+  if (!Array.isArray(arr) || arr.length === 0) return false;
+  if (!("t" in arr[0])) return false;
+
+  // Compute deltas from first item's timestamp
+  const t0 = parseDateTime(arr[0].t);
+  const newBase = withTodayDateAndTimeOf(t0);
+  const t0ms = t0.getTime();
+
+  const updated = arr.map((item) => {
+    if (!item.t) return item; // leave untouched
+    const ti = parseDateTime(item.t).getTime();
+    const delta = t0ms - ti; // ms to subtract from base
+    const newDate = new Date(newBase.getTime() - delta);
+    return { ...item, t: formatDate(newDate) };
+  });
+
+  await writeJson(filePath, updated);
+  return true;
+}
+
+async function retimeDIA2(filePath) {
+  const arr = await readJson(filePath);
+  if (!Array.isArray(arr) || arr.length === 0) return false;
+  if (!("t" in arr[0])) return false;
+
+  const todayMidnight = new Date();
+  todayMidnight.setHours(0, 0, 0, 0);
+
+  const updated = arr.map((item, idx) => {
+    const d = new Date(todayMidnight.getTime() - idx * 24 * 60 * 60 * 1000);
+    return { ...item, t: formatDate(d) };
+  });
+
+  await writeJson(filePath, updated);
+  return true;
+}
+
+async function maybeLogSkip(filePath, reason) {
+  console.log(`[skip] ${path.basename(filePath)}: ${reason}`);
+}
+
+async function processSlotDir(targetDir) {
+  const dia0 = path.join(targetDir, "DIA0.json");
+  const dia1 = path.join(targetDir, "DIA1.json");
+  const dia2 = path.join(targetDir, "DIA2.json");
+
+  // DIA0
+  try {
+    const changed = await retimeDIA0(dia0);
+    if (!changed) await maybeLogSkip(dia0, "no data or no t field");
+    else console.log(`[ok] Updated ${path.basename(dia0)}`);
+  } catch (e) {
+    console.error(`[error] ${path.basename(dia0)}:`, e.message);
+  }
+
+  // DIA1: usually no 't' -> skip gracefully. If it has 't', treat like DIA0 (keep intervals)
+  try {
+    const arr = await readJson(dia1);
+    if (Array.isArray(arr) && arr.length && "t" in arr[0]) {
+      const changed = await retimeDIA0(dia1);
+      if (changed) console.log(`[ok] Updated ${path.basename(dia1)}`);
+      else await maybeLogSkip(dia1, "no data or no t field");
+    } else {
+      await maybeLogSkip(dia1, "no t field present");
+    }
+  } catch (e) {
+    console.error(`[error] ${path.basename(dia1)}:`, e.message);
+  }
+
+  // DIA2
+  try {
+    const changed = await retimeDIA2(dia2);
+    if (!changed) await maybeLogSkip(dia2, "no data or no t field");
+    else console.log(`[ok] Updated ${path.basename(dia2)}`);
+  } catch (e) {
+    console.error(`[error] ${path.basename(dia2)}:`, e.message);
+  }
+}
+
+async function main() {
+  try {
+    const arg = process.argv[2];
+    const analogBase = path.resolve(
+      workspaceRoot,
+      "mocks/device-cgi-simulator/chartsData/analogInputs"
+    );
+
+    let targets = [];
+
+    if (!arg || arg === "all") {
+      // process all numeric slot directories under analogInputs
+      const entries = await fs.readdir(analogBase, { withFileTypes: true });
+      targets = entries
+        .filter((e) => e.isDirectory() && /^\d+$/.test(e.name))
+        .map((e) => path.join(analogBase, e.name))
+        .sort((a, b) => Number(path.basename(a)) - Number(path.basename(b)));
+    } else if (/^\d+$/.test(arg)) {
+      targets = [path.join(analogBase, arg)];
+    } else {
+      // treat as a path
+      const p = path.isAbsolute(arg) ? arg : path.resolve(workspaceRoot, arg);
+      targets = [p];
+    }
+
+    if (!targets.length) {
+      console.log("No analog input slot directories found.");
+      return;
+    }
+
+    for (const dir of targets) {
+      try {
+        await fs.access(dir);
+      } catch {
+        console.log(`[skip] ${dir}: not found`);
+        continue;
+      }
+      console.log(`\n=== Processing slot: ${path.basename(dir)} ===`);
+      await processSlotDir(dir);
+    }
+  } catch (err) {
+    console.error("Failed to retime analog input data:", err);
+    process.exitCode = 1;
+  }
+}
+
+await main();