node-red-contrib-mobius-flow-base 2.5.91 → 3.0.0-beta.13

package/dist/engine-websocket.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeToBCMD = exports.subscribeToBCMD = exports.unsubscribeToResourceCOV = exports.subscribeToResourceCOV = exports.unsubscribeToObjectCOV = exports.subscribeToObjectCOV = exports.disconnectFromWebSocket = exports.connectToWebSocket = exports.killWebSocket = exports.clearAllCallbacks = exports.registerCallback = exports.on = exports.setWebSocketConnectParams = void 0;
+const ws_1 = __importDefault(require("ws"));
+const engine_api_client_1 = require("./engine-api-client");
+let webSocket = null;
+let pendingWebSocketMessages = [];
+let pendingWebSocketMessageInterval = null;
+let pingInterval = null;
+let registeredCallbacks = [];
+let eventListeners = [];
+let reconnectInterval = null;
+let attemptReconnect = false;
+let connectParams = null;
+const setWebSocketConnectParams = (hostname, port, protocol) => {
+    connectParams = { hostname, port, protocol };
+};
+exports.setWebSocketConnectParams = setWebSocketConnectParams;
+const on = (eventName, callback) => {
+    eventListeners.push({ eventName, callback });
+};
+exports.on = on;
+const triggerEvent = (eventName) => {
+    const callbacks = eventListeners
+        .filter((cb) => cb.eventName === eventName)
+        .map((cb) => cb.callback);
+    callbacks.forEach((cb) => cb());
+};
+function registerCallback(topic, callback) {
+    registeredCallbacks.push({ topic, callback });
+}
+exports.registerCallback = registerCallback;
+function clearAllCallbacks() {
+    registeredCallbacks = [];
+}
+exports.clearAllCallbacks = clearAllCallbacks;
+function sendPingMessage() {
+    sendWebSocketMessage({
+        topic: 'ping',
+        payload: {},
+    });
+}
+function sendWebSocketMessage(message) {
+    if (webSocket?.readyState === ws_1.default.OPEN) {
+        webSocket.send(JSON.stringify(message));
+    }
+    else {
+        pendingWebSocketMessages.push(message);
+    }
+}
+function handleWebSocketMessage(message) {
+    if (message.topic === 'error') {
+        console.log(`Websocket Error: ${message.payload}`);
+    }
+    if (message.topic === 'authorized') {
+        console.log('Engine API Subscription WebSocket Auth Success');
+        triggerEvent('connected');
+    }
+    const callbacks = registeredCallbacks
+        .filter((cb) => cb.topic === message.topic)
+        .map((cb) => cb.callback);
+    callbacks.forEach((cb) => cb(message.payload));
+}
+const reconnect = () => {
+    console.log('Engine API Subscription WebSocket Client reconnecting...');
+    (0, exports.connectToWebSocket)();
+};
+// To be used only when connection node is deleted, hence removal of all callbacks etc.
+const killWebSocket = () => {
+    attemptReconnect = false;
+    if (reconnectInterval) {
+        clearInterval(reconnectInterval);
+    }
+    registeredCallbacks = [];
+    pendingWebSocketMessages = [];
+    eventListeners = [];
+    if (webSocket) {
+        webSocket.close();
+    }
+    console.log('Killing Engine API Subscription WebSocket Client');
+};
+exports.killWebSocket = killWebSocket;
+/**
+ * Connect to the Mobius WebSocket API
+ * This method will connect to the Mobius WebSocket API and authenticate with the API token
+ */
+const connectToWebSocket = () => {
+    if (!connectParams) {
+        console.log('Unabled to connect to Engine API Subscription WebSocket as no connect params are set');
+        return;
+    }
+    if (!engine_api_client_1.tokens) {
+        console.log('Unabled to connect to Engine API Subscription WebSocket as no tokens are available');
+        return;
+    }
+    if (webSocket) {
+        webSocket.close();
+        webSocket = null;
+    }
+    let webSocketProtocol = 'wss';
+    if (connectParams.protocol === 'http') {
+        webSocketProtocol = 'ws';
+    }
+    webSocket = new ws_1.default(`${webSocketProtocol}://${connectParams.hostname}:${connectParams.port}/api/v1/mobius/subscribe/connect`);
+    webSocket.onopen = () => {
+        attemptReconnect = true;
+        console.log('Engine API Subscription WebSocket Client Connected');
+        pingInterval = setInterval(sendPingMessage, 30000);
+        clearInterval(reconnectInterval);
+        webSocket?.send(JSON.stringify({
+            topic: 'authorize',
+            payload: `Bearer ${engine_api_client_1.tokens?.token}`,
+        }));
+        pendingWebSocketMessageInterval = setInterval(() => {
+            for (let i = 0; i < pendingWebSocketMessages.length; i++) {
+                const pendingMessage = pendingWebSocketMessages.shift();
+                sendWebSocketMessage(pendingMessage);
+            }
+        }, 1000);
+    };
+    webSocket.onclose = () => {
+        console.log('Engine API Subscription WebSocket Client Closed');
+        if (pingInterval) {
+            clearInterval(pingInterval);
+        }
+        webSocket = null;
+        clearInterval(reconnectInterval);
+        if (pendingWebSocketMessageInterval) {
+            clearInterval(pendingWebSocketMessageInterval);
+        }
+        if (attemptReconnect) {
+            reconnectInterval = setInterval(() => {
+                if (engine_api_client_1.loggedIn) {
+                    reconnect();
+                }
+            }, 30000);
+        }
+        triggerEvent('disconnected');
+    };
+    webSocket.onmessage = (message) => {
+        try {
+            if (message.data) {
+                const parsedMessage = JSON.parse(message.data);
+                handleWebSocketMessage(parsedMessage);
+            }
+        }
+        catch (e) {
+            console.log('Error parsing message ', e);
+        }
+    };
+    webSocket.on('error', (e) => {
+        if (e.code === 'ECONNREFUSED') {
+            (0, engine_api_client_1.setLoggedIn)(false);
+        }
+        else {
+            console.error('Engine API Subscription WebSocket Client Error: ', e);
+        }
+    });
+};
+exports.connectToWebSocket = connectToWebSocket;
+/**
+ * Disconnect from the Mobius WebSocket API - Using this will not stop socket from attempting to reconnect
+ * This method will close the connection to the Mobius WebSocket API
+ */
+const disconnectFromWebSocket = () => {
+    if (webSocket) {
+        webSocket.close();
+    }
+};
+exports.disconnectFromWebSocket = disconnectFromWebSocket;
+/**
+ * Subscribe to an object's COV
+ * This method will subscribe to an object's COV
+ * @param uri The URI of the object to subscribe to
+ * @param listener The listener to dispatch the event to
+ */
+const subscribeToObjectCOV = (uri) => {
+    console.log('Subscribing to object COV', uri);
+    sendWebSocketMessage({
+        topic: 'subscribe',
+        payload: { type: 'object-cov', uri },
+    });
+    // subList.push({ topic: 'object-cov', uri });
+};
+exports.subscribeToObjectCOV = subscribeToObjectCOV;
+/**
+ * Unsubscribe from an object's COV
+ * This method will unsubscribe from an object's COV
+ * @param uri The URI of the object to unsubscribe from
+ * @param listener The listener to remove
+ */
+const unsubscribeToObjectCOV = (uri) => {
+    sendWebSocketMessage({
+        topic: 'unsubscribe',
+        payload: { type: 'object-cov', uri },
+    });
+    // subList = subList.filter(
+    //   (sub) => JSON.stringify(sub) !== JSON.stringify({ topic: 'object-cov', uri })
+    // );
+};
+exports.unsubscribeToObjectCOV = unsubscribeToObjectCOV;
+/**
+ * Subscribe to an object's COV
+ * This method will subscribe to an object's COV
+ * @param uri The URI of the object to subscribe to
+ * @param listener The listener to dispatch the event to
+ */
+const subscribeToResourceCOV = (uri) => {
+    sendWebSocketMessage({
+        topic: 'subscribe',
+        payload: { type: 'resource-cov', uri },
+    });
+    // subList.push({ topic: 'resource-cov', uri });
+};
+exports.subscribeToResourceCOV = subscribeToResourceCOV;
+/**
+ * Unsubscribe from an object's COV
+ * This method will unsubscribe from an object's COV
+ * @param uri The URI of the object to unsubscribe from
+ * @param listener The listener to remove
+ */
+const unsubscribeToResourceCOV = (uri) => {
+    sendWebSocketMessage({
+        topic: 'unsubscribe',
+        payload: { type: 'resource-cov', uri },
+    });
+    // subList = subList.filter(
+    //   (sub) => JSON.stringify(sub) !== JSON.stringify({ topic: 'resource-cov', uri })
+    // );
+};
+exports.unsubscribeToResourceCOV = unsubscribeToResourceCOV;
+/**
+ * Subscribe to a BCMD event
+ * This method will subscribe to a BCMD event
+ * @param uri The URI of the object to subscribe to
+ * @param listener The listener to dispatch the event to
+ */
+const subscribeToBCMD = (uri) => {
+    sendWebSocketMessage({
+        topic: 'subscribe',
+        payload: { type: 'broadcast-command', uri },
+    });
+    // subList.push({ topic: 'broadcast-command', uri });
+};
+exports.subscribeToBCMD = subscribeToBCMD;
+/**
+ * Unsubscribe from a BCMD event
+ * This method will unsubscribe from a BCMD event
+ * @param uri The URI of the object to unsubscribe from
+ * @param listener The listener to remove
+ */
+const unsubscribeToBCMD = (uri) => {
+    sendWebSocketMessage({
+        topic: 'unsubscribe',
+        payload: { type: 'broadcast-command', uri },
+    });
+    // subList = subList.filter(
+    //   (sub) => JSON.stringify(sub) !== JSON.stringify({ topic: 'broadcast-command', uri })
+    // );
+};
+exports.unsubscribeToBCMD = unsubscribeToBCMD;

