@hurenkam/hue-services 0.6.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@hurenkam/hue-services",
+  "version": "0.6.0",
+  "description": "Custom node-red nodes for interfacing with philips hue devices",
+  "author": "Mark Hurenkamp",
+  "license": "Apache 2.0",
+  "maintainers": [
+    "Mark Hurenkamp <mark.hurenkamp@xs4all.nl>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hurenkam/node-red-hue-services.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hurenkam/node-red-hue-services/issues"
+  },
+  "scripts": {
+    "test": "nyc --reporter=text --reporter=html mocha \"test/**/*_spec.js\""
+  },
+  "keywords": [
+    "node-red",
+    "hue",
+    "clip"
+  ],
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "files": "src/files.js",
+      "debug": "src/debug.js",
+      "hue": "src/hue.js",
+      "all": "src/all.js"
+    }
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.1.3",
+    "debug": "^4.3.4",
+    "eventsource": "^2.0.2",
+    "limiter": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "node-red": "^2.2.3",
+    "node-red-node-test-helper": "^0.2.7",
+    "mocha": "^10.1.0",
+    "nyc": "^15.1.0",
+    "sinon": "^15.0.0"
+  }
+}

package/src/RestApi.js

@@ -0,0 +1,138 @@
+const axios = require('axios');
+const https = require('https');
+const limiter = require('limiter');
+
+const _error = require('debug')('error').extend('RestApi');
+const _warn  = require('debug')('warn').extend('RestApi');
+const _info  = require('debug')('info').extend('RestApi');
+const _trace = require('debug')('trace').extend('RestApi');
+
+class RestApi {
+    #ip;
+    #headers;
+    #requestQ;
+    #timeout;
+    #limiter;
+
+    #error;
+    #warn;
+    #info;
+    #trace;
+
+    constructor(name,ip,throttle,headers) {
+        this.#limiter = new limiter.RateLimiter(throttle);
+
+        this.#error = _error.extend("["+name+"]");
+        this.#warn  = _warn. extend("["+name+"]");
+        this.#info  = _info. extend("["+name+"]");
+        this.#trace = _trace.extend("["+name+"]");
+
+        this.#info("constructor()");
+
+        this.#ip = ip;
+        this.#headers = { "Content-Type": "application/json; charset=utf-8" };
+        if (headers) {
+            Object.keys(headers).forEach(key => {
+                this.#headers[key] = headers[key];
+            });
+        };
+
+        this.#requestQ = [];
+        this.#handleRequest();
+        this.#timeout = null;
+    }
+
+    destructor() {
+        this.#info("destructor()");
+        if (this.#timeout) {
+            clearTimeout(this.#timeout);
+            this.#timeout = null;
+        }
+
+        if (this.#requestQ) {
+            this.#requestQ.forEach(item => {
+                item.resolve = null;
+                item.reject = null;
+            });
+        }
+        this.#requestQ = null;
+    }
+
+    async #request(url, method="GET", data=null) {
+        var realurl = "https://" + this.#ip + url;
+        this.#info("_request(" + realurl + ", " + method + ",",data,")");
+
+        var request = {
+            "method": method,
+            "url": realurl,
+            "headers": this.#headers,
+            "httpsAgent": new https.Agent({ rejectUnauthorized: false })
+        }
+        if (data) {
+            request["data"] = data;
+        }
+
+        return axios(request);
+    }
+
+    #handleRequest() {
+        if ((this.#requestQ) && (this.#requestQ.length > 0)) {
+            this.#info("_handleRequest() pending: " + this.#requestQ.length);
+            var local = this;
+
+            var request = this.#requestQ.shift();
+            this.#request(request.url, request.method, request.data)
+            .then(async (result) => {
+                await local.#limiter.removeTokens(1,()=>{});
+                request.resolve(result.data);
+                this.#timeout = setTimeout(this.#handleRequest.bind(this), 0);
+            })
+            .catch((error) => {
+                this.#error("_handleRequest(" + request.url + ") error: ");
+                this.#error(error);
+                request.reject();
+
+                // back off for a few seconds, just in case we ran into a 429 error.
+                local.#timeout = setTimeout(local.#handleRequest.bind(local), 5000);
+            });
+
+        } else {
+            // if no request was pending, then check again soon
+            this.#timeout = setTimeout(this.#handleRequest.bind(this), 100);
+        }
+    }
+
+    get(url) {
+        this.#trace("get(" + url + ")");
+        var local = this;
+        return new Promise(function (resolve, reject) {
+            local.#requestQ.push({ url: url, method: "GET", data: null, resolve: resolve, reject: reject });
+        });
+    }
+
+    put(url, data) {
+        this.#trace("put(" + url + ")");
+        var local = this;
+        return new Promise(function (resolve, reject) {
+            local.#requestQ.push({ url: url, method: "PUT", data: data, resolve: resolve, reject: reject });
+        });
+    }
+
+    post(url, data) {
+        this.#trace(".post(" + url + ")");
+        var local = this;
+        return new Promise(function (resolve, reject) {
+            local.#requestQ.push({ url: url, method: "POST", data: data, resolve: resolve, reject: reject });
+        });
+    }
+
+    delete(url, data) {
+        this.#trace(".delete(" + url + ")");
+        var local = this;
+        return new Promise(function (resolve, reject) {
+            local.#requestQ.push({ url: url, method: "DELETE", data: data, resolve: resolve, reject: reject });
+        });
+    }
+}
+
+module.exports = RestApi;

