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

package/nodes/AlarmUltimateInputAdapter.html

@@ -0,0 +1,304 @@
+<script type="text/javascript">
+  RED.nodes.registerType("AlarmUltimateInputAdapter", {
+    category: "Alarm Ultimate",
+    color: "#A8DADC",
+    defaults: {
+      name: { value: "" },
+      presetSource: { value: "builtin" },
+      presetId: { value: "passthrough" },
+      userCode: { value: "return msg;", required: false },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "alarm-ultimate.svg",
+    label: function () {
+      return this.name || "Input Adapter";
+    },
+    paletteLabel: function () {
+      return "Input Adapter";
+    },
+    oneditprepare: function () {
+      const self = this;
+      const els = {
+        presetSource: $("#node-input-presetSource"),
+        presetId: $("#node-input-presetId"),
+        builtinPreset: $("#node-input-builtinPreset"),
+        builtinInfo: $("#node-input-builtinInfo"),
+        userCode: $("#node-input-userCode"),
+      };
+
+      let builtinPresets = [];
+      let editor = null;
+      let userCodeCache = String(self.userCode || "return msg;");
+      let builtinIdCache = String(self.presetId || "passthrough");
+
+      function refreshBuiltinSelect() {
+        els.builtinPreset.empty();
+        builtinPresets.forEach((p) => {
+          els.builtinPreset.append(
+            $("<option></option>").attr("value", p.id).text(p.name),
+          );
+        });
+      }
+
+      function builtinExists(id) {
+        const target = String(id || "").trim();
+        if (!target) return false;
+        return builtinPresets.some((p) => p && p.id === target);
+      }
+
+      function setMode(mode) {
+        const m = mode === "user" ? "user" : "builtin";
+        els.presetSource.val(m);
+        $("#builtin-row").toggle(m === "builtin");
+      }
+
+      function setBuiltinInfo(presetId) {
+        const p = builtinPresets.find((x) => x.id === presetId);
+        if (!p) {
+          els.builtinInfo.text("");
+          return;
+        }
+        const desc = p.description ? ` — ${p.description}` : "";
+        els.builtinInfo.text(`${p.name}${desc}`);
+      }
+
+      function getSelectedBuiltinPreset() {
+        const id = String(els.builtinPreset.val() || "").trim();
+        return builtinPresets.find((p) => p && p.id === id) || null;
+      }
+
+      function applyBuiltinSelection(desiredId) {
+        let id = String(desiredId || "").trim();
+        if (!builtinExists(id)) {
+          id = builtinExists(builtinIdCache) ? builtinIdCache : "passthrough";
+        }
+        if (!builtinExists(id) && builtinPresets.length > 0) {
+          id = String(builtinPresets[0].id || "").trim();
+        }
+        if (builtinExists(id)) {
+          els.builtinPreset.val(id);
+          builtinIdCache = id;
+          return id;
+        }
+        return "";
+      }
+
+      function updateEditor() {
+        const src = els.presetSource.val() === "user" ? "user" : "builtin";
+        if (src === "builtin") {
+          const preset = getSelectedBuiltinPreset();
+          editor.setReadOnly(true);
+          editor.setValue(String((preset && preset.code) || ""), -1);
+          return;
+        }
+        editor.setReadOnly(false);
+        editor.setValue(String(userCodeCache || "return msg;"), -1);
+      }
+
+      editor = RED.editor.createEditor({
+        id: "node-input-code-editor",
+        mode: "ace/mode/javascript",
+        value: userCodeCache,
+      });
+      self._inputAdapterEditor = editor;
+
+      function loadBuiltins() {
+        const httpAdminRoot =
+          (RED.settings && RED.settings.httpAdminRoot) || "/";
+        const root = httpAdminRoot.endsWith("/")
+          ? httpAdminRoot
+          : `${httpAdminRoot}/`;
+        $.getJSON(`${root}alarm-ultimate/input-adapter/presets`)
+          .done((data) => {
+            builtinPresets = Array.isArray(data && data.presets)
+              ? data.presets
+              : [];
+            refreshBuiltinSelect();
+            const configured = String(els.presetId.val() || "").trim();
+            const selected = applyBuiltinSelection(configured || builtinIdCache);
+            if (els.presetSource.val() !== "user" && selected) {
+              els.presetId.val(selected);
+              setBuiltinInfo(selected);
+            }
+            updateEditor();
+          })
+          .fail(() => {
+            builtinPresets = [
+              {
+                id: "passthrough",
+                name: "Passthrough",
+                description: "",
+                code: "return msg;",
+              },
+            ];
+            refreshBuiltinSelect();
+            const configured = String(els.presetId.val() || "").trim();
+            const selected = applyBuiltinSelection(configured || builtinIdCache);
+            if (selected) setBuiltinInfo(selected);
+            updateEditor();
+          });
+      }
+
+      // Initialize.
+      loadBuiltins();
+      setMode(els.presetSource.val());
+
+      // Seed selects from stored presetId.
+      const initialSource =
+        els.presetSource.val() === "user" ? "user" : "builtin";
+      const initialId = String(els.presetId.val() || "");
+      if (initialSource === "builtin") {
+        builtinIdCache = String(initialId || builtinIdCache || "passthrough");
+      }
+      if (!els.userCode.val()) {
+        els.userCode.val(userCodeCache);
+      } else {
+        userCodeCache = String(els.userCode.val() || "return msg;");
+      }
+      updateEditor();
+
+      // Events.
+      els.presetSource.on("change", () => {
+        // keep user draft before switching away
+        if (editor && editor.getReadOnly && editor.getReadOnly() === false) {
+          userCodeCache = String(editor.getValue() || "");
+          els.userCode.val(userCodeCache);
+        }
+        const m = els.presetSource.val() === "user" ? "user" : "builtin";
+        setMode(m);
+        if (m === "builtin") {
+          const selected = applyBuiltinSelection(els.builtinPreset.val() || builtinIdCache);
+          if (selected) {
+            els.presetId.val(selected);
+            setBuiltinInfo(selected);
+          }
+        } else {
+          builtinIdCache = String(els.builtinPreset.val() || builtinIdCache);
+          els.presetId.val("custom");
+        }
+        updateEditor();
+      });
+
+      els.builtinPreset.on("change", () => {
+        const id = String(els.builtinPreset.val() || "");
+        builtinIdCache = id;
+        els.presetId.val(id);
+        setBuiltinInfo(id);
+        updateEditor();
+      });
+
+      editor.getSession().on("change", () => {
+        const src = els.presetSource.val() === "user" ? "user" : "builtin";
+        if (src !== "user") return;
+        userCodeCache = String(editor.getValue() || "");
+        els.userCode.val(userCodeCache);
+      });
+    },
+    oneditsave: function () {
+      // Keep presetId aligned with current selection.
+      const src =
+        $("#node-input-presetSource").val() === "user" ? "user" : "builtin";
+      if (src === "builtin") {
+        $("#node-input-presetId").val(
+          String($("#node-input-builtinPreset").val() || ""),
+        );
+      } else {
+        $("#node-input-presetId").val("custom");
+      }
+      if (this._inputAdapterEditor && src === "user") {
+        $("#node-input-userCode").val(
+          String(this._inputAdapterEditor.getValue() || ""),
+        );
+      }
+      if (this._inputAdapterEditor) {
+        try {
+          this._inputAdapterEditor.destroy();
+        } catch (_err) {
+          // ignore
+        }
+        this._inputAdapterEditor = null;
+      }
+    },
+    oneditcancel: function () {
+      if (this._inputAdapterEditor) {
+        try {
+          this._inputAdapterEditor.destroy();
+        } catch (_err) {
+          // ignore
+        }
+        this._inputAdapterEditor = null;
+      }
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="AlarmUltimateInputAdapter">
+  <div class="form-row">
+    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name" />
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-presetSource"
+      ><i class="fa fa-random"></i> Preset source</label
+    >
+    <select id="node-input-presetSource" style="width: 70%;">
+      <option value="builtin">Built-in</option>
+      <option value="user">User</option>
+    </select>
+  </div>
+
+  <br />
+
+  <div class="form-row" id="builtin-row">
+    <label for="node-input-builtinPreset"
+      ><i class="fa fa-cube"></i> Built-in preset</label
+    >
+    <select id="node-input-builtinPreset" style="width: 70%;"></select>
+    <br />
+    <br />
+    <div class="form-tips" id="node-input-builtinInfo"></div>
+  </div>
+
+  <div class="form-row">
+    <label><i class="fa fa-code"></i> Code</label>
+  </div>
+
+  <div class="form-row">
+    <div style="width:100%;">
+      <div
+        style="height: 320px; width: 100%;"
+        class="node-text-editor"
+        id="node-input-code-editor"
+      ></div>
+      <br />
+      <div class="form-tips">
+        Built-in presets are read-only. Switch to <b>User</b> to edit your
+        custom code. Return a msg, an array of msgs, or nothing to drop.
+      </div>
+    </div>
+  </div>
+
+  <input type="hidden" id="node-input-userCode" />
+  <input type="hidden" id="node-input-presetId" />
+  <br />
+  <br />
+  <br />
+  <br />
+</script>
+
+<script type="text/markdown" data-help-name="AlarmUltimateInputAdapter">
+  Translates incoming messages into the format expected by **Alarm System Ultimate** zones.
+
+  Configure a preset (built-in or user-defined). A preset is JavaScript code executed as a function body:
+
+  - Input: `msg`
+  - Return: a message object, an array of messages, or `null/undefined` to drop.
+
+  Example:
+
+  ```js
+  return { topic: msg.topic, payload: !!msg.payload };
+  ```
+</script>

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.2",
   "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"