node-red-contrib-alarm-ultimate 0.1.0

package/nodes/lib/node-helpers.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const utils = require('../utils.js');
+
+function createStatus(node) {
+  return function setNodeStatus({ fill, shape, text }) {
+    const dDate = new Date();
+    node.status({
+      fill,
+      shape,
+      text: `${text} (${dDate.getDate()}, ${dDate.toLocaleTimeString()})`,
+    });
+  };
+}
+
+function resolveInput(msg, propertyPath, translatorConfigId, RED) {
+  const propName = propertyPath || 'payload';
+  let value;
+  try {
+    value = utils.fetchFromObject(msg, propName);
+  } catch (error) {
+    return { value: undefined, boolean: undefined };
+  }
+  if (value === undefined) {
+    return { value: undefined, boolean: undefined };
+  }
+
+  const translatorConfig = translatorConfigId
+    ? RED.nodes.getNode(translatorConfigId)
+    : null;
+
+  return {
+    value,
+    boolean: utils.ToBoolean(value, translatorConfig),
+  };
+}
+
+function createTimerBag(node) {
+  const timers = new Set();
+  const intervals = new Set();
+
+  function trackTimeout(handle) {
+    timers.add(handle);
+    return handle;
+  }
+
+  function trackInterval(handle) {
+    intervals.add(handle);
+    return handle;
+  }
+
+  function clearAll() {
+    for (const handle of timers) {
+      clearTimeout(handle);
+    }
+    timers.clear();
+    for (const handle of intervals) {
+      clearInterval(handle);
+    }
+    intervals.clear();
+  }
+
+  node.on('close', (_removed, done) => {
+    clearAll();
+    done();
+  });
+
+  return {
+    setTimeout(fn, timeout) {
+      const handle = setTimeout(() => {
+        timers.delete(handle);
+        fn();
+      }, timeout);
+      return trackTimeout(handle);
+    },
+    setInterval(fn, interval) {
+      const handle = setInterval(fn, interval);
+      return trackInterval(handle);
+    },
+    clearTimeout(handle) {
+      clearTimeout(handle);
+      timers.delete(handle);
+    },
+    clearInterval(handle) {
+      clearInterval(handle);
+      intervals.delete(handle);
+    },
+    clearAll,
+  };
+}
+
+module.exports = {
+  createStatus,
+  resolveInput,
+  createTimerBag,
+};

package/nodes/utils.js

