node-red-contrib-alarm-ultimate 0.1.1 → 0.1.3

package/nodes/AlarmUltimateInputAdapter.js

@@ -0,0 +1,188 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const vm = require("vm");
+
+function safeReadDir(dirPath) {
+  try {
+    return fs.readdirSync(dirPath);
+  } catch (_err) {
+    return [];
+  }
+}
+
+function loadBuiltinPresets() {
+  const presetsDir = path.join(__dirname, "presets", "input-adapter");
+  const files = safeReadDir(presetsDir)
+    .filter((f) => f.endsWith(".js"))
+    .sort((a, b) => a.localeCompare(b));
+
+  const presets = [];
+  for (const file of files) {
+    const fullPath = path.join(presetsDir, file);
+    try {
+      // eslint-disable-next-line global-require, import/no-dynamic-require
+      const mod = require(fullPath);
+      const preset = mod && typeof mod === "object" ? mod : null;
+      if (!preset) continue;
+      if (typeof preset.id !== "string" || preset.id.trim().length === 0) continue;
+      if (typeof preset.name !== "string" || preset.name.trim().length === 0) continue;
+      if (typeof preset.code !== "string" || preset.code.trim().length === 0) continue;
+      presets.push({
+        id: preset.id.trim(),
+        name: preset.name.trim(),
+        description: typeof preset.description === "string" ? preset.description.trim() : "",
+        code: preset.code,
+      });
+    } catch (_err) {
+      // ignore broken preset files
+    }
+  }
+  return presets;
+}
+
+function buildContextApi(node) {
+  const nodeCtx = node.context();
+  const flowCtx = node.context().flow;
+  const globalCtx = node.context().global;
+
+  function wrap(ctx) {
+    return {
+      get: (key) => ctx.get(key),
+      set: (key, value) => ctx.set(key, value),
+    };
+  }
+
+  return {
+    node: wrap(nodeCtx),
+    flow: wrap(flowCtx),
+    global: wrap(globalCtx),
+  };
+}
+
+module.exports = function (RED) {
+  const builtins = loadBuiltinPresets();
+  const builtinById = new Map(builtins.map((p) => [p.id, p]));
+
+  if (RED && RED.httpAdmin && typeof RED.httpAdmin.get === "function") {
+    const needsRead =
+      RED.auth && typeof RED.auth.needsPermission === "function"
+        ? RED.auth.needsPermission("AlarmUltimateInputAdapter.read")
+        : (req, res, next) => next();
+
+    RED.httpAdmin.get("/alarm-ultimate/input-adapter/presets", needsRead, (_req, res) => {
+      res.json({ presets: builtins });
+    });
+  }
+
+  function AlarmUltimateInputAdapter(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const REDUtil = RED.util;
+
+    const presetSource = config.presetSource === "user" ? "user" : "builtin";
+    const presetId =
+      typeof config.presetId === "string" && config.presetId.trim().length > 0
+        ? config.presetId.trim()
+        : "passthrough";
+    const userCode = typeof config.userCode === "string" ? config.userCode : "";
+
+    const preset =
+      presetSource === "user"
+        ? {
+            id: "custom",
+            name: "Custom",
+            code: userCode,
+          }
+        : builtinById.get(presetId);
+    const sandbox = {
+      msg: null,
+      context: buildContextApi(node),
+      log: (...args) => node.log(args.map(String).join(" ")),
+      warn: (...args) => node.warn(args.map(String).join(" ")),
+      error: (...args) => node.error(args.map(String).join(" ")),
+      fn: null,
+      result: undefined,
+    };
+    const vmContext = vm.createContext(sandbox);
+
+    function compile(code) {
+      const body = String(code || "").trim();
+      if (!body) return null;
+      const fnScript = new vm.Script(
+        `fn = (function (msg, context, log, warn, error) { "use strict";\n${body}\n});`,
+      );
+      fnScript.runInContext(vmContext, { timeout: 250 });
+      const callScript = new vm.Script(
+        `result = fn(msg, context, log, warn, error);`,
+      );
+      return { callScript };
+    }
+
+    let compiled = null;
+    try {
+      if (!preset || typeof preset.code !== "string" || preset.code.trim().length === 0) {
+        node.status({
+          fill: "red",
+          shape: "ring",
+          text: presetSource === "user" ? "missing user code" : "preset not found",
+        });
+      } else {
+        compiled = compile(preset.code);
+        node.status({
+          fill: "green",
+          shape: "dot",
+          text: presetSource === "user" ? "preset: custom" : `preset: ${preset.name}`,
+        });
+      }
+    } catch (err) {
+      node.status({ fill: "red", shape: "dot", text: "invalid preset" });
+      node.error(err);
+    }
+
+    node.on("input", (msg, send, done) => {
+      const doSend = send || ((m) => node.send(m));
+      if (!compiled) {
+        if (done) done();
+        return;
+      }
+
+      try {
+        sandbox.msg = msg ? REDUtil.cloneMessage(msg) : {};
+        sandbox.result = undefined;
+        compiled.callScript.runInContext(vmContext, { timeout: 100 });
+        const out = sandbox.result;
+
+        if (out === undefined || out === null) {
+          if (done) done();
+          return;
+        }
+
+        if (Array.isArray(out)) {
+          out.filter(Boolean).forEach((m, idx) => {
+            if (idx === 0) doSend(m);
+            else doSend(REDUtil.cloneMessage(m));
+          });
+          if (done) done();
+          return;
+        }
+
+        if (typeof out === "object") {
+          doSend(out);
+          if (done) done();
+          return;
+        }
+
+        doSend({ ...(msg || {}), payload: out });
+        if (done) done();
+      } catch (err) {
+        node.status({ fill: "red", shape: "dot", text: "transform error" });
+        node.error(err, msg);
+        if (done) done(err);
+      }
+    });
+  }
+
+  RED.nodes.registerType("AlarmUltimateInputAdapter", AlarmUltimateInputAdapter);
+};