package/src/all.html

@@ -0,0 +1,52 @@
+<script type="module">
+
+    import { BridgeConfigUI }         from "/src/ui/BridgeConfigUI.js";
+
+    import { ButtonUI }               from "/src/ui/ButtonUI.js";
+    import { DevicePowerUI }          from "/src/ui/DevicePowerUI.js";
+    import { GroupedLightUI }         from "/src/ui/GroupedLightUI.js";
+    import { LightUI }                from "/src/ui/LightUI.js";
+    import { LightLevelUI }           from "/src/ui/LightLevelUI.js";
+    import { MotionUI }               from "/src/ui/MotionUI.js";
+    import { RelativeRotaryUI }       from "/src/ui/RelativeRotaryUI.js";
+    import { TemperatureUI }          from "/src/ui/TemperatureUI.js";
+    import { SceneUI }                from "/src/ui/SceneUI.js";
+    import { ServiceUI }              from "/src/ui/ServiceUI.js";
+    import { ZigbeeConnectivityUI }   from "/src/ui/ZigbeeConnectivityUI.js";
+
+    var nodes = {
+        "BridgeConfigNode": BridgeConfigUI,
+
+        "ButtonNode": ButtonUI,
+        "DevicePowerNode": DevicePowerUI,
+        "GroupedLightNode": GroupedLightUI,
+        "LightNode": LightUI,
+        "LightLevelNode": LightLevelUI,
+        "MotionNode": MotionUI,
+        "TemperatureNode": TemperatureUI,
+        "ServiceNode": ServiceUI,
+        "SceneNode": SceneUI,
+        "RelativeRotaryNode": RelativeRotaryUI,
+        "ZigbeeConnectivityNode": ZigbeeConnectivityUI,
+    }
+
+    Object.keys(nodes).forEach((id) => {
+        var node = new nodes[id]();
+        var typeName = "@hurenkam/hue-services/"+id
+
+        var template = document.createElement("script");
+        template.setAttribute("type","text/html");
+        template.setAttribute("data-template-name",typeName);
+        template.innerHTML = node.ui();
+        document.documentElement.appendChild(template);
+
+        var help = document.createElement("script");
+        help.setAttribute("type","text/markdown");
+        help.setAttribute("data-help-name",typeName);
+        help.innerHTML = node.manual();
+        document.documentElement.appendChild(help);
+
+        RED.nodes.registerType(typeName,node.config);
+    });
+
+</script>

package/src/all.js

