iobroker.zwavews 0.0.3

package/lib/statesController.js

@@ -0,0 +1,84 @@
+/**
+ *
+ */
+class StatesController {
+  /**
+   *
+   * @param adapter
+   * @param deviceCache
+   */
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+
+  /**
+   *
+   * @param stateName
+   * @param value
+   */
+  async setStateSafelyAsync(stateName, value) {
+    if (value === undefined || value === null) {
+      return;
+    }
+    await this.adapter.setStateAsync(stateName, value, true);
+  }
+
+  /**
+   *
+   * @param stateName
+   * @param value
+   */
+  async setStateChangedSafelyAsync(stateName, value) {
+    if (value === undefined || value === null) {
+      return;
+    }
+    await this.adapter.setStateChangedAsync(stateName, value, true);
+  }
+
+  /**
+   *
+   * @param deviceCache
+   */
+  async subscribeAllWritableExistsStates() {
+    const writableStates = {};
+
+    const res = await this.adapter.getObjectViewAsync("system", "state", {
+      startkey: "zwaveWS.",
+      endkey: "zwaveWS.\u9999",
+    });
+
+    for (const row of res.rows) {
+      const obj = row.value;
+      if (obj?.common?.write === true) {
+        writableStates[obj._id] = {
+          mqttId: obj.native.mqttPath,
+          write: true,
+          subst: null,
+        };
+      }
+    }
+
+    return writableStates;
+  }
+
+  /**
+   *
+   */
+  async setAllAvailableToFalse() {
+    const readyStates = await this.adapter.getStatesAsync("*.ready");
+    for (const readyState in readyStates) {
+      await this.adapter.setStateChangedAsync(readyState, false, true);
+    }
+    const availableStates = await this.adapter.getStatesAsync("*.status");
+    for (const availableState in availableStates) {
+      await this.adapter.setStateChangedAsync(availableState, "unknown", true);
+    }
+    await this.adapter.setStateChangedAsync('info.zwave_gateway_status', 'offline', true);
+
+  }
+
+}
+
+module.exports = {
+  StatesController,
+};

package/lib/utils.js

@@ -0,0 +1,205 @@
+/**
+ *
+ * @param ba
+ */
+function bytesArrayToWordArray(ba) {
+  const wa = [];
+  for (let i = 0; i < ba.length; i++) {
+    wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
+  }
+  return wa;
+}
+
+// If the value is greater than 1000, kelvin is assumed.
+// If smaller, it is assumed to be mired.
+/**
+ *
+ * @param t
+ */
+function toMired(t) {
+  let miredValue = t;
+  if (t > 1000) {
+    miredValue = miredKelvinConversion(t);
+  }
+  return miredValue;
+}
+
+/**
+ *
+ * @param t
+ */
+function miredKelvinConversion(t) {
+  return Math.round(1000000 / t);
+}
+
+/**
+ * Converts a decimal number to a hex string with zero-padding
+ *
+ * @param decimal
+ * @param padding
+ */
+function decimalToHex(decimal, padding) {
+  let hex = Number(decimal).toString(16);
+  padding =
+    typeof padding === "undefined" || padding === null
+      ? (padding = 2)
+      : padding;
+
+  while (hex.length < padding) {
+    hex = `0${hex}`;
+  }
+
+  return hex;
+}
+
+/**
+ *
+ * @param array
+ */
+function clearArray(array) {
+  while (array.length > 0) {
+    array.pop();
+  }
+}
+
+/**
+ *
+ * @param source
+ * @param target
+ */
+function moveArray(source, target) {
+  while (source.length > 0) {
+    target.push(source.shift());
+  }
+}
+
+/**
+ *
+ * @param item
+ */
+function isObject(item) {
+  return typeof item === "object" && !Array.isArray(item) && item !== null;
+}
+
+/**
+ *
+ * @param item
+ */
+function isJson(item) {
+  let value = typeof item !== "string" ? JSON.stringify(item) : item;
+  try {
+    value = JSON.parse(value);
+  } catch (e) {
+    return false;
+  }
+
+  return typeof value === "object" && value !== null;
+}
+
+/**
+ *
+ * @param input
+ */
+function getLastSegment(input) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  const parts = input.split(/[./]/).filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : "";
+}
+
+/**
+ * @param {any} value
+ * @returns {boolean}
+ */
+function isNumeric(value) {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (s === "") {
+      return false;
+    }
+    return /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?$/.test(s);
+  }
+  return false;
+}
+
+/**
+ *
+ * @param str
+ */
+function replaceLastDot(str) {
+  const idx = str.lastIndexOf(".");
+  return idx >= 0 ? `${str.slice(0, idx)}_${str.slice(idx + 1)}` : str;
+}
+/**
+ *
+ * @param input
+ */
+function formatMQTT(input) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  return input.replace(/\./g, "/");
+}
+
+/**
+ *
+ * @param nodeId
+ * @param width
+ */
+function padNodeId(nodeId, width = 3) {
+  return nodeId.replace(/(\d+)$/, (m) => m.padStart(width, "0"));
+}
+
+/**
+ *
+ * @param status
+ */
+function getStatusText(status) {
+  const nodeStatus = {
+    0: "Unknown",
+    1: "Asleep",
+    2: "Awake",
+    3: "Dead",
+    4: "Alive",
+  };
+
+  return nodeStatus[status] || "Unknown";
+}
+
+/**
+ *
+ * @param nodeIdOriginal
+ */
+function formatNodeId(nodeIdOriginal) {
+  let nodeId = nodeIdOriginal;
+
+  if (this.isNumeric(nodeIdOriginal)) {
+    nodeId = this.padNodeId(`nodeID_${nodeIdOriginal}`);
+  }
+  return nodeId;
+}
+
+module.exports = {
+  bytesArrayToWordArray,
+  toMired,
+  miredKelvinConversion,
+  decimalToHex,
+  formatNodeId,
+  clearArray,
+  moveArray,
+  isObject,
+  isJson,
+  getLastSegment,
+  isNumeric,
+  replaceLastDot,
+  formatMQTT,
+  padNodeId,
+  getStatusText,
+};