package/nodes/AlarmUltimateZone.html

@@ -112,7 +112,7 @@
 
   <div class="form-row">
     <label for="node-input-topic"><i class="fa fa-tag"></i> Topic</label>
-    <input type="text" id="node-input-topic" placeholder="(default: &lt;controlTopic&gt;/zone/&lt;zoneId&gt;)" />
+    <input type="text" id="node-input-topic" placeholder="(default: &lt;controlTopic&gt;/zone/&lt;zoneTopic&gt;)" />
   </div>
 
   <div class="form-row">
@@ -125,7 +125,7 @@
 Emits the state of a single configured zone from a selected **Alarm System Ultimate** node.
 
 - `msg.payload`: `true` when the zone is open/active, otherwise `false`
-- `msg.zone`: `{ id, name?, type? }`
+- `msg.zone`: `{ id, name?, type?, topic? }`
 - `msg.bypassed`: `true|false`
 
 Notes:

package/nodes/AlarmUltimateZone.js

@@ -18,10 +18,13 @@ module.exports = function (RED) {
 
     let lastOpen = null;
 
-    function buildTopic(controlTopic) {
+    function buildTopic(controlTopic, zoneTopic) {
       if (configuredTopic) return configuredTopic;
       const base = typeof controlTopic === 'string' && controlTopic.trim().length > 0 ? controlTopic.trim() : 'alarm';
-      const z = zoneId || 'zone';
+      const z =
+        typeof zoneTopic === 'string' && zoneTopic.trim().length > 0
+          ? zoneTopic.trim()
+          : zoneId || 'zone';
       return `${base}/zone/${z}`;
     }
 
@@ -41,7 +44,7 @@ module.exports = function (RED) {
       });
 
       const msg = {
-        topic: buildTopic(evt && evt.controlTopic),
+        topic: buildTopic(evt && evt.controlTopic, zoneTopic),
         payload: open,
         alarmId: evt ? evt.alarmId : alarmId,
         zone: evt && evt.zone ? evt.zone : { id: zoneId || null },

package/nodes/presets/input-adapter/ax-pro-hikvision-ultimate.js

@@ -0,0 +1,34 @@
+module.exports = {
+  id: "axpro_hikvision_ultimate",
+  name: "AX Pro (Hikvision Ultimate)",
+  description:
+    "Maps payload.zoneUpdate from Hikvision-Ultimate AX Pro nodes to {topic,payload} for Alarm zones.",
+  code: `
+if (!msg || typeof msg !== "object") return;
+const zone = msg.payload && msg.payload.zoneUpdate ? msg.payload.zoneUpdate : null;
+if (!zone || typeof zone !== "object") return;
+
+const rawTopic =
+  typeof zone.name === "string" && zone.name.trim()
+    ? zone.name.trim()
+    : zone.id !== undefined && zone.id !== null
+      ? String(zone.id)
+      : "";
+if (!rawTopic) return;
+
+let open;
+if (typeof zone.magnetOpenStatus === "boolean") {
+  open = zone.magnetOpenStatus;
+} else if (typeof zone.alarm === "boolean") {
+  open = zone.alarm;
+} else if (typeof zone.sensorStatus === "string") {
+  const v = zone.sensorStatus.trim().toLowerCase();
+  open = v !== "normal" && v !== "closed" && v !== "ok";
+} else {
+  return;
+}
+
+return { topic: rawTopic, payload: open, zoneUpdate: zone };
+`.trim(),
+};
+

package/nodes/presets/input-adapter/boolean-from-payload.js

@@ -0,0 +1,10 @@
+module.exports = {
+  id: "boolean_from_payload",
+  name: "Boolean from payload",
+  description: "Copies msg.topic and converts msg.payload to boolean.",
+  code: `
+if (typeof msg !== "object" || msg === null) return;
+return { topic: msg.topic, payload: !!msg.payload };
+`.trim(),
+};
+

package/nodes/presets/input-adapter/ha-on-off.js

@@ -0,0 +1,24 @@
+module.exports = {
+  id: "home_assistant_on_off",
+  name: "Home Assistant on/off",
+  description: 'Converts msg.payload "on"/"off" (or boolean) to boolean payload.',
+  code: `
+if (!msg || typeof msg !== "object") return;
+const topic = msg.topic;
+const value = msg.payload;
+let b;
+if (typeof value === "boolean") b = value;
+else if (typeof value === "string") {
+  const v = value.trim().toLowerCase();
+  if (v === "on" || v === "open" || v === "true" || v === "1") b = true;
+  else if (v === "off" || v === "closed" || v === "false" || v === "0") b = false;
+  else return;
+} else if (typeof value === "number") {
+  b = value !== 0;
+} else {
+  return;
+}
+return { topic, payload: b };
+`.trim(),
+};
+

package/nodes/presets/input-adapter/knx-ultimate.js

@@ -0,0 +1,29 @@
+module.exports = {
+  id: "knx_ultimate",
+  name: "KNX Ultimate",
+  description: "Uses knx.destination (fallback msg.topic) and converts payload to boolean.",
+  code: `
+if (!msg || typeof msg !== "object") return;
+const topic =
+  msg.knx && typeof msg.knx.destination === "string" && msg.knx.destination.trim()
+    ? msg.knx.destination.trim()
+    : msg.topic;
+if (typeof topic !== "string" || !topic.trim()) return;
+
+const value = msg.payload;
+let b;
+if (typeof value === "boolean") b = value;
+else if (typeof value === "number") b = value !== 0;
+else if (typeof value === "string") {
+  const v = value.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "on" || v === "open") b = true;
+  else if (v === "0" || v === "false" || v === "off" || v === "closed") b = false;
+  else return;
+} else {
+  return;
+}
+
+return { topic, payload: b };
+`.trim(),
+};
+

package/nodes/presets/input-adapter/passthrough.js

@@ -0,0 +1,7 @@
+module.exports = {
+  id: "passthrough",
+  name: "Passthrough",
+  description: "Emit the incoming msg unchanged.",
+  code: `return msg;`,
+};
+

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "node-red-contrib-alarm-ultimate",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Alarm System node for Node-RED.",
-  "author": "Supergiovane (https://github.com/Supergiovane)",
+  "author": "MAssimo Saccani (https://github.com/Supergiovane)",
   "license": "MIT",
   "keywords": [
     "node-red",
@@ -11,11 +11,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/Supergiovane/node-red-contrib-alarm-ultimate"
+    "url": "https://github.com/Supergiovane/node-red-contrib-alarm-ultimate.git"
   },
   "node-red": {
     "nodes": {
       "AlarmSystemUltimate": "nodes/AlarmSystemUltimate.js",
+      "AlarmUltimateInputAdapter": "nodes/AlarmUltimateInputAdapter.js",
       "AlarmUltimateState": "nodes/AlarmUltimateState.js",
       "AlarmUltimateZone": "nodes/AlarmUltimateZone.js",
       "AlarmUltimateSiren": "nodes/AlarmUltimateSiren.js"

package/test/alarm-system.spec.js

@@ -467,4 +467,116 @@ describe('AlarmSystemUltimate node', function () {
       })
       .catch(done);
   });
+
+  it('emits zone open/close events while disarmed', function (done) {
+    const flowId = 'alarm-zone-events';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm-zone-events' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        requireCodeForDisarm: false,
+        zones: '{"id":"front","name":"Front","topic":"sensor/frontdoor","type":"perimeter","entry":false}',
+        wires: [[], [], [], [], ['zoneEvents']],
+      },
+      { id: 'zoneEvents', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow)
+      .then(() => {
+        const alarm = helper.getNode('alarm');
+        const zoneEvents = helper.getNode('zoneEvents');
+
+        const seen = [];
+        zoneEvents.on('input', (msg) => {
+          seen.push(msg);
+        });
+
+        // Default mode is disarmed. We should still see zone_open/zone_close.
+        alarm.receive({ topic: 'sensor/frontdoor', payload: true });
+        setTimeout(() => {
+          alarm.receive({ topic: 'sensor/frontdoor', payload: false });
+        }, 30);
+
+        setTimeout(() => {
+          try {
+            const events = seen.map((m) => m.event).filter(Boolean);
+            expect(events).to.include('zone_open');
+            expect(events).to.include('zone_close');
+            const openEvt = seen.find((m) => m && m.event === 'zone_open');
+            expect(openEvt).to.be.an('object');
+            expect(openEvt.payload).to.be.an('object');
+            expect(openEvt.payload.zone).to.be.an('object');
+            expect(openEvt.payload.zone.topic).to.equal('sensor/frontdoor');
+            done();
+          } catch (err) {
+            done(err);
+          }
+        }, 120);
+      })
+      .catch(done);
+  });
+
+  it('syncs arm/disarm to other Alarm nodes', function (done) {
+    const flowId = 'alarm-sync';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm-sync' },
+      {
+        id: 'alarmA',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        name: 'Alarm A',
+        controlTopic: 'alarmA',
+        exitDelaySeconds: 0,
+        requireCodeForDisarm: false,
+        syncTargets: JSON.stringify({
+          alarmB: { onArm: 'arm', onDisarm: 'disarm' },
+        }),
+        wires: [['aEvents']],
+      },
+      { id: 'aEvents', type: 'helper', z: flowId },
+      {
+        id: 'alarmB',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        name: 'Alarm B',
+        controlTopic: 'alarmB',
+        exitDelaySeconds: 0,
+        requireCodeForDisarm: false,
+        wires: [['bEvents']],
+      },
+      { id: 'bEvents', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow)
+      .then(() => {
+        const alarmA = helper.getNode('alarmA');
+        const bEvents = helper.getNode('bEvents');
+
+        const seenB = [];
+        bEvents.on('input', (msg) => {
+          if (msg && typeof msg.event === 'string') {
+            seenB.push(msg.event);
+          }
+        });
+
+        alarmA.receive({ topic: 'alarmA', command: 'arm' });
+        setTimeout(() => {
+          alarmA.receive({ topic: 'alarmA', command: 'disarm' });
+        }, 60);
+
+        setTimeout(() => {
+          try {
+            expect(seenB).to.include('armed');
+            expect(seenB).to.include('disarmed');
+            done();
+          } catch (err) {
+            done(err);
+          }
+        }, 250);
+      })
+      .catch(done);
+  });
 });