@@ -0,0 +1,95 @@
+module.exports.ToBoolean = function ToBoolean(value, _configTranslationNode) {
+  let res = false;
+  let decimal = /^\s*[+-]{0,1}\s*([\d]+(\.[\d]*)*)\s*$/;
+
+  if (typeof value === "boolean") {
+    return value;
+  } else if (typeof value === "string" || typeof value === "number") {
+    if (typeof value === "number") value = value.toString(); // We work with strings
+    try {
+      let translationTable = [];
+      value = value.toLowerCase();
+      if (_configTranslationNode === null) {
+        translationTable = DEFAULTTRANSLATIONINPUT.split("\n");
+      } else {
+        translationTable = _configTranslationNode.commandText.split("\n");
+      }
+      for (let index = 0; index < translationTable.length; index++) {
+        // HA Style evaluation in the format "{{value>=0}}"
+        let inputPayloadToBeTranslated = translationTable[index].toLowerCase().split(":")[0];
+        if (inputPayloadToBeTranslated.indexOf("{{") > -1 && inputPayloadToBeTranslated.indexOf("}}") > -1) {
+          // Eval content of the brackets {{value<=0}}, HA style
+          inputPayloadToBeTranslated = inputPayloadToBeTranslated.replace("{{", "").replace("}}", "").replace("value", value); // Set the word value to real value
+          if (eval(inputPayloadToBeTranslated)) {
+            return translationTable[index].split(":")[1] === "true"
+              ? true
+              : false;
+          } // Eval the operation
+        } else if (
+          // Normal string value
+          value === inputPayloadToBeTranslated
+        ) {
+          return translationTable[index].split(":")[1] === "true"
+            ? true
+            : false;
+        }
+      }
+    } catch (error) {
+      console.log("Alarm-Ultimate:utils:toBoolean: " + error.message);
+    }
+  }
+  // else if (typeof value === "number") {
+  //   // Is it formated as a decimal number?
+  //   if (decimal.test(value)) {
+  //     res = parseFloat(value) != 0;
+  //   } else {
+  //     res = value.toLowerCase() === "true";
+  //   }
+  //   return res;
+  // }
+};
+
+module.exports.ToAny = function ToAny(value, _configTranslationNode) {
+
+  try {
+    let translationTable = [];
+    if (_configTranslationNode === null) {
+      // Don't do translation, because the default translation input may contin unwanted translations
+      return value;
+    } else {
+      translationTable = _configTranslationNode.commandText.split("\n");
+    }
+    for (let index = 0; index < translationTable.length; index++) {
+      let inputPayloadToBeTranslated = translationTable[index].split(":")[0];
+      //let outputBoolean = Boolean(translationTable[index].split(":")[1]);
+      if (
+        String(value).toLowerCase() === inputPayloadToBeTranslated.toLowerCase() &&
+        inputPayloadToBeTranslated.toLowerCase() !== ""
+      ) {
+        return translationTable[index].split(":")[1];
+      }
+    }
+    return value;
+  } catch (error) {
+    console.log("Alarm-Ultimate:utils:toAny: " + error.message);
+  }
+
+};
+
+module.exports.fetchFromObject = function fetchFromObject(
+  _msg,
+  _payloadPropName
+) {
+  // The output cannot be an oblect. In case, return undefined.
+  var _index = _payloadPropName.indexOf(".");
+  if (_index > -1) {
+    return fetchFromObject(
+      _msg[_payloadPropName.substring(0, _index)],
+      _payloadPropName.substr(_index + 1)
+    );
+  }
+  if (typeof _msg[_payloadPropName] === "object") return undefined;
+  return _msg[_payloadPropName];
+};
+const DEFAULTTRANSLATIONINPUT =
+  "on:true\noff:false\nactive:true\ninactive:false\nopen:true\nclosed:false\nclose:false\n1:true\n0:false\ntrue:true\nfalse:false\nhome:true\nnot_home:false\nnormal:false\nviolated:true";

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "node-red-contrib-alarm-ultimate",
+  "version": "0.1.0",
+  "description": "Alarm System node for Node-RED.",
+  "author": "Supergiovane (https://github.com/Supergiovane)",
+  "license": "MIT",
+  "keywords": [
+    "node-red",
+    "alarm",
+    "security"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Supergiovane/node-red-contrib-alarm-ultimate"
+  },
+  "node-red": {
+    "nodes": {
+      "AlarmSystemUltimate": "nodes/AlarmSystemUltimate.js",
+      "AlarmUltimateState": "nodes/AlarmUltimateState.js",
+      "AlarmUltimateZone": "nodes/AlarmUltimateZone.js",
+      "AlarmUltimateSiren": "nodes/AlarmUltimateSiren.js"
+    }
+  },
+  "devDependencies": {
+    "chai": "^4.3.10",
+    "mocha": "^10.4.0",
+    "node-red": "^3.1.0",
+    "node-red-node-test-helper": "^0.3.5"
+  },
+  "scripts": {
+    "test": "mocha test/**/*.spec.js"
+  }
+}

package/test/alarm-system.spec.js

