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

package/nodes/AlarmSystemUltimate.js

@@ -32,6 +32,19 @@ function writeJsonFileAtomicSync(filePath, data) {
 module.exports = function (RED) {
   const helpers = require('./lib/node-helpers.js');
 
+  function parseJsonObject(value) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    } catch (_err) {
+      return null;
+    }
+  }
+
   if (RED && RED.httpAdmin && typeof RED.httpAdmin.get === 'function') {
     const needsRead =
       RED.auth && typeof RED.auth.needsPermission === 'function'
@@ -79,6 +92,27 @@ module.exports = function (RED) {
       res.json(api.getState());
     });
 
+    RED.httpAdmin.get('/alarm-ultimate/alarm/:id/log', needsRead, (req, res) => {
+      const api = alarmInstances.get(req.params.id);
+      if (!api) {
+        res.sendStatus(404);
+        return;
+      }
+      const getLog = api.getLog && typeof api.getLog === 'function' ? api.getLog : null;
+      if (!getLog) {
+        res.status(501).json({ ok: false, error: 'log_not_supported' });
+        return;
+      }
+      const since = Number(req.query && req.query.since);
+      const limit = Number(req.query && req.query.limit);
+      res.json(
+        getLog({
+          since: Number.isFinite(since) ? since : null,
+          limit: Number.isFinite(limit) ? limit : null,
+        })
+      );
+    });
+
     RED.httpAdmin.post('/alarm-ultimate/alarm/:id/command', needsWrite, (req, res) => {
       const api = alarmInstances.get(req.params.id);
       if (!api) {
@@ -88,7 +122,8 @@ module.exports = function (RED) {
       try {
         const body = req.body && typeof req.body === 'object' ? req.body : {};
         api.command(body);
-        res.json({ ok: true });
+        const snapshot = api.getState && typeof api.getState === 'function' ? api.getState() : null;
+        res.json({ ok: true, result: snapshot });
       } catch (err) {
         res.status(500).json({ ok: false, error: err.message });
       }
@@ -105,6 +140,7 @@ module.exports = function (RED) {
 
     const controlTopic = config.controlTopic || 'alarm';
     const payloadPropName = config.payloadPropName || 'payload';
+    const syncTargetsConfig = parseJsonObject(config.syncTargets) || {};
 
     const requireCodeForArm = config.requireCodeForArm === true;
     const requireCodeForDisarm = config.requireCodeForDisarm !== false;
@@ -255,6 +291,8 @@ module.exports = function (RED) {
       'bypassed',
       'unbypassed',
       'chime',
+      'zone_open',
+      'zone_close',
       'zone_ignored_exit',
       'zone_bypassed_trigger',
       'zone_restore',
@@ -550,6 +588,22 @@ module.exports = function (RED) {
       let shape = 'ring';
       let text = 'DISARMED';
 
+      // When idle/disarmed, show recent arming errors to make the reason visible in the editor status.
+      if (!state.alarmActive && !state.entry && !state.arming && state.mode === 'disarmed') {
+        const last = Array.isArray(state.log) && state.log.length ? state.log[state.log.length - 1] : null;
+        const evt = last && typeof last.event === 'string' ? last.event : '';
+        if (evt === 'arm_blocked') {
+          const violations = Array.isArray(last.violations) ? last.violations.length : 0;
+          fill = 'yellow';
+          shape = 'ring';
+          text = `ARM BLOCKED${violations ? ` (${violations})` : ''}`;
+        } else if (evt === 'denied' && last && String(last.action || '') === 'arm') {
+          fill = 'red';
+          shape = 'ring';
+          text = 'ARM DENIED';
+        }
+      }
+
       if (state.alarmActive) {
         fill = 'red';
         shape = 'dot';
@@ -678,6 +732,27 @@ module.exports = function (RED) {
       };
     }
 
+    function getLogSnapshot(opts) {
+      const options = opts && typeof opts === 'object' ? opts : {};
+      const since = Number.isFinite(Number(options.since)) ? Number(options.since) : null;
+      const limit = Number.isFinite(Number(options.limit)) ? clampInt(options.limit, 200, 0, 500) : null;
+
+      const all = Array.isArray(state.log) ? state.log : [];
+      const filtered = since ? all.filter((e) => (e && Number(e.ts)) > since) : all;
+      const out = limit === null ? filtered : limit === 0 ? [] : filtered.slice(-limit);
+
+      return {
+        id: node.id,
+        name: node.name || '',
+        now: now(),
+        total: all.length,
+        returned: out.length,
+        since,
+        limit,
+        log: out.map((e) => ({ ...(e || {}) })),
+      };
+    }
+
     function buildZoneSummary(zone) {
       return {
         id: zone ? zone.id : null,
@@ -1016,6 +1091,7 @@ module.exports = function (RED) {
       state.mode = 'disarmed';
       persist();
       emitEvent('disarmed', { reason, duress: Boolean(duress) }, baseMsg);
+      return true;
     }
 
     function violatedZonesForArm() {
@@ -1038,13 +1114,13 @@ module.exports = function (RED) {
     function arm(baseMsg, reason) {
       if (state.mode === 'armed' && !state.arming) {
         emitEvent('already_armed', { target: 'armed' }, baseMsg);
-        return;
+        return true;
       }
 
       const violations = blockArmOnViolations ? violatedZonesForArm() : [];
       if (blockArmOnViolations && violations.length > 0) {
         emitEvent('arm_blocked', { target: 'armed', violations }, baseMsg);
-        return;
+        return false;
       }
 
       stopOpenZonesDuringArming();
@@ -1065,7 +1141,7 @@ module.exports = function (RED) {
         stopOpenZonesDuringArming();
         persist();
         emitEvent('armed', { reason }, baseMsg);
-        return;
+        return true;
       }
 
       const until = now() + exitDelayMs;
@@ -1094,6 +1170,55 @@ module.exports = function (RED) {
         persist();
         emitEvent('armed', { reason }, baseMsg);
       }, exitDelayMs);
+      return true;
+    }
+
+    function isSyncedControlMessage(msg) {
+      return Boolean(msg && typeof msg === 'object' && msg._alarmUltimateSync);
+    }
+
+    function normalizeSyncAction(value) {
+      const v = String(value || '').toLowerCase().trim();
+      if (v === 'arm') return 'arm';
+      if (v === 'disarm') return 'disarm';
+      return 'leave';
+    }
+
+    function syncOtherAlarms(trigger, baseMsg) {
+      if (!syncTargetsConfig || typeof syncTargetsConfig !== 'object') {
+        return;
+      }
+      if (isSyncedControlMessage(baseMsg)) {
+        return;
+      }
+      const when = trigger === 'disarm' ? 'onDisarm' : 'onArm';
+      const entries = Object.entries(syncTargetsConfig);
+      if (!entries.length) {
+        return;
+      }
+      for (const [targetId, rule] of entries) {
+        if (!targetId || targetId === node.id) continue;
+        const action = normalizeSyncAction(rule && typeof rule === 'object' ? rule[when] : '');
+        if (action === 'leave') continue;
+        const api = alarmInstances.get(targetId);
+        if (!api || typeof api.command !== 'function') continue;
+
+        const payload = {
+          command: action,
+          _alarmUltimateSync: {
+            origin: node.id,
+            trigger,
+          },
+        };
+        if (typeof baseMsg.code === 'string') payload.code = baseMsg.code;
+        if (typeof baseMsg.pin === 'string') payload.pin = baseMsg.pin;
+
+        try {
+          api.command(payload);
+        } catch (_err) {
+          // ignore
+        }
+      }
     }
 
     function startEntryDelay(zone, baseMsg) {
@@ -1107,7 +1232,7 @@ module.exports = function (RED) {
       }
       const until = now() + delay;
       state.entry = { zoneId: zone.id, until };
-      emitEvent('entry_delay', { zone: { id: zone.id, name: zone.name }, seconds: remainingSeconds(until) }, baseMsg);
+      emitEvent('entry_delay', { zone: buildZoneSummary(zone), seconds: remainingSeconds(until) }, baseMsg);
       startStatusInterval();
       clearEntryTimer();
       entryTimer = timerBag.setTimeout(() => {
@@ -1177,7 +1302,7 @@ module.exports = function (RED) {
       }
       state.bypass[id] = Boolean(enabled);
       persist();
-      emitEvent(enabled ? 'bypassed' : 'unbypassed', { zone: { id: zone.id, name: zone.name } }, baseMsg);
+      emitEvent(enabled ? 'bypassed' : 'unbypassed', { zone: buildZoneSummary(zone) }, baseMsg);
     }
 
     function handleControlMessage(msg) {
@@ -1241,9 +1366,11 @@ module.exports = function (RED) {
         if (validation.duress) {
           triggerAlarm('duress', null, msg, true);
           disarm(msg, 'duress', true);
+          syncOtherAlarms('disarm', msg);
           return true;
         }
         disarm(msg, 'manual', false);
+        syncOtherAlarms('disarm', msg);
         return true;
       }
 
@@ -1266,7 +1393,10 @@ module.exports = function (RED) {
         if (validation.duress) {
           triggerAlarm('duress', null, msg, true);
         }
-        arm(msg, 'manual');
+        const accepted = arm(msg, 'manual');
+        if (accepted) {
+          syncOtherAlarms('arm', msg);
+        }
         return true;
       }
 
@@ -1278,7 +1408,7 @@ module.exports = function (RED) {
       if (!zone) {
         return;
       }
-      const resolved = helpers.resolveInput(msg, payloadPropName, config.translatorConfig, RED);
+      const resolved = helpers.resolveInput(msg, payloadPropName, null, RED);
       const value = resolved.boolean;
       if (value === undefined) {
         return;
@@ -1290,8 +1420,20 @@ module.exports = function (RED) {
       zoneMeta.lastChangeAt = now();
       state.zoneState[zone.id] = zoneMeta;
 
+      if (changed) {
+        emitEvent(
+          value === true ? 'zone_open' : 'zone_close',
+          {
+            zone: buildZoneSummary(zone),
+            open: value === true,
+            bypassed: state.bypass[zone.id] === true,
+          },
+          msg
+        );
+      }
+
       if (changed && emitRestoreEvents && value === false) {
-        emitEvent('zone_restore', { zone: { id: zone.id, name: zone.name, type: zone.type } }, msg);
+        emitEvent('zone_restore', { zone: buildZoneSummary(zone) }, msg);
       }
 
       if (changed) {
@@ -1317,7 +1459,7 @@ module.exports = function (RED) {
       }
 
       if (state.bypass[zone.id] === true && zone.bypassable !== false) {
-        emitEvent('zone_bypassed_trigger', { zone: { id: zone.id, name: zone.name, type: zone.type } }, msg);
+        emitEvent('zone_bypassed_trigger', { zone: buildZoneSummary(zone) }, msg);
         return;
       }
 
@@ -1335,13 +1477,13 @@ module.exports = function (RED) {
       }
 
       if (state.arming && !zone.instantDuringExit) {
-        emitEvent('zone_ignored_exit', { zone: { id: zone.id, name: zone.name, type: zone.type } }, msg);
+        emitEvent('zone_ignored_exit', { zone: buildZoneSummary(zone) }, msg);
         return;
       }
 
       if (state.mode === 'disarmed') {
         if (zone.chime) {
-          emitEvent('chime', { zone: { id: zone.id, name: zone.name, type: zone.type } }, msg);
+          emitEvent('chime', { zone: buildZoneSummary(zone) }, msg);
         }
         return;
       }
@@ -1374,6 +1516,7 @@ module.exports = function (RED) {
       name: node.name || '',
       controlTopic,
       getState: getUiState,
+      getLog: getLogSnapshot,
       command(body) {
         const payload = body && typeof body === 'object' ? body : {};
         const msg = { topic: controlTopic };
@@ -1402,6 +1545,9 @@ module.exports = function (RED) {
         if (typeof payload.zone === 'string') {
           msg.zone = payload.zone;
         }
+        if (payload._alarmUltimateSync && typeof payload._alarmUltimateSync === 'object') {
+          msg._alarmUltimateSync = payload._alarmUltimateSync;
+        }
 
         node.receive(msg);
       },

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>