package/lib/websocketController.js

@@ -0,0 +1,131 @@
+const WebSocket = require('ws');
+let wsClient;
+const wsHeartbeatIntervall = 5000;
+const restartTimeout = 1000;
+let ping;
+let pingTimeout;
+let autoRestartTimeout;
+
+/**
+ *
+ */
+class WebsocketController {
+    /**
+     *
+     * @param adapter
+     */
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+
+    /**
+     *
+     */
+    initWsClient() {
+        try {
+            let wsURL = `${this.adapter.config.wsScheme}://${this.adapter.config.wsServerIP}:${this.adapter.config.wsServerPort}/api`;
+
+            if (this.adapter.config.wsTokenEnabled == true) {
+                wsURL += `?token=${this.adapter.config.wsToken}`;
+            }
+
+            wsClient = new WebSocket(wsURL, { rejectUnauthorized: false });
+
+            wsClient.on('open', () => {
+                // Send ping to server
+                this.sendPingToServer();
+                // Start Heartbeat
+                this.wsHeartbeat();
+            });
+
+            wsClient.on('pong', () => {
+                this.wsHeartbeat();
+            });
+
+            wsClient.on('close', async () => {
+                clearTimeout(pingTimeout);
+                clearTimeout(ping);
+
+                if (wsClient.readyState === WebSocket.CLOSED) {
+                    this.autoRestart();
+                }
+            });
+
+            wsClient.on('message', () => {});
+
+            wsClient.on('error', (err) => {
+                this.adapter.log.debug(err);
+            });
+
+            return wsClient;
+        } catch (err) {
+            this.adapter.log.error(err);
+        }
+    }
+
+    /**
+     *
+     * @param message
+     */
+    send(message) {
+        if (wsClient.readyState !== WebSocket.OPEN) {
+            this.adapter.log.warn('Cannot set State, no websocket connection to Zigbee2MQTT!');
+            return;
+        }
+        wsClient.send(message);
+    }
+
+    /**
+     *
+     */
+    sendPingToServer() {
+        //this.logDebug('Send ping to server');
+        wsClient.ping();
+        ping = setTimeout(() => {
+            this.sendPingToServer();
+        }, wsHeartbeatIntervall);
+    }
+
+    /**
+     *
+     */
+    wsHeartbeat() {
+        clearTimeout(pingTimeout);
+        pingTimeout = setTimeout(() => {
+            this.adapter.log.warn('Websocked connection timed out');
+            wsClient.terminate();
+        }, wsHeartbeatIntervall + 3000);
+    }
+
+    /**
+     *
+     */
+    async autoRestart() {
+        this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
+        autoRestartTimeout = setTimeout(() => {
+            this.adapter.startWebsocket();
+        }, restartTimeout);
+    }
+
+    /**
+     *
+     */
+    closeConnection() {
+        if (wsClient && wsClient.readyState !== WebSocket.CLOSED) {
+            wsClient.close();
+        }
+    }
+
+    /**
+     *
+     */
+    async allTimerClear() {
+        clearTimeout(pingTimeout);
+        clearTimeout(ping);
+        clearTimeout(autoRestartTimeout);
+    }
+}
+
+module.exports = {
+    WebsocketController,
+};