@@ -0,0 +1,42 @@
+module.exports = function(RED) {
+    "use strict";
+
+    const BaseNode = require('./nodes/BaseNode');
+    BaseNode.nodeAPI = RED;
+
+    const BridgeConfigNode = require('./nodes/BridgeConfigNode');
+
+    const ButtonNode = require('./nodes/ButtonNode');
+    const DevicePowerNode = require('./nodes/DevicePowerNode');
+    const GroupedLightNode = require('./nodes/GroupedLightNode');
+    const LightNode = require('./nodes/LightNode');
+    const LightLevelNode = require('./nodes/LightLevelNode');
+    const MotionNode = require('./nodes/MotionNode');
+    const RelativeRotaryNode = require('./nodes/RelativeRotaryNode');
+    const TemperatureNode = require('./nodes/TemperatureNode');
+    const SceneNode = require('./nodes/SceneNode');
+    const ServiceNode = require('./nodes/ServiceNode');
+    const ZigbeeConnectivityNode = require('./nodes/ZigbeeConnectivityNode');
+    
+
+    var nodes = {
+        "BridgeConfigNode": BridgeConfigNode,
+
+        "ButtonNode": ButtonNode,
+        "DevicePowerNode": DevicePowerNode,
+        "GroupedLightNode": GroupedLightNode,
+        "LightNode": LightNode,
+        "LightLevelNode": LightLevelNode,
+        "MotionNode": MotionNode,
+        "RelativeRotaryNode": RelativeRotaryNode,
+        "SceneNode": SceneNode,
+        "ServiceNode": ServiceNode,
+        "TemperatureNode": TemperatureNode,
+        "ZigbeeConnectivityNode": ZigbeeConnectivityNode,
+    }
+
+    Object.keys(nodes).forEach((id) => {
+        var typeName = "@hurenkam/hue-services/"+id
+        RED.nodes.registerType(typeName,nodes[id]);
+    });
+}

package/src/clip/ClipApi.js

