node-red-contrib-mobius-flow-base 2.5.86-beta.1 → 2.5.86-beta.101

package/dist/nodes/mobius-connection.js

@@ -0,0 +1,675 @@
+/**
+ 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';
+
+var _ = require('lodash');
+var tcpAPI = require('@ia/mobius-tcpip-service-api');
+var uiDeviceDiscovery = require('./node-red-ui-discover-devices');
+
+module.exports = function (RED) {
+  /**
+   * Helper function to match topic subscriptions
+   * @param  {string} topic        - The subscribed topic
+   * @param  {string} messageTopic - The topic in an actual message
+   * @return {boolean}             - True if the topics match, else false
+   */
+  function matchTopic(topic, messageTopic) {
+    if (topic === '#') {
+      return true;
+    }
+    // eslint-disable-next-line no-useless-escape
+    var regex = new RegExp(
+      '^' +
+        topic
+          .replace(/([\[\]\?\(\)\\\\$\^\*\.|])/g, '\\$1')
+          // eslint-disable-next-line no-useless-escape
+          .replace(/\+/g, '[^/]+')
+          .replace(/\/#$/, '(/.*)?') +
+        '$'
+    );
+    return regex.test(messageTopic);
+  }
+
+  /**
+   * Constructor for a Mobius service configuration node
+   * @param {Object} n - The node being created
+   */
+  function MobiusConnectionNode(n) {
+    RED.nodes.createNode(this, n);
+    this.host = n.host;
+    this.port = n.port;
+    this.psk = n.psk;
+    this.service = new tcpAPI.TCPIPServiceAPI(n.host, n.port, n.psk);
+    this.service.srvcAPI.removeAllListeners('cov');
+    this.service.srvcAPI.removeAllListeners('obcov');
+    this.service.srvcAPI.removeAllListeners('bcmd');
+    this.service.srvcAPI.on('cov', (response) => {
+      this.handleCOVEvents(response);
+    });
+    this.service.srvcAPI.on('obcov', (response) => {
+      this.handleObjectCOVEvents(response);
+    });
+    this.service.srvcAPI.on('bcmd', (response) => {
+      this.handleBCMDEvents(response);
+    });
+    var node = this;
+    node.serviceList = [];
+    node.hasStarted = false;
+    node.users = {};
+    node.resourceSubscriptions = new Map();
+    node.objectSubscriptions = new Map();
+    node.bcmdSubscriptions = new Map();
+    node.connected = false;
+    node.unsubscribeTimeout = 0;
+
+    // Connected to the mobius TCPIP spoke
+    // Update the status indicators
+    node.service.on('connected', () => {
+      this.log(`Connected to ${n.host} : ${n.port}`);
+      node.connected = true;
+      _.forEach(node.users, (user, id) => {
+        if (node.users.hasOwnProperty(id)) {
+          node.users[id].status({
+            fill: 'green',
+            shape: 'dot',
+            text: 'Connected',
+          });
+        }
+      });
+      // Subscribe to all COVs
+      this.resourceSubscriptions.forEach((subs, key) => {
+        node.service.srvcAPI.subscribeToCOV(key);
+      });
+      // Subscribe to all object COVs
+      node.objectSubscriptions.forEach((subs, key) => {
+        node.service.srvcAPI.subscribeToObjectCOV(key);
+      });
+      // Subscribe to all BCMDs
+      node.bcmdSubscriptions.forEach((subs, key) => {
+        node.service.srvcAPI.subscribeToBCMD(key);
+      });
+      // Discover all service IDs
+      node.service.srvcAPI.discover(node.service.srvcAPI.status.hubId, (err, response) => {
+        if (err) {
+          node.error('Mobius error discovering service list' + JSON.stringify(err));
+        } else {
+          node.serviceList = response.value;
+          node.hasStarted = true;
+        }
+      });
+    });
+
+    // Disconnected from the mobius TCPIP spoke
+    // Update the status indicators
+    node.service.on('disconnected', () => {
+      this.log(`Disconnected from ${n.host} : ${n.port}`);
+      node.connected = false;
+      for (var id in node.users) {
+        if (node.users.hasOwnProperty(id)) {
+          node.users[id].status({
+            fill: 'red',
+            shape: 'ring',
+            text: 'Disconnected',
+          });
+        }
+      }
+    });
+
+    /**
+     * Handle all resource COVs
+     * @param  {Object} response  - The resource that has changed
+     */
+    node.handleCOVEvents = function (response) {
+      let covsFired = [];
+      node.resourceSubscriptions.forEach((subs, key) => {
+        if (matchTopic(key, response.uri)) {
+          _.forEach(subs, (sub) => {
+            if (!_.includes(covsFired, sub.node)) {
+              covsFired.push(sub.node);
+              sub.cb(response);
+            }
+          });
+        }
+      });
+    };
+
+    /**
+     * Handle all object COVs
+     * @param  {Object} response  - The object that has changed
+     */
+    node.handleObjectCOVEvents = function (response) {
+      let covsFired = [];
+      node.objectSubscriptions.forEach((subs, key) => {
+        if (matchTopic(key, response.uri)) {
+          _.forEach(subs, (sub) => {
+            if (!_.includes(covsFired, sub.node)) {
+              covsFired.push(sub.node);
+              sub.cb(response);
+            }
+          });
+        }
+      });
+    };
+
+    /**
+     * Handle all BCMDs
+     * @param  {Object} response  - The BCMD
+     */
+    node.handleBCMDEvents = function (response) {
+      let bcmdsFired = [];
+      node.bcmdSubscriptions.forEach((subs, key) => {
+        if (matchTopic(key, response.uri)) {
+          _.forEach(subs, (sub) => {
+            if (!_.includes(bcmdsFired, sub.node)) {
+              bcmdsFired.push(sub.node);
+              sub.cb(response);
+            }
+          });
+        }
+      });
+    };
+
+    /**
+     * Select status text and colour of node status based on last active time
+     * @param {number} lastActiveTime - The node's last active time
+     * @returns Object containing status text and status colour
+     */
+    node.buildLastActiveTimeStatus = function (lastActiveTime) {
+      let response = {
+        text: 'Unknown',
+        colour: 'green',
+      };
+      const timeSinceLastActive = Date.now() - lastActiveTime;
+      if (timeSinceLastActive < 15 * 60000) {
+        response.text = 'Active less than 15 minutes ago';
+      }
+      if (timeSinceLastActive >= 15 * 60000 && timeSinceLastActive < 3 * 60 * 60000) {
+        response.text = 'Active less than 3 hours ago';
+      }
+      if (timeSinceLastActive >= 3 * 60 * 60000 && timeSinceLastActive < 12 * 60 * 60000) {
+        response.text = 'Active less than 12 hours ago';
+      }
+      if (timeSinceLastActive >= 12 * 60 * 60000 && timeSinceLastActive < 24 * 60 * 60000) {
+        response.text = 'Active less than 24 hours ago';
+      }
+      if (timeSinceLastActive > 24 * 60 * 60000 && lastActiveTime > 0) {
+        response.colour = 'grey';
+        response.text = 'Active more than 24 hours ago';
+      }
+      if (lastActiveTime === 0) {
+        response.colour = 'grey';
+        response.text = 'Never Active';
+      }
+      return {
+        fill: response.colour,
+        shape: 'dot',
+        text: response.text,
+      };
+    };
+
+    /**
+     * Update a given node's node status based on last active time
+     * @param  {Object} mobiusNode - The node whos status is to be updated
+     */
+    node.updateNodeStatus = function (mobiusNode) {
+      node.users[mobiusNode.id] = mobiusNode;
+      let newStatus = {
+        fill: 'green',
+        shape: 'dot',
+        text: 'Connected',
+      };
+      switch (node.users[mobiusNode.id].statusType) {
+        case 'timeSinceLastActive':
+          newStatus = node.buildLastActiveTimeStatus(node.users[mobiusNode.id].lastActiveTime);
+        case 'lastUri':
+          const uri = node.users[mobiusNode.id].latestUri;
+          if (uri !== '') {
+            newStatus = {
+              fill: 'green',
+              shape: 'dot',
+              text: uri,
+            };
+          }
+      }
+      node.users[mobiusNode.id].status(newStatus);
+    };
+
+    /**
+     * Update a given node's node latest URI record
+     * @param  {Object} mobiusNode - The node whos last URI record is to be updated
+     */
+    node.updateLatestUri = function (mobiusNode, uri) {
+      node.users[mobiusNode.id] = mobiusNode;
+      node.users[mobiusNode.id].latestUri = uri;
+      node.updateNodeStatus(mobiusNode);
+    };
+
+    /**
+     * Update a given node's node last active time
+     * @param  {Object} mobiusNode - The node whos last active time is to be updated
+     */
+    node.updateLastActiveTime = function (mobiusNode) {
+      node.users[mobiusNode.id] = mobiusNode;
+      node.users[mobiusNode.id].lastActiveTime = Date.now();
+      node.updateNodeStatus(mobiusNode);
+    };
+
+    /**
+     * Register a new Mobius node with this config node
+     * @param  {Object} mobiusNode - The new node to register
+     */
+    node.register = function (mobiusNode) {
+      node.users[mobiusNode.id] = mobiusNode;
+      if (node.connected) {
+        node.users[mobiusNode.id].status({
+          fill: 'green',
+          shape: 'dot',
+          text: 'Connected',
+        });
+      }
+      node.users[mobiusNode.id].lastActiveTime = 0;
+      node.users[mobiusNode.id].statusCheckLoop = setInterval(() => {
+        if (node.connected) {
+          node.updateNodeStatus(mobiusNode);
+        }
+      }, 60000);
+    };
+
+    /**
+     * Deregister a previously registered Mobius node
+     * @param  {[Object}  mobiusNode - The node to deregister
+     * @param  {Function} done       - A callback to be run by the node after it has been deregistered
+     */
+    node.deregister = function (mobiusNode, done) {
+      clearInterval(node.users[mobiusNode.id].statusCheckLoop);
+      delete node.users[mobiusNode.id];
+      if (node.service) {
+        try {
+          node.resourceSubscriptions.forEach((subs, key) => {
+            subs.forEach((sub, index) => {
+              if (mobiusNode.id === sub.node) {
+                subs.splice(index, 1);
+              }
+            });
+            if (subs.length === 0) {
+              node.service.srvcAPI.unsubscribeToCOV(key);
+              node.resourceSubscriptions.delete(key);
+            }
+          });
+          node.objectSubscriptions.forEach((subs, key) => {
+            subs.forEach((sub, index) => {
+              if (mobiusNode.id === sub.node) {
+                subs.splice(index, 1);
+              }
+            });
+            if (subs.length === 0) {
+              node.service.srvcAPI.unsubscribeToObjectCOV(key);
+              node.objectSubscriptions.delete(key);
+            }
+          });
+          node.bcmdSubscriptions.forEach((subs, key) => {
+            subs.forEach((sub, index) => {
+              if (mobiusNode.id === sub.node) {
+                subs.splice(index, 1);
+              }
+            });
+            if (subs.length === 0) {
+              node.service.srvcAPI.unsubscribeToBCMD(key);
+              node.bcmdSubscriptions.delete(key);
+            }
+          });
+        } catch (err) {
+          console.log(`Failed to unsubscribe from event: ${err.message}`);
+        }
+        return done();
+      }
+      done();
+    };
+
+    /**
+     * Register the close connection handler
+     */
+    node.on('close', (done) => {
+      if (node.connected) {
+        // Wait for all nodes to unsubscribe before terminating the connection
+        node.unsubscribeTimeout = 0;
+        var waitForCleanup = setInterval(() => {
+          if (
+            (node.resourceSubscriptions.size === 0 &&
+              node.objectSubscriptions.size === 0 &&
+              node.bcmdSubscriptions.size === 0) ||
+            node.unsubscribeTimeout > 50
+          ) {
+            clearInterval(waitForCleanup);
+            node.service.end();
+            node.service.once('disconnected', () => {
+              node.connected = false;
+              done();
+            });
+          }
+          node.unsubscribeTimeout++;
+        }, 100);
+      } else {
+        node.service.end();
+        done();
+      }
+    });
+
+    /**
+     * Discover the services on a hub, the object profiles used by a service or the instances of
+     * objects of a profile type.
+     * @param  {string} uri         - The identifier of the hub, service or profile
+     * @param  {Function} callback  - function(err, [object]) {}
+     * @return {string}             - A random unique request response ID. This is also returned in
+     *                                the response message event
+     */
+    node.discover = function (uri, callback) {
+      node.service.srvcAPI.discover(uri, callback);
+    };
+
+    /**
+     * Write a value to a resource
+     * @param  {string} uri         - The full URI of the resource
+     * @param  {Object} value       - The value to write
+     * @param  {number} priority    - The priority to write to
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.writeResourceValue = function (uri, value, priority, callback) {
+      node.service.srvcAPI.writeResourceValue(uri, value, priority, callback);
+    };
+
+    /**
+     * Write a value to multiple resources of a single object in a microservice
+     * Values can be anything as long as its type matches the resource's value type
+     * @param  {string} uri         - The object identifier
+     * @param  {Object} updates     - An array containing all of the resources to be updated
+     * @param  {Function} callback  - function(err, [object]) {}
+     * @return {string}             - A random unique request response ID. This is also returned in
+     *                                the response message event
+     */
+    node.multiWriteResourceValue = function (uri, updates, callback) {
+      node.service.srvcAPI.multiWriteResourceValue(uri, updates, callback);
+    };
+
+    /**
+     * Clear a resource's priority
+     * @param  {string} uri         - The full URI of the resource
+     * @param  {number} priority    - The priority to clear
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.clearResourcePriority = function (uri, priority, callback) {
+      node.service.srvcAPI.clearResourcePriority(uri, priority, callback);
+    };
+
+    /**
+     * Read a resource's value
+     * @param  {string} uri         - The full URI of the resource
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.readResource = function (uri, callback) {
+      node.service.srvcAPI.readResource(uri, callback);
+    };
+
+    /**
+     * Read a resource's value
+     * @param  {string} uri         - The full URI of the object
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.readObject = function (uri, callback) {
+      node.service.srvcAPI.readObject(uri, callback);
+    };
+
+    /**
+     * Filter objects by resource value
+     * @param  {string} uri         - The resource identifier
+     * @param  {array} pids         - The profile ids to search (as an array of four digit hex string)
+     * @param  {string} rid         - The id of the resource to test values against (as a two digit hex string)
+     * @param  {number} limit       - The maximum number of objects to return
+     * @param  {Function} func      - The function used to test the resource values
+     * @param  {Function} callback  - function(err, [object]) {}
+     */
+    node.filterObjectsByRIDValue = function (uri, pids, rid, limit, func, callback) {
+      node.service.srvcAPI.filterObjectsByRIDValue(uri, pids, rid, limit, func, callback);
+    };
+
+    /**
+     * Subscribe to a resource COV
+     * @param  {string} uri         - The full URI of the resource
+     * @param  {Object} ref         - The ID of the node that is registering for this COV
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.subscribeToCOV = function (uri, ref, callback) {
+      let sub = {
+        node: ref,
+        cb: callback,
+      };
+      if (!node.resourceSubscriptions.has(uri)) {
+        node.service.srvcAPI.subscribeToCOV(uri);
+        node.resourceSubscriptions.set(uri, [sub]);
+      } else {
+        //        _.pullAllBy(node.resourceSubscriptions.get(uri), [{node: ref}], node);
+        node.resourceSubscriptions.get(uri).push(sub);
+      }
+    };
+
+    /**
+     * Unsubscribe to a resource COV
+     * @param  {string} uri         - The full URI of the resource
+     * @param  {Object} ref         - The ID of the node that is registering for this COV
+     */
+    node.unsubscribeToCOV = function (uri, ref) {
+      if (node.resourceSubscriptions.has(uri)) {
+        node.resourceSubscriptions.set(
+          uri,
+          node.resourceSubscriptions.get(uri).filter((sub) => sub.node !== ref)
+        );
+      }
+      if (node.resourceSubscriptions.get(uri).length === 0) {
+        node.service.srvcAPI.unsubscribeToCOV(uri);
+        node.resourceSubscriptions.delete(uri);
+      }
+    };
+
+    /**
+     * Subscribe to an object COV
+     * @param  {string} uri         - The full URI of the object
+     * @param  {Object} ref         - The ID of the node that is registering for this COV
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.subscribeToObjectCOV = function (uri, ref, callback) {
+      let sub = {
+        node: ref,
+        cb: callback,
+      };
+      if (!node.objectSubscriptions.has(uri)) {
+        node.service.srvcAPI.subscribeToObjectCOV(uri);
+        node.objectSubscriptions.set(uri, [sub]);
+      } else {
+        //        _.pullAllBy(node.objectSubscriptions.get(uri), [{node: ref}], node);
+        node.objectSubscriptions.get(uri).push(sub);
+      }
+    };
+
+    /**
+     * Unsubscribe to an object COV
+     * @param  {string} uri         - The full URI of the object
+     * @param  {Object} ref         - The ID of the node that is registering for this COV
+     */
+    node.unsubscribeToObjectCOV = function (uri, ref) {
+      if (node.objectSubscriptions.has(uri)) {
+        node.objectSubscriptions.set(
+          uri,
+          node.objectSubscriptions.get(uri).filter((sub) => sub.node !== ref)
+        );
+      }
+      if (node.objectSubscriptions.get(uri).length === 0) {
+        node.service.srvcAPI.unsubscribeToObjectCOV(uri);
+        node.objectSubscriptions.delete(uri);
+      }
+    };
+
+    /**
+     * Subscribe to a broadcast command
+     * @param  {string} uri         - The full URI of the broadcast command
+     * @param  {Object} ref         - The ID of the node that is registering for this broadcast command event
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.subscribeToBCMD = function (uri, ref, callback) {
+      let sub = {
+        node: ref,
+        cb: callback,
+      };
+      if (!node.bcmdSubscriptions.has(uri)) {
+        node.service.srvcAPI.subscribeToBCMD(uri);
+        node.bcmdSubscriptions.set(uri, [sub]);
+      } else {
+        node.bcmdSubscriptions.get(uri).push(sub);
+      }
+    };
+
+    /**
+     * Unsubscribe to a broadcast command
+     * @param  {string} uri         - The full URI of the broadcast command
+     * @param  {Object} ref         - The ID of the node that is registering for this broadcast command event
+     */
+    node.unsubscribeToBCMD = function (uri, ref) {
+      if (node.bcmdSubscriptions.has(uri)) {
+        node.bcmdSubscriptions.set(
+          uri,
+          node.bcmdSubscriptions.get(uri).filter((sub) => sub.node !== ref)
+        );
+      }
+      if (node.bcmdSubscriptions.get(uri).length === 0) {
+        node.service.srvcAPI.unsubscribeToBCMD(uri);
+        node.bcmdSubscriptions.delete(uri);
+      }
+    };
+
+    /**
+     * Send broadcast command
+     * @param  {string} cid         - The command ID
+     * @param  {Object} commandData - An object containing the command data
+     */
+    node.sendBroadcastCommand = function (cid, commandData) {
+      node.service.srvcAPI.sendBroadcastCommand(cid, commandData);
+    };
+
+    /**
+     * Send direct command
+     * @param  {string} uri         - The full URI of the service to send the command to
+     * @param  {string} cid         - The command ID
+     * @param  {Object} commandData - An object containing the command data
+     * @param  {number} timeout     - Optional timeout in ms which overrides the default timeout if > 0
+     * @param  {Function} callback  - Callback when complete
+     */
+    node.sendDirectCommand = function (uri, cid, commandData, timeout, callback) {
+      node.service.srvcAPI.sendDirectCommand(uri, cid, commandData, timeout, callback);
+    };
+
+    /**
+     * Get service configuration
+     * @param {string} hid          - The hub ID of the hub the desired service is a child to
+     * @param {string} sid          - The service ID of the desired service
+     * @param {Function} callback   - Callback when complete
+     */
+    node.getServiceConfig = function (hid, sid, callback) {
+      node.service.srvcAPI.getServiceConfig(hid, sid, callback);
+    };
+
+    /**
+     * Update configuration of a given object
+     * @param {string} hid          - The hub ID of the hub the target object is a child of
+     * @param {string} sid          - The serbice ID of the service the target object is a child of
+     * @param {string} pid          - The profile ID of target object type
+     * @param {string} ins          - The object instance
+     * @param {Object} config       - The new object configuration, structure given by {ins: string, pid: string, uiname: string, rids: array}
+     * @param {Function} callback   - Callback when complete
+     */
+    node.updateObjectInServiceConfig = function (hid, sid, pid, ins, config, callback) {
+      node.service.srvcAPI.updateObjectInServiceConfig(hid, sid, pid, ins, config, callback);
+    };
+  }
+
+  RED.nodes.registerType('mobius connection', MobiusConnectionNode);
+
+  // Register the endpoint for node-red mobius object discovery in node-red node config pages
+  RED.httpAdmin.get(
+    '/mobjectdiscover',
+    RED.auth.needsPermission('serial.read'),
+    function (req, res) {
+      let conn = RED.nodes.getNode(req.query.mobius);
+      let hid = req.query.hid;
+      let spids = [];
+      try {
+        if (req.query.hasOwnProperty('spids')) {
+          spids = JSON.parse(req.query.spids);
+        }
+      } catch (e) {
+        spids = [];
+      }
+
+      let pid = req.query.pid;
+      if (conn === null || !conn.service.connected) {
+        RED.log.error('Discover objects failed - could not to connect to MOBiUS hub.');
+        throw new Error('Discover objects failed - could not to connect to MOBiUS hub.');
+      } else {
+        uiDeviceDiscovery
+          .discoverDevicesByPID(RED, conn, hid, spids, pid)
+          .then((devices) => {
+            res.json(devices);
+          })
+          .catch((err) => {
+            throw err;
+          });
+      }
+    }
+  );
+
+  // Register the endpoint for node-red mobius service discovery in node-red node config pages
+  RED.httpAdmin.get(
+    '/mservicediscover',
+    RED.auth.needsPermission('serial.read'),
+    function (req, res) {
+      let conn = RED.nodes.getNode(req.query.mobius);
+      let hid = req.query.hid;
+      let spid = req.query.spid;
+      if (conn === null || !conn.service.connected) {
+        RED.log.error('Discover services failed - could not to connect to MOBiUS hub.');
+        throw new Error('Discover services failed - could not to connect to MOBiUS hub.');
+      } else {
+        uiDeviceDiscovery
+          .discoverServicesBySPID(RED, conn, hid, spid)
+          .then((services) => {
+            res.json(services);
+          })
+          .catch((err) => {
+            throw err;
+          });
+      }
+    }
+  );
+};