@@ -0,0 +1,470 @@
+'use strict';
+
+const { expect } = require('chai');
+const { helper } = require('./helpers');
+
+const alarmNode = require('../nodes/AlarmSystemUltimate.js');
+
+const ALARM_OUTPUT_COUNT = 9;
+
+function loadAlarm(flow, credentials) {
+  const normalizedFlow = flow.map((node, index) => {
+    if (
+      node &&
+      node.type &&
+      node.type !== 'tab' &&
+      node.type !== 'subflow' &&
+      node.type !== 'group' &&
+      node.z &&
+      !(Object.prototype.hasOwnProperty.call(node, 'x') && Object.prototype.hasOwnProperty.call(node, 'y'))
+    ) {
+      const adjusted = { ...node, x: 100 + index * 10, y: 100 + index * 10 };
+      if (adjusted.type === 'AlarmSystemUltimate' && Array.isArray(adjusted.wires)) {
+        const nextWires = adjusted.wires.map((wire) => (Array.isArray(wire) ? wire : []));
+        while (nextWires.length < ALARM_OUTPUT_COUNT) {
+          nextWires.push([]);
+        }
+        adjusted.wires = nextWires;
+      }
+      return adjusted;
+    }
+    return node;
+  });
+  return helper.load(alarmNode, normalizedFlow, credentials || {});
+}
+
+describe('AlarmSystemUltimate node', function () {
+  this.timeout(5000);
+
+  before(function (done) {
+    helper.startServer(done);
+  });
+
+  after(function (done) {
+    helper.stopServer(done);
+  });
+
+  afterEach(function () {
+    return helper.unload();
+  });
+
+  it('triggers alarm after entry delay', function (done) {
+    const flowId = 'alarm1';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm1' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0.05,
+        entryDelaySeconds: 0.05,
+        sirenDurationSeconds: 0.05,
+        sirenLatchUntilDisarm: false,
+        requireCodeForDisarm: false,
+        blockArmOnViolations: true,
+        zones: '{"id":"front","name":"Front","topic":"sensor/frontdoor","type":"perimeter","entry":true}',
+        wires: [['events'], ['siren']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow).then(() => {
+      const alarm = helper.getNode('alarm');
+      const events = helper.getNode('events');
+      const siren = helper.getNode('siren');
+
+      const received = { entry: false, alarm: false, sirenOn: false };
+
+      function maybeDone() {
+        if (received.entry && received.alarm && received.sirenOn) {
+          done();
+        }
+      }
+
+      events.on('input', (msg) => {
+        try {
+          if (msg.event === 'entry_delay') {
+            received.entry = true;
+          }
+          if (msg.event === 'alarm') {
+            received.alarm = true;
+          }
+          maybeDone();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      siren.on('input', (msg) => {
+        try {
+          if (msg.event === 'siren_on') {
+            received.sirenOn = true;
+          }
+          maybeDone();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      alarm.receive({ topic: 'alarm', command: 'arm' });
+      setTimeout(() => {
+        alarm.receive({ topic: 'sensor/frontdoor', payload: 'open' });
+      }, 80);
+    }).catch(done);
+  });
+
+  it('disarms during entry delay and prevents alarm', function (done) {
+    const flowId = 'alarm2';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm2' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0.05,
+        entryDelaySeconds: 0.1,
+        sirenDurationSeconds: 0.2,
+        requireCodeForDisarm: false,
+        zones: '{"id":"front","topic":"sensor/frontdoor","type":"perimeter","entry":true}',
+        wires: [['events'], ['siren']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow).then(() => {
+      const alarm = helper.getNode('alarm');
+      const events = helper.getNode('events');
+      const siren = helper.getNode('siren');
+
+      const seenEvents = [];
+      const sirenOn = [];
+
+      events.on('input', (msg) => {
+        seenEvents.push(msg.event);
+        if (msg.event === 'entry_delay') {
+          setTimeout(() => {
+            alarm.receive({ topic: 'alarm', command: 'disarm' });
+          }, 20);
+        }
+      });
+
+      siren.on('input', (msg) => {
+        if (msg.event === 'siren_on') {
+          sirenOn.push(msg);
+        }
+      });
+
+      alarm.receive({ topic: 'alarm', command: 'arm' });
+      setTimeout(() => {
+        alarm.receive({ topic: 'sensor/frontdoor', payload: 'open' });
+      }, 80);
+
+      setTimeout(() => {
+        try {
+          expect(seenEvents).to.include('entry_delay');
+          expect(seenEvents).to.include('disarmed');
+          expect(seenEvents).to.not.include('alarm');
+          expect(sirenOn.length).to.equal(0);
+          done();
+        } catch (err) {
+          done(err);
+        }
+      }, 300);
+    }).catch(done);
+  });
+
+  it('bypasses a zone and ignores its trigger', function (done) {
+    const flowId = 'alarm3';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm3' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0.05,
+        entryDelaySeconds: 0.05,
+        sirenDurationSeconds: 0.2,
+        requireCodeForDisarm: false,
+        zones: '{"id":"front","topic":"sensor/frontdoor","type":"perimeter","entry":false,"bypassable":true}',
+        wires: [['events'], ['siren']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow).then(() => {
+      const alarm = helper.getNode('alarm');
+      const events = helper.getNode('events');
+      const siren = helper.getNode('siren');
+
+      const seenEvents = [];
+      let sirenOn = false;
+
+      events.on('input', (msg) => {
+        seenEvents.push(msg.event);
+      });
+
+      siren.on('input', (msg) => {
+        if (msg.event === 'siren_on') {
+          sirenOn = true;
+        }
+      });
+
+      alarm.receive({ topic: 'alarm', command: 'bypass', zone: 'front' });
+      alarm.receive({ topic: 'alarm', command: 'arm' });
+      setTimeout(() => {
+        alarm.receive({ topic: 'sensor/frontdoor', payload: 'open' });
+      }, 80);
+
+      setTimeout(() => {
+        try {
+          expect(seenEvents).to.include('bypassed');
+          expect(seenEvents).to.not.include('alarm');
+          expect(sirenOn).to.equal(false);
+          done();
+        } catch (err) {
+          done(err);
+        }
+      }, 250);
+    }).catch(done);
+  });
+
+  it('accepts zones as a JSON array (formatted)', function (done) {
+    const flowId = 'alarm4';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm4' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0.05,
+        entryDelaySeconds: 0.05,
+        sirenDurationSeconds: 0.05,
+        sirenLatchUntilDisarm: false,
+        requireCodeForDisarm: false,
+        blockArmOnViolations: true,
+        zones: JSON.stringify(
+          [
+            {
+              id: 'front',
+              name: 'Front',
+              topic: 'sensor/frontdoor',
+              type: 'perimeter',
+              entry: true,
+            },
+          ],
+          null,
+          2
+        ),
+        wires: [['events'], ['siren']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow).then(() => {
+      const alarm = helper.getNode('alarm');
+      const events = helper.getNode('events');
+      const siren = helper.getNode('siren');
+
+      const received = { entry: false, alarm: false, sirenOn: false };
+
+      function maybeDone() {
+        if (received.entry && received.alarm && received.sirenOn) {
+          done();
+        }
+      }
+
+      events.on('input', (msg) => {
+        try {
+          if (msg.event === 'entry_delay') {
+            received.entry = true;
+          }
+          if (msg.event === 'alarm') {
+            received.alarm = true;
+          }
+          maybeDone();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      siren.on('input', (msg) => {
+        try {
+          if (msg.event === 'siren_on') {
+            received.sirenOn = true;
+          }
+          maybeDone();
+        } catch (err) {
+          done(err);
+        }
+      });
+
+      alarm.receive({ topic: 'alarm', command: 'arm' });
+      setTimeout(() => {
+        alarm.receive({ topic: 'sensor/frontdoor', payload: 'open' });
+      }, 80);
+    }).catch(done);
+  });
+
+  it('routes alarm events to the "Alarm Triggered" output', function (done) {
+    const flowId = 'alarm5';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm5' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0,
+        entryDelaySeconds: 0,
+        sirenDurationSeconds: 0,
+        requireCodeForDisarm: false,
+        zones: '{"id":"front","topic":"sensor/frontdoor","type":"perimeter","entry":false}',
+        wires: [['events'], ['siren'], ['alarmTriggered']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+      { id: 'alarmTriggered', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow)
+      .then(() => {
+        const alarm = helper.getNode('alarm');
+        const alarmTriggered = helper.getNode('alarmTriggered');
+
+        alarmTriggered.on('input', (msg) => {
+          try {
+            expect(msg.event).to.equal('alarm');
+            done();
+          } catch (err) {
+            done(err);
+          }
+        });
+
+        alarm.receive({ topic: 'alarm', command: 'arm' });
+        setTimeout(() => {
+          alarm.receive({ topic: 'sensor/frontdoor', payload: true });
+        }, 20);
+      })
+      .catch(done);
+  });
+
+  it('emits "Any Zone Open" boolean output', function (done) {
+    const flowId = 'alarm6';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm6' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0,
+        entryDelaySeconds: 0,
+        sirenDurationSeconds: 0,
+        requireCodeForDisarm: false,
+        zones: '{"id":"front","topic":"sensor/frontdoor","type":"perimeter","entry":false}',
+        wires: [['events'], ['siren'], [], [], [], [], ['anyZoneOpen']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+      { id: 'anyZoneOpen', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow)
+      .then(() => {
+        const alarm = helper.getNode('alarm');
+        const anyZoneOpen = helper.getNode('anyZoneOpen');
+
+        let hasSeenTrue = false;
+
+        anyZoneOpen.on('input', (msg) => {
+          try {
+            if (msg.payload === true) {
+              hasSeenTrue = true;
+              return;
+            }
+            if (hasSeenTrue && msg.payload === false) {
+              done();
+            }
+          } catch (err) {
+            done(err);
+          }
+        });
+
+        setTimeout(() => {
+          alarm.receive({ topic: 'sensor/frontdoor', payload: true });
+        }, 30);
+        setTimeout(() => {
+          alarm.receive({ topic: 'sensor/frontdoor', payload: false });
+        }, 80);
+      })
+      .catch(done);
+  });
+
+  it('lists open zones on request topic', function (done) {
+    const flowId = 'alarm7';
+    const flow = [
+      { id: flowId, type: 'tab', label: 'alarm7' },
+      {
+        id: 'alarm',
+        type: 'AlarmSystemUltimate',
+        z: flowId,
+        controlTopic: 'alarm',
+        exitDelaySeconds: 0,
+        entryDelaySeconds: 0,
+        sirenDurationSeconds: 0,
+        requireCodeForDisarm: false,
+        openZonesRequestTopic: 'alarm/listOpenZones',
+        openZonesRequestIntervalSeconds: 0,
+        zones: JSON.stringify(
+          [
+            { id: 'front', topic: 'sensor/frontdoor', type: 'perimeter', entry: false },
+            { id: 'back', topic: 'sensor/backdoor', type: 'perimeter', entry: false },
+          ],
+          null,
+          2
+        ),
+        wires: [['events'], ['siren'], [], [], [], [], [], [], ['openZones']],
+      },
+      { id: 'events', type: 'helper', z: flowId },
+      { id: 'siren', type: 'helper', z: flowId },
+      { id: 'openZones', type: 'helper', z: flowId },
+    ];
+
+    loadAlarm(flow)
+      .then(() => {
+        const alarm = helper.getNode('alarm');
+        const openZones = helper.getNode('openZones');
+
+        const receivedIds = new Set();
+
+        openZones.on('input', (msg) => {
+          try {
+            expect(msg.event).to.equal('open_zone');
+            expect(msg).to.have.nested.property('payload.zone.id');
+            receivedIds.add(msg.payload.zone.id);
+            if (receivedIds.has('front') && receivedIds.has('back')) {
+              done();
+            }
+          } catch (err) {
+            done(err);
+          }
+        });
+
+        alarm.receive({ topic: 'sensor/frontdoor', payload: true });
+        alarm.receive({ topic: 'sensor/backdoor', payload: true });
+
+        setTimeout(() => {
+          alarm.receive({ topic: 'alarm/listOpenZones' });
+        }, 30);
+      })
+      .catch(done);
+  });
+});