package/dist/node-red-ui-funcs.js

@@ -0,0 +1,180 @@
+/**
+ Copyright (C) 2016, IAConnects Technology Limited
+ All Rights Reserved
+
+ ALL INFORMATION CONTAINED HEREIN IS, AND REMAINS
+ THE PROPERTY OF IACONNECTS TECHNOLOGY LIMITED AND ITS SUPPLIERS,
+ IF ANY. THE INTELLECTUAL AND TECHNICAL CONCEPTS CONTAINED
+ HEREIN ARE PROPRIETARY TO IACONNECTS TECHNOLOGY LIMITED
+ AND ITS SUPPLIERS AND ARE PROTECTED BY TRADE SECRET OR COPYRIGHT LAW.
+ DISSEMINATION OF THIS INFORMATION OR REPRODUCTION OF THIS MATERIAL
+ IS STRICTLY FORBIDDEN UNLESS PRIOR WRITTEN PERMISSION IS OBTAINED
+ FROM IACONNECTS TECHNOLOGY LIMITED.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+ BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ **/
+
+'use strict';
+
+const _ = require('lodash');
+const excludedSpids = ['0004', '0012'];
+
+module.exports = {
+
+  // Promisified version of discover
+  discover (connection, uri) {
+    return new Promise((resolve, reject) => {
+      connection.discover(uri, (err, response) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  },
+
+  // Promisified version of getServiceConfig
+  getNodeConfig (connection, hid) {
+    return new Promise((resolve, reject) => {
+      connection.getNodeConfig(hid, (err, response) => {
+        if (!err) {
+          resolve(response);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  },
+
+  // Promisified version of getServiceConfig
+  getServiceConfig (connection, hid, sid) {
+    return new Promise((resolve, reject) => {
+      connection.getServiceConfig(hid, sid, (err, response) => {
+        if (!err) {
+          resolve(response);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  },
+
+  // Discover object by By PID
+  async discoverDevicesByPID (RED, connection, hid, spids, pid) {
+    let devices = [];
+    if (!hid || hid === '') {
+      hid = connection.service.hubId;
+    }
+    let services = null;
+    try {
+      services = await this.discover(connection, hid);
+    } catch (err) {
+      RED.log.error(`Discover devices failed (${hid}) - ${err.message}`);
+      throw new Error(`Discover devices failed (${hid}) - ${err.message}`);
+    }
+    for (let srvcLoop = 0; srvcLoop < services.data.length; srvcLoop++) {
+      if (services.data[srvcLoop].status === 'online' && (spids.length === 0 || spids.includes(services.data[srvcLoop].spid))) {
+        let insURI = `${hid}/${services.data[srvcLoop].id.split('/')[1]}/${pid}`;
+        try {
+          let instances = await this.discover(connection, insURI);
+          for (let insLoop = 0; insLoop < instances.data.length; insLoop++) {
+            let deviceURI = `${hid}/${services.data[srvcLoop].id.split('/')[1]}/${pid}/${instances.data[insLoop]}`;
+            let device = await this.discover(connection, deviceURI);
+            let resourcesByName = _.keyBy(device.data[0].resources, 'name');
+            let deviceName = resourcesByName['name'].pv;
+            if (deviceName !== '') {
+              devices.push(device.uri + ' ' + deviceName);
+            } else {
+              devices.push(device.uri);
+            }
+          }
+        } catch (err) {
+          RED.log.warn(`Discover devices failed (${insURI}) - ${err.message}`);
+        }
+      }
+    }
+    return devices;
+  },
+
+  // Discover services by SPID
+  async discoverServicesBySPID (RED, connection, hid, spid) {
+    if (!hid || hid === '') {
+      hid = connection.service.hubId;
+    }
+    let services = null;
+    try {
+      services = await this.discover(connection, hid);
+    } catch (err) {
+      RED.log.error(`Discover services failed (${hid}) - ${err.message}`);
+      throw new Error(`Discover services failed (${hid}) - ${err.message}`);
+    }
+    let srvcs = [];
+    for (let srvcLoop = 0; srvcLoop < services.data.length; srvcLoop++) {
+      if (services.data[srvcLoop].status === 'online' && services.data[srvcLoop].spid === spid) {
+        srvcs.push(`${hid}/${services.data[srvcLoop].id.split('/')[1]}`);
+      }
+    }
+    return srvcs;
+  },
+
+  // Get list of services
+  async getServiceList(connection, hid) {
+    try {
+      // Fetch information from node config
+      const nodeConfig = await this.getNodeConfig(connection, hid);
+      const servicesFromConfig = nodeConfig.data;
+      let services = [];
+      for (let i = 0; i < servicesFromConfig.length; i++) {
+        const spid = servicesFromConfig[i].id.split('/')[0];
+        if (!excludedSpids.includes(spid)) {
+          services.push({
+            id: servicesFromConfig[i].id,
+            spid,
+            sid: servicesFromConfig[i].id.split('/')[1],
+            uri: `${nodeConfig.uri}/${servicesFromConfig[i].id.split('/')[1]}`,
+            name: servicesFromConfig[i].name,
+            enabled: servicesFromConfig[i].enabled,
+            runAtStart: servicesFromConfig[i].runAtStart,
+          });
+        }
+      }
+      return services;
+    } catch (err) {
+      throw JSON.stringify(err);
+    }
+  },
+
+  // Get list og objects on given service
+  async getObjectList(connection, hid, sid) {
+    try {
+      let objectList = [];
+      const serviceResponse = await this.discover(connection, `${hid}/${sid}`);
+      const pids = [...new Set(serviceResponse.data)];
+      for (let i = 0; i < pids.length; i++) {
+        const inssResponse = await this.discover(connection, `${hid}/${sid}/${pids[i]}`);
+        const inss = inssResponse.data;
+        for (let j = 0; j < inss.length; j++) {
+          const objResponse = await this.discover(
+            connection,
+            `${hid}/${sid}/${pids[i]}/${inss[j]}`
+          );
+          objectList.push(objResponse.data[0]);
+        }
+      }
+      return objectList;
+    } catch (err) {
+      throw JSON.stringify(err);
+    }
+  },
+};