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

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: 🐞 Bug report
+about: Create a report to help us improve
+title: '🐞 [Bug]: '
+labels: 'bug'
+assignees: ''
+---
+
+**Remember to include**
+
+- Customer
+- Software version
+- Where it was running (Cloud, balena, customer's own infra etc)
+- A good description of the bug and how to reproduce it
+- An estimate of the time to fix
+- Any other repos that may be affected

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: ✨ Feature request
+about: Suggest an idea for this project
+title: '✨ [Feature]: '
+labels: 'enhancement'
+assignees: ''
+---
+
+**Remember to include**
+
+- Customer
+- The reason for the new feature
+- A good description of the new feature
+- Any alternatives you have considered
+- An estimate of the time to fix
+- Any other repos that may be affected

package/.github/ISSUE_TEMPLATE/general.md

@@ -0,0 +1,7 @@
+---
+name: 🔖 General issue
+about: Any issue that is not a bug or feature request.
+title: ''
+labels: ''
+assignees: ''
+---

package/.github/workflows/build_publish.yml

@@ -0,0 +1,80 @@
+name: Build and Publish
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Get tag
+        id: source_tag
+        run: |
+          echo "SOURCE_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+
+      - name: Get package version
+        id: source_ver
+        run: |
+          echo "SOURCE_VER=v$(grep version ./package.json | sed -n 's/^.*"\([0-9][^"]*\)".*$/\1/p')" >> $GITHUB_OUTPUT
+
+      - name: Do tag and version match?
+        if: steps.source_tag.outputs.SOURCE_TAG != steps.source_ver.outputs.SOURCE_VER
+        run: |
+          echo ${{ steps.source_tag.outputs.SOURCE_TAG }}
+          echo ${{ steps.source_ver.outputs.SOURCE_VER }}
+          echo "::error Tag does not match version"
+          exit -1
+
+      - name: Setup node
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+          always-auth: true
+
+      - name: Build
+        run: |
+          npm install -g yarn
+          yarn install
+          tsc && mkdir -p dist/nodes
+          cp src/nodes/*.js dist/nodes/
+          cp src/nodes/*.html dist/nodes/
+          cp -r src/nodes/icons dist/nodes/
+          mkdir -p dist/nodes/common
+          cp src/mobsearch.js dist/nodes/common/
+          cp src/node-red-ui-funcs.js dist/
+        env:
+          GH_PKG_READ_TOKEN: ${{ secrets.GH_PKG_READ_TOKEN }}
+
+      - name: Publish package
+        run: |
+          npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_WRITE_TOKEN }}
+
+      - name: Create release
+        env:
+          RELEASE_TYPE: ${{ contains(steps.source_ver.outputs.SOURCE_VER, '-') }}
+          RELEASE_TAG: ${{ steps.source_ver.outputs.SOURCE_VER }}
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.MOBIUS_ACTION_TOKEN }}
+          script: |
+            try {
+              await github.rest.repos.createRelease({
+                draft: false,
+                generate_release_notes: true,
+                name: process.env.RELEASE_TAG,
+                owner: context.repo.owner,
+                prerelease: process.env.RELEASE_TYPE === 'true',
+                repo: context.repo.repo,
+                tag_name: process.env.RELEASE_TAG,
+              });
+            } catch (error) {
+              core.setFailed(error.message);
+            }

package/README.md

@@ -1,16 +1,10 @@
 # node-red-contrib-mobius-flow-base
-![Version](https://img.shields.io/badge/Version-v1.0.12-blue.svg)  
 
-Copyright 2016 [Interior Automation](http://www.interior-automation.co.uk) under the BSD-3-Clause license.
+Copyright 2016 [iaconnects](http://www.iaconnects.co.uk).
 
-[Node-RED](http://nodered.org) nodes to interact with Interior Automation's MOBiUS Flow.
+[Node-RED](http://nodered.org) nodes to interact with MOBiUSFlow.
 
-## Install
-Run the following command in the root directory of your Node-RED install:
-
-```npm install node-red-contrib-mobius-flow-base```
-
-This module currently requires access to Interior Automation's private NPM repository. This will be made public in the future once MOBiUS Flow is ready for public release.
+This module currently requires access to the iaconnects private NPM repository.
 
 ## Nodes
 
@@ -33,4 +27,4 @@ Clears the specified priority of resource.
 Subscribe to change of value events for an object
 
 ### Resource COV Node
-Subscribe to change of value events for a resource
+Subscribe to change of value events for a resource

package/dist/engine-api-calls.d.ts

@@ -0,0 +1,19 @@
+import { AxiosInstance } from 'axios';
+export declare const discover: (apiClient: AxiosInstance, uri: string, callback: Function) => Promise<void>;
+export declare const writeResource: (apiClient: AxiosInstance, uri: string, value: number | string | boolean, priority: number, callback: Function) => Promise<void>;
+export declare const writeMultiResource: (apiClient: AxiosInstance, uri: string, updates: {
+    r: string;
+    p: number;
+    v: number | string | boolean;
+}[], callback: Function) => Promise<void>;
+export declare const clearResource: (apiClient: AxiosInstance, uri: string, priority: number, callback: Function) => Promise<void>;
+export declare const readResource: (apiClient: AxiosInstance, uri: string, callback: Function) => Promise<void>;
+export declare const readObject: (apiClient: AxiosInstance, uri: string, callback: Function) => Promise<void>;
+export declare const sendBroadcastCommand: (apiClient: AxiosInstance, cid: string, commandData: any) => Promise<void>;
+export declare const sendDirectCommand: (apiClient: AxiosInstance, uri: string, cid: string, commandData: any, timeout: number, callback: Function) => Promise<void>;
+export declare const getServiceConfig: (apiClient: AxiosInstance, uri: string, callback: Function) => Promise<void>;
+export declare const updateObject: (apiClient: AxiosInstance, uri: string, config: any, callback: Function) => Promise<void>;
+export declare const filterObjectsByRIDValue: (apiClient: AxiosInstance, uri: string, pids: string[], rid: string, limit: number, func: (v: string | number | boolean) => boolean, callback: Function) => Promise<any>;
+export declare const getHubId: (apiClient: AxiosInstance, callback: Function) => Promise<void>;
+export declare const getNodeConfig: (apiClient: AxiosInstance, uri: string, callback: Function) => Promise<void>;
+export declare const changeAdminPassword: (apiClient: AxiosInstance, password: string, callback: Function) => Promise<void>;

package/dist/engine-api-calls.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeAdminPassword = exports.getNodeConfig = exports.getHubId = exports.filterObjectsByRIDValue = exports.updateObject = exports.getServiceConfig = exports.sendDirectCommand = exports.sendBroadcastCommand = exports.readObject = exports.readResource = exports.clearResource = exports.writeMultiResource = exports.writeResource = exports.discover = void 0;
+const discover = async (apiClient, uri, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/discover/${uri}`,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.discover = discover;
+const writeResource = async (apiClient, uri, value, priority, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'post',
+            url: `/mobius/object/resource/${uri}`,
+            data: {
+                value,
+                priority,
+            },
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.writeResource = writeResource;
+const writeMultiResource = async (apiClient, uri, updates, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'patch',
+            url: `/mobius/object/resource/${uri}`,
+            data: updates,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.writeMultiResource = writeMultiResource;
+const clearResource = async (apiClient, uri, priority, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'patch',
+            url: `/mobius/object/resource/clear/${uri}`,
+            data: {
+                priority,
+            },
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.clearResource = clearResource;
+const readResource = async (apiClient, uri, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/object/resource/${uri}`,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.readResource = readResource;
+const readObject = async (apiClient, uri, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/object/${uri}`,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.readObject = readObject;
+const sendBroadcastCommand = async (apiClient, cid, commandData) => {
+    try {
+        const response = await apiClient({
+            method: 'post',
+            url: `/mobius/command/${cid}`,
+            data: commandData,
+        });
+    }
+    catch (err) {
+        throw `Failed to send broadcast command: ${JSON.stringify(err)}`;
+    }
+};
+exports.sendBroadcastCommand = sendBroadcastCommand;
+const sendDirectCommand = async (apiClient, uri, cid, commandData, timeout, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'post',
+            url: `/mobius/directCommand/${cid}`,
+            data: {
+                uri,
+                commandData,
+                timeout,
+            },
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.sendDirectCommand = sendDirectCommand;
+const getServiceConfig = async (apiClient, uri, callback) => {
+    console.log(uri);
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/service/config/${uri}`,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.getServiceConfig = getServiceConfig;
+const updateObject = async (apiClient, uri, config, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'post',
+            url: `/mobius/object/config/${uri}`,
+            data: config,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.updateObject = updateObject;
+const filterObjectsByRIDValue = async (apiClient, uri, pids, rid, limit, func, callback) => {
+    try {
+        const discoveries = [];
+        for (let pid of pids) {
+            discoveries.push(apiClient({
+                method: 'get',
+                url: `/mobius/discover/${uri}/${pid}`,
+            }));
+        }
+        const pidGroups = (await Promise.all(discoveries)).map((response) => ({
+            uri: response.data.uri,
+            inss: response.data.data,
+        }));
+        const objectUris = [];
+        for (let pidGroup of pidGroups) {
+            for (let ins of pidGroup.inss) {
+                objectUris.push(`${pidGroup.uri}/${ins}`);
+            }
+        }
+        const objects = [];
+        for (let objectUri of objectUris) {
+            const object = await apiClient({
+                method: 'get',
+                url: `/mobius/object/${objectUri}`,
+            });
+            const resource = object.data.data.resources.find((r) => r.rid === rid);
+            if (func(resource?.pv)) {
+                objects.push(object.data.data);
+            }
+            if (objects.length >= limit) {
+                return callback(null, { uri, ts: new Date().toISOString(), value: objects });
+            }
+        }
+        return callback(null, { uri, ts: new Date().toISOString(), value: objects });
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.filterObjectsByRIDValue = filterObjectsByRIDValue;
+const getHubId = async (apiClient, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/admin/settings`,
+        });
+        callback(null, response.data.data.mobiusFlow.hubID.runtime);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.getHubId = getHubId;
+const getNodeConfig = async (apiClient, uri, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/mobius/node/config/${uri}`,
+        });
+        callback(null, response.data);
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.getNodeConfig = getNodeConfig;
+const changeAdminPassword = async (apiClient, password, callback) => {
+    try {
+        const response = await apiClient({
+            method: 'get',
+            url: `/auth/user/admin`,
+        });
+        const adminUserId = response.data;
+        await apiClient({
+            method: 'patch',
+            url: `/auth/user/password/${adminUserId}`,
+            data: {
+                password,
+            },
+        });
+        callback(null, 'Ok');
+    }
+    catch (err) {
+        callback(err);
+    }
+};
+exports.changeAdminPassword = changeAdminPassword;

package/dist/engine-api-client.d.ts

@@ -0,0 +1,8 @@
+export declare let tokens: null | {
+    token: string;
+    refreshToken: string;
+};
+export declare let loggedIn: boolean;
+export declare const getApiClient: (protocol: 'http' | 'https', host: string, port: number, username: string, password: string) => import("axios").AxiosInstance;
+export declare const setLoggedIn: (value: boolean) => void;
+export declare const closeApiClient: () => void;

package/dist/engine-api-client.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeApiClient = exports.setLoggedIn = exports.getApiClient = exports.loggedIn = exports.tokens = void 0;
+const axios_1 = __importDefault(require("axios"));
+const engine_websocket_1 = require("./engine-websocket");
+exports.tokens = null;
+exports.loggedIn = false;
+let reloginInterval = null;
+const getApiClient = (protocol, host, port, username, password) => {
+    (0, engine_websocket_1.setWebSocketConnectParams)(host, port, protocol);
+    //const baseURL = `http://localhost:8443/api/v1`;
+    const baseURL = `${protocol}://${host}:${port}/api/v1`;
+    const client = axios_1.default.create({
+        baseURL: baseURL,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+    reloginInterval = setInterval(() => {
+        if (!exports.loggedIn) {
+            login();
+        }
+    }, 30000);
+    // Add auth headers to all axios calls
+    client.interceptors.request.use((config) => {
+        if (!config.url?.endsWith('/auth/login')) {
+            if (exports.tokens && config.headers) {
+                config.headers['Authorization'] = `Bearer ${exports.tokens.token}`;
+            }
+        }
+        return config;
+    }, (error) => {
+        Promise.reject(error);
+    });
+    const login = async () => {
+        console.log('Attempting Mobius Engine API Login');
+        try {
+            const response = await client({
+                method: 'post',
+                url: '/auth/login',
+                data: {
+                    username,
+                    password,
+                },
+            });
+            exports.tokens = response.data;
+            exports.loggedIn = true;
+            console.log('Logged in to Mobius Engine API');
+            (0, engine_websocket_1.connectToWebSocket)();
+        }
+        catch (e) {
+            exports.loggedIn = false;
+        }
+    };
+    login();
+    const refresh = async () => {
+        if (!exports.tokens) {
+            return;
+        }
+        try {
+            const response = await client({
+                method: 'post',
+                url: '/auth/refresh',
+                data: {
+                    refreshToken: exports.tokens.refreshToken,
+                },
+            });
+            exports.tokens = response.data;
+            exports.loggedIn = true;
+        }
+        catch {
+            exports.loggedIn = false;
+            login();
+        }
+    };
+    setInterval(refresh, 1000 * 60 * 5);
+    client.interceptors.response.use((res) => {
+        return res;
+    }, async (error) => {
+        if (!error.response) {
+            // notify
+        }
+        if (!error.config.url?.endsWith('/auth/login')) {
+            console.log(`Logged Out: ${JSON.stringify(error.response)}`);
+            exports.loggedIn = false;
+            exports.tokens = null;
+            login();
+        }
+        return Promise.reject(error);
+    });
+    return client;
+};
+exports.getApiClient = getApiClient;
+const setLoggedIn = (value) => {
+    exports.loggedIn = value;
+};
+exports.setLoggedIn = setLoggedIn;
+const closeApiClient = () => {
+    if (reloginInterval) {
+        clearInterval(reloginInterval);
+    }
+};
+exports.closeApiClient = closeApiClient;

package/dist/engine-websocket.d.ts

@@ -0,0 +1,60 @@
+type WebSocketTopics = 'authorize' | 'subscribe' | 'unsubscribe' | 'connected' | 'authorized' | 'object-cov' | 'resource-cov' | 'service-status' | 'broadcast-command' | 'error' | 'ping' | 'pong';
+type Events = 'connected' | 'disconnected';
+export declare const setWebSocketConnectParams: (hostname: string, port: number, protocol: 'http' | 'https') => void;
+export declare const on: (eventName: Events, callback: Function) => void;
+export declare function registerCallback(topic: WebSocketTopics, callback: Function): void;
+export declare function clearAllCallbacks(): void;
+export declare const killWebSocket: () => void;
+/**
+ * Connect to the Mobius WebSocket API
+ * This method will connect to the Mobius WebSocket API and authenticate with the API token
+ */
+export declare const connectToWebSocket: () => void;
+/**
+ * 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
+ */
+export declare const disconnectFromWebSocket: () => void;
+/**
+ * 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
+ */
+export declare const subscribeToObjectCOV: (uri: string) => void;
+/**
+ * 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
+ */
+export declare const unsubscribeToObjectCOV: (uri: string) => void;
+/**
+ * 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
+ */
+export declare const subscribeToResourceCOV: (uri: string) => void;
+/**
+ * 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
+ */
+export declare const unsubscribeToResourceCOV: (uri: string) => void;
+/**
+ * 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
+ */
+export declare const subscribeToBCMD: (uri: string) => void;
+/**
+ * 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
+ */
+export declare const unsubscribeToBCMD: (uri: string) => void;
+export {};