@@ -0,0 +1,367 @@
+const events = require('events');
+const EventSource = require('eventsource');
+const RestApi = require('../RestApi');
+
+const Resource = require('./Resource');
+
+const _error = require('debug')('error').extend('ClipApi');
+const _warn  = require('debug')('warn').extend('ClipApi');
+const _info  = require('debug')('info').extend('ClipApi');
+const _trace = require('debug')('trace').extend('ClipApi');
+
+class ClipApi extends events.EventEmitter {
+    #restAPI;
+    #resources;
+    #startQ;
+    #isStarted;
+    #name;
+    #ip;
+    #key;
+    #eventSource;
+
+    #error;
+    #warn;
+    #info;
+    #trace;
+
+    #factory =  {
+        "behavior_script": Resource,
+        "behavior_instance": Resource,
+        "bridge": Resource,
+        "bridge_home": Resource,
+        "button": Resource,
+        "device": Resource,
+        "device_power": Resource,
+        "entertainment": Resource,
+        "entertainment_configuration": Resource,
+        "geolocation": Resource,
+        "grouped_light": Resource,
+        "homekit": Resource,
+        "light": Resource,
+        "light_level": Resource,
+        "matter": Resource,
+        "motion": Resource,
+        "relative_rotary": Resource,
+        "room": Resource,
+        "scene": Resource,
+        "temperature": Resource,
+        "zgp_connectivity": Resource,
+        "zigbee_connectivity": Resource,
+        "zigbee_device_discovery": Resource,
+        "zone": Resource
+    };
+
+    constructor(ip,key,name) {
+        super();
+
+        this.#name = name;
+        this.#ip = ip;
+        this.#key = key;
+        this.#resources = {};
+        this.#startQ = [];
+        this.#isStarted = false;
+
+        this.#error = _error.extend("["+name+"]");
+        this.#warn  = _warn. extend("["+name+"]");
+        this.#info  = _info. extend("["+name+"]");
+        this.#trace = _trace.extend("["+name+"]");
+
+        this.#info("constructor("+ip+","+key+","+name+")");
+
+        this.#restAPI = this._initRestApi();
+        this.#eventSource = this._initEventStream();
+        this._requestResources();
+    }
+
+    _initRestApi() {
+        var restAPI = new RestApi(
+            this.#name,
+            this.#ip,
+            { tokensPerInterval: 3, interval: "second" },
+            {"hue-application-key": this.#key}
+        );
+        return restAPI;
+    }
+
+    _restApi() {
+        return this.#restAPI;
+    }
+
+    _initEventStream() {
+        this.#info("_initEventStream()");
+
+        var url = "https://" + this.#ip + "/eventstream/clip/v2";
+        var eventSource = new EventSource(url, {
+            headers: { 'hue-application-key': this.#key },
+            https: { rejectUnauthorized: false },
+        });
+
+        eventSource.onmessage = (streammessage) => {
+            this._processStreamMessage(streammessage);
+        };
+
+        return eventSource;
+    }
+
+    _processStreamMessage(streammessage) {
+        this.#trace("_processStreamMessage()");
+
+        const messages = JSON.parse(streammessage.data);
+        messages.forEach((message) => {
+            message.data.forEach((event) => {
+                this._processStreamEvent(event);
+            });
+        });
+    }
+
+    _processStreamEvent(event) {
+        this.#trace("_processStreamEvent(",event,")");
+
+        if (this._isResourceRegistered(event.id)) {
+            this.getResource(event.id).onEvent(event);
+        }
+    }
+
+    _requestResources() {
+        this.#info("_requestResources()");
+        var instance = this;
+
+        var handleResourceList = async function(response) {
+            instance._processResources(response);
+        };
+
+        var handleError = async function(error) {
+            instance.#error("constructor()  error:", error.message,error.stack);
+        }
+
+        this._restApi().get("/clip/v2/resource")
+            .then(handleResourceList)
+            .catch(handleError);
+    }
+
+    _processResources(response) {
+        this.#info("_processResources()");
+
+        response.data.forEach((item) => {
+            this.#trace("constructor()  found resource:", item);
+
+            if (Object.keys(this.#factory).includes(item.type)) {
+                if (!this._isResourceRegistered(item.id)) {
+                    var resource = new this.#factory[item.type](item,this);
+                    this._registerResource(resource);
+                }
+            } else {
+                this.#warn("constructor(): Missing factory for type", item.type);
+            }
+        });
+
+        this.#startQ.forEach(resource => resource.start(this.#resources[resource.rid()]));
+        this.#isStarted = true;
+        this.#startQ = null;
+    }
+
+    _isResourceRegistered(uuid) {
+        return Object.keys(this.#resources).includes(uuid);
+    }
+
+    _registerResource(resource) {
+        this.#trace("#registerResource(",resource.id(),")");
+        this.#resources[resource.rid()] = resource;
+    }
+
+    _unregisterResource(resource) {
+        this.#trace("#unregisterResource()");
+        delete(this.#resources[resource.rid()]);
+    }
+
+    _stopEventStream() {
+        this.#info("_stopEventStream()");
+        if (this.#eventSource != null) {
+            this.#eventSource.onmessage = null;
+            this.#eventSource.close();
+        };
+
+        this.#eventSource = null;
+    }
+
+    requestStartup(resource) {
+        this.#trace("requestStartup()");
+        if (this.#isStarted) {
+            resource.start();
+        } else {
+            this.#startQ.push(resource);
+        }
+    }
+
+    destructor() {
+        this.#info("destructor()");
+        this.emit('stopped');
+        this.removeAllListeners();
+        if (this.#restAPI) {
+            this.#restAPI.destructor();
+            this.#restAPI = null;
+        }
+        this._stopEventStream();
+
+        var instance = this;
+        Object.keys(this.#resources).forEach((id) => {
+            var resource = instance.resource[id];
+            instance._unregisterResource(resource);
+            resource.destructor();
+        });
+
+        this.resources = null;
+    }
+
+    getResource(rid) {
+        if (this._isResourceRegistered(rid)) {
+            return this.#resources[rid];
+        } else {
+            this.#warn("getResource(",rid,"): Resource not found.");
+        }
+    }
+
+    get(rtype,rid) {
+        this.#trace("get(",rtype,",",rid,")");
+        return this._restApi().get("/clip/v2/resource/" + rtype + "/" + rid);
+    }
+
+    put(rtype,rid,data) {
+        this.#trace("put(",rtype,",",rid,",",data,")");
+        return this._restApi().put("/clip/v2/resource/" + rtype + "/" + rid, data);
+    }
+
+    post(rtype,rid,data) {
+        this.#trace("post(",rtype,",",rid,",",data,")");
+        return this._restApi().post("/clip/v2/resource/" + rtype + "/" + rid, data);
+    }
+
+    delete(rtype,rid,data) {
+        this.#trace("delete(",rtype,",",rid,",",data,")");
+        return this._restApi().delete("/clip/v2/resource/" + rtype + "/" + rid, data);
+    }
+
+    getSortedResourcesByTypeAndModel(type,models) {
+        this.#trace("getSortedResourcesByTypeAndModel(",type,",",models,")");
+        var instance = this;
+        var keys = Object.keys(instance.#resources).filter(function(key) {
+            var value = instance.#resources[key];
+            return ((value.rtype() == type))
+        });
+
+        var result = []
+        keys.forEach((key) => {
+            result.push(instance.#resources[key]);
+        });
+
+        result.sort(function (a, b) {
+            if (a.id() > b.id()) return 1;
+            if (a.id() < b.id()) return -1;
+            return 0;
+        });
+
+        //this.#trace("getSortedResourcesByTypeAndModel(",type,",",models,") options:",options);
+        return result.filter(function(resource) {
+            if (models) {
+                if ((resource.data().product_data) && (resource.data().product_data.model_id)) {
+                    return models.includes(resource.data().product_data.model_id);
+                } else {
+                    return false;
+                }
+            } else {
+                return true;
+            }
+        });
+    }
+
+    getSortedResourceOptions(type, models) {
+        this.#trace("getSortedOptions(" + type + "," + models + ")");
+
+        var options = [];
+        var resources = this.getSortedResourcesByTypeAndModel(type,models);
+        resources.forEach((resource) => {
+            options.push({ value: resource.rid(), label: (resource.name()? resource.name() : resource.id()) });
+        });
+
+        options.sort(function (a, b) {
+            if (a.label > b.label) return 1;
+            if (a.label < b.label) return -1;
+            return 0;
+        });
+
+        this.#trace("getSortedOptions(" + type + "," + models + ") options:",options);
+        return options;
+    }
+
+    getSortedTypeOptions() {
+        this.#trace("getSortedTypeOptions()");
+        var options = [];
+        var rtypes = [];
+        Object.values(this.#resources).forEach((resource)=>{
+            if (resource.owner()) {
+                if (!rtypes.includes(resource.rtype())) {
+                    rtypes.push(resource.rtype());
+                    options.push({ value: resource.rtype(), label: resource.rtype()});
+                }
+            }
+        });
+
+        options.sort(function (a, b) {
+            if (a.label > b.label) return 1;
+            return -1;
+        });
+
+        this.#trace("getSortedTypeOptions() options:",options);
+        return options;
+    }
+
+    getSortedOwnerOptions(rtype) {
+        this.#trace("getSortedOwnerOptions(" + rtype + ")");
+
+        var options = [];
+        var rids = [];
+        Object.values(this.#resources).forEach((resource)=>{
+            if (resource.services) {
+                Object.values(resource.services()).forEach((service) => {
+                    if ((service.rtype() == rtype) && (!rids.includes(resource.rid()))) {
+                        rids.push(resource.rid());
+                        options.push({ value: resource.rid(), label: resource.name() });
+                    }
+                });
+            }
+        });
+
+        options.sort(function (a, b) {
+            if (a.label > b.label) return 1;
+            if (a.label < b.label) return -1;
+            return 0;
+        });
+
+        this.#trace("getSortedOwnerOptions(" + rtype + ") options:",options);
+        return options;
+    }
+
+    getSortedServiceOptions(uuid,rtype) {
+        this.#trace("getSortedServiceOptions("+ uuid + "," + rtype + ")");
+
+        var options = [];
+        var owner = this.#resources[uuid];
+        var services = owner.services();
+        Object.values(services).forEach((service) => {
+            if (service.rtype() == rtype) {
+                options.push({ value: service.rid(), label: service.typeName() });
+            }
+        });
+
+        options.sort(function (a, b) {
+            if (a.label > b.label) return 1;
+            if (a.label < b.label) return -1;
+            return 0;
+        });
+
+        this.#trace("getSortedServiceOptions("+ uuid + "," + rtype + ") options:",options);
+        return options;
+    }
+}
+
+module.exports = ClipApi