@hurenkam/hue-services 0.6.0

package/src/clip/Resource.js

@@ -0,0 +1,132 @@
+const events = require('events');
+
+const _error = require('debug')('error').extend('Resource');
+const _warn  = require('debug')('warn').extend('Resource');
+const _info  = require('debug')('info').extend('Resource');
+const _trace = require('debug')('trace').extend('Resource');
+
+class Resource extends events.EventEmitter {
+    #clip;
+    #data;
+
+    #error;
+    #warn;
+    #info;
+    #trace;
+
+    constructor(data,clip) {
+        super();
+        this.#data = data;
+        this.#clip = clip;
+
+        this.#error = _error.extend("["+this.id()+"]");
+        this.#warn  = _warn. extend("["+this.id()+"]");
+        this.#info  = _info. extend("["+this.id()+"]");
+        this.#trace = _trace.extend("["+this.id()+"]");
+
+        this.#info("constructor()");
+    }
+
+    destructor() {
+        this.#info("destructor()");
+        this.removeAllListeners();
+        this.#clip = null;
+        this.#data = null;
+    }
+
+    clip() {
+        return this.#clip;
+    }
+
+    data() {
+        return this.#data;
+    }
+
+    id() {
+        var id = this.rtype()+"/"+this.rid()
+        var name = this.name();
+        return id + (name? " ("+name+")":"");
+    }
+
+    rid() {
+        return this.data().id;
+    }
+
+    rtype() {
+        return this.data().type;
+    }
+
+    owner() {
+        var result = null;
+
+        if (this.data().owner) {
+            result = this.clip().getResource(this.data().owner.rid);
+        }
+
+        return result;
+    }
+
+    name() {
+        if ((this.data().metadata) && (this.data().metadata.name))
+            return this.data().metadata.name;
+
+        if ((this.owner()) && (this.owner().name())) {
+            return this.owner().name();
+        }
+
+        return null;
+    }
+
+    typeName() {
+        var result = this.rtype();
+        if ((this.#data.metadata) && (this.#data.metadata.control_id))
+            result += this.#data.metadata.control_id;
+        return result;
+    }
+
+    services() {
+        this.#info("services()");
+        var result = {};
+        if ((this.data()) && (this.data().services))
+        {
+            this.data().services.forEach(service => {
+                this.#trace("services()  service:",service);
+                var resource = this.clip().getResource(service.rid);
+                if (resource) {
+                    result[service.rid] = resource;
+                }
+            });
+        }
+        return result;
+    }
+
+    get() {
+        this.#trace("get()");
+        return this.clip().get(this.rtype(),this.rid());
+    }
+
+    put(data) {
+        this.#trace("put(",data,")");
+        this.clip().put(this.rtype(),this.rid(), data);
+    }
+
+    onEvent(event) {
+        this.#trace("onEvent()",event);
+        this.updateStatus(event);
+        this.emit('update',event);
+    }
+
+    updateStatus(event) {
+        this.#trace("updateStatus()",event);
+        const blacklist = ["id", "id_v1", "owner", "type"];
+
+        var instance = this;
+        Object.keys(event).forEach((key) => {
+            if (!blacklist.includes(key)) {
+                instance.#data[key] = event[key];
+            }
+        });
+    }
+}
+
+module.exports = Resource;

package/src/debug.js

@@ -0,0 +1,56 @@
+// ====================
+// Manage debug logging
+// ====================
+
+module.exports = function (RED) {
+
+    const debug = require('debug');
+
+    // GET: Retrieves current setting, but beware:
+    //      There seems to be a bug in the debug module 
+    //      where it not always accepts the same namespaces
+    //      as input causing the GET sometimes to error and
+    //      leave debugging disabled alltogether.
+    //      See https://github.com/debug-js/debug/issues/918
+    //
+    //      Use the following command to retrieve the settings:
+    //      curl -i -H "Accept: application/json" 'localhost:1880/debug'
+    RED.httpAdmin.get('/debug', function (req, res) {
+        console.log("/debug",req.method);
+        var namespaces = debug.disable();
+        console.log("/debug",req.method,namespaces);
+        debug.enable(namespaces);
+        res.end(JSON.stringify(Object({ "namespaces": namespaces })));
+    });
+
+    // POST: Using POST you can set the debug level to a new
+    //       namespaces setting.
+    //       e.g. use the following command to enable error and warning logging:
+    //       curl -i -H "Accept: application/json" 'localhost:1880/debug' -d "namespaces='error:*,warn:*'"
+    RED.httpAdmin.post('/debug', function (req, res) {
+        console.log("/debug",req.method,req.body);
+
+        if (req.method=="POST") {
+            var namespaces = req.body.namespaces;
+            if (namespaces) {
+                debug.enable(namespaces);
+                res.end(JSON.stringify(Object({ "namespaces": namespaces })));
+            } else {
+                res.end(JSON.stringify(Object({ "error": "Missing namespaces in request." })));
+            }
+            return;
+        }
+
+        res.end(JSON.stringify(Object({ "error": "Only GET and PUT are supported." })));
+    });
+
+    // DELETE: Using DELETE you can disable the debug logging.
+    //         e.g. use the following command:
+    //         curl -i -H "Accept: application/json" 'localhost:1880/debug' -X "DELETE"
+    RED.httpAdmin.delete('/debug', function (req, res) {
+        console.log("/debug",req.method);
+        var namespaces = debug.disable();
+        console.log("/debug",req.method,namespaces);
+        res.end(JSON.stringify(Object({ "namespaces": namespaces })));
+    });
+}

package/src/files.js

@@ -0,0 +1,12 @@
+module.exports = function (RED) {
+    /**
+     * Enable http route to static ui files
+     */
+     RED.httpAdmin.get('/src/ui/*', function (req, res) {
+        var options = {
+            root: __dirname + '/ui/',
+            dotfiles: 'deny'
+        };
+        res.sendFile(req.params[0], options);
+     });
+}

package/src/hue.js

@@ -0,0 +1,98 @@
+// ===================
+// Manage bridge calls
+// ===================
+
+const _error = require('debug')('error').extend('hue');
+const _warn  = require('debug')('warn').extend('hue');
+const _info  = require('debug')('info').extend('hue');
+const _trace = require('debug')('trace').extend('hue');
+
+module.exports = function (RED) {
+    const BridgeConfigNode = require('./nodes/BridgeConfigNode');
+
+    RED.httpAdmin.get('/BridgeConfigNode/DiscoverBridges', async function (req, res, next) {
+        _info("/DiscoverBridges");
+        _trace(req.query);
+        var options = [];
+    
+        BridgeConfigNode.DiscoverBridges()
+        .then(function(data) {
+            if (data) {
+                data.forEach((element) => {
+                    options.push({ label: element.name, value: element.internalipaddress })
+                });
+            }
+            res.end(JSON.stringify(Object(options)));
+        })
+        .catch(function(error) {
+            _error("/DiscoverBridges  Error:",error.message,error.stack);
+            res.end(JSON.stringify(Object(options)));
+        });
+    });
+    
+    RED.httpAdmin.get('/BridgeConfigNode/AcquireApplicationKey', async function (req, res, next) {
+        _info("/AcquireApplicationKey");
+        _trace(req.query);
+    
+        if (!req.query.ip) {
+            return res.status(500).send("Missing bridge ip.");
+        }
+        else {
+            BridgeConfigNode.AcquireApplicationKey(req.query.ip)
+            .then(function(data) {
+                _trace("/AcquireApplicationKey Key:",data);
+                res.end(JSON.stringify(Object({ key: data })));
+            })
+            .catch(function(error) {
+                _error("/AcquireApplicationKey Error:",error.message,error.stack);
+                res.end(JSON.stringify(Object({ error: error })));
+            });
+        }
+    });
+    
+    RED.httpAdmin.get('/BridgeConfigNode/GetBridgeOptions', async function (req, res, next) {
+        _info("/GetBridgeOptions");
+        _trace(req.query);
+        var options = [];
+    
+        Object.keys(BridgeConfigNode.bridges()).forEach((key) => {
+            options.push({ label: BridgeConfigNode.bridges()[key].name, value: BridgeConfigNode.bridges()[key].id });
+        });
+    
+        res.end(JSON.stringify(Object(options)));
+    });
+    
+    RED.httpAdmin.get('/BridgeConfigNode/GetSortedResourceOptions', async function (req, res, next) {
+        _info("/GetSortedResourceOptions");
+        _trace(req.query);
+        var clip = BridgeConfigNode.bridges()[req.query.bridge_id].instance.clip();
+        var options = clip.getSortedResourceOptions(req.query.type, req.query.models);
+        res.end(JSON.stringify(Object(options)));
+    });
+    
+    RED.httpAdmin.get('/BridgeConfigNode/GetSortedTypeOptions', async function (req, res, next) {
+        _info("/GetSortedTypeOptions");
+        _trace(req.query);
+        var clip = BridgeConfigNode.bridges()[req.query.bridge_id].instance.clip();
+        var options = clip.getSortedTypeOptions();
+        res.end(JSON.stringify(Object(options)));
+    });
+    
+    
+    RED.httpAdmin.get('/BridgeConfigNode/GetSortedOwnerOptions', async function (req, res, next) {
+        _info("/GetSortedOwnerOptions");
+        _trace(req.query);
+        var clip = BridgeConfigNode.bridges()[req.query.bridge_id].instance.clip();
+        var options = clip.getSortedOwnerOptions(req.query.rtype);
+        res.end(JSON.stringify(Object(options)));
+    });
+    
+    RED.httpAdmin.get('/BridgeConfigNode/GetSortedServiceOptions', async function (req, res, next) {
+        _info("/GetSortedServiceOptions");
+        _trace(req.query);
+        var clip = BridgeConfigNode.bridges()[req.query.bridge_id].instance.clip();
+        var options = clip.getSortedServiceOptions(req.query.owner,req.query.rtype);
+        res.end(JSON.stringify(Object(options)));
+    });
+    
+}

package/src/nodes/BaseNode.js

@@ -0,0 +1,98 @@
+const _error = require('debug')('error').extend('BaseNode');
+const _warn  = require('debug')('warn').extend('BaseNode');
+const _info  = require('debug')('info').extend('BaseNode');
+const _trace = require('debug')('trace').extend('BaseNode');
+
+class BaseNode {
+    static nodeAPI = null;
+    #onInput;
+    #onClose;
+
+    #error;
+    #warn;
+    #info;
+    #trace;
+
+    constructor(config) {
+        this.config = config;
+        
+        this.#error = _error.extend("["+this.logid()+"]");
+        this.#warn  = _warn. extend("["+this.logid()+"]");
+        this.#info  = _info. extend("["+this.logid()+"]");
+        this.#trace = _trace.extend("["+this.logid()+"]");
+
+        this.#info("constructor()");
+        BaseNode.nodeAPI.nodes.createNode(this,config);
+        var instance = this;
+
+        this.#onInput = function (msg) {
+            try {
+                instance.onInput(msg);
+            } catch (error) {
+                this.#error(error.message,error.stack);
+            }
+        }
+    
+        this.#onClose = function () {
+            try {
+                instance.destructor();
+            } catch (error) {
+                this.#error(error.message,error.stack);
+            }
+        }
+    
+        this.on('input', this.#onInput);
+        this.on('close', this.#onClose);
+    }
+
+    logid() {
+        return (this.config)? ((this.config.name)? this.config.name: this.config.id) : "<?>";
+    }
+
+    getStatusFill() {
+        this.#trace("getStatusFill()");
+        return null;
+    }
+
+    getStatusText() {
+        this.#trace("getStatusText()");
+        return null;
+    }
+
+    getStatusShape() {
+        this.#trace("getStatusShape()");
+        return null;
+    }
+
+    updateStatus() {
+        this.#trace("updateStatus()");
+        try {
+            var fill =  this.getStatusFill();
+            var shape = this.getStatusShape();
+            var text =  this.getStatusText();
+
+            if ((shape) && (!fill)) fill = "grey";
+            if ((fill) && (!shape)) shape = "dot";
+
+            this.status({
+                fill:  fill,
+                shape: shape,
+                text:  text
+            });
+        } catch (error) {
+            this.#error(error.message,error.stack);
+        }
+    }
+
+    onInput(msg) {
+        this.#trace("onInput(",msg,")");
+    }
+
+    destructor() {
+        this.#info("destructor()");
+        this.off('input',this.#onInput);
+        this.off('close',this.#onClose);
+    }
+}
+
+module.exports = BaseNode;

package/src/nodes/BridgeConfigNode.js

@@ -0,0 +1,144 @@
+var bridges = {};
+
+const ClipApi = require('../clip/ClipApi');
+const BaseNode = require('./BaseNode');
+const axios = require('axios');
+const https = require('https');
+
+const _error = require('debug')('error').extend('BridgeConfigNode');
+const _warn  = require('debug')('warn').extend('BridgeConfigNode');
+const _info  = require('debug')('info').extend('BridgeConfigNode');
+const _trace = require('debug')('trace').extend('BridgeConfigNode');
+
+class BridgeConfigNode extends BaseNode {
+    #onClose;
+    #onClipError;
+    #clip;
+
+    #error;
+    #warn;
+    #info;
+    #trace;
+
+    static bridges () { return bridges; }
+
+    constructor(config) {
+        super(config);
+        BaseNode.nodeAPI.nodes.createNode(this, config);
+
+        this.#error = _error.extend("["+this.logid()+"]");
+        this.#warn  = _warn. extend("["+this.logid()+"]");
+        this.#info  = _info. extend("["+this.logid()+"]");
+        this.#trace = _trace.extend("["+this.logid()+"]");
+
+        this.#info("constructor()");
+        var instance = this;
+
+        bridges[this.id] = { id: this.id, name: config.name, instance: this };
+        this.#clip = this._constructClip(config.ip,config.key,config.name);
+
+        this.#onClose = function() {
+            try {
+                instance.destructor();
+            } catch (error) {
+                instance.#error(error.message,error.stack);
+            }
+        }
+        this.on('close', this.#onClose);
+    }
+
+    destructor() {
+        this._destructClip();
+        super.destructor();
+    }
+
+    _constructClip(ip,key,name) {
+        var instance = this;
+        this.#onClipError = function(event) {
+            instance.#error("onClipError()",error);
+        }
+
+        var clip = new ClipApi(ip,key,name);
+        clip.on('error',this.#onClipError);
+        return clip;
+    }
+
+    _destructClip() {
+        this.#clip.destructor();
+        this.#clip = null;
+    }
+
+    clip() {
+        return this.#clip;
+    }
+
+    requestStartup(resource) {
+        if (this.clip()) {
+            this.clip().requestStartup(resource);
+        }
+    }
+
+    /* istanbul ignore next */
+    static async _axios(request) {
+        return axios(request);
+    }
+
+    static async DiscoverBridges() {
+        _info("DiscoverBridges()");
+        var result = [];
+
+        var response = await BridgeConfigNode._axios({
+            "method": "GET",
+            "url": "https://discovery.meethue.com",
+            "headers": { "Content-Type": "application/json; charset=utf-8" },
+            "httpsAgent": new https.Agent({ rejectUnauthorized: false })
+        });
+
+        const promises = response.data.map(async element => {
+            const config = await BridgeConfigNode._axios({
+                "method": "GET",
+                "url": "https://" + element.internalipaddress + "/api/config",
+                "headers": { "Content-Type": "application/json; charset=utf-8" },
+                "httpsAgent": new https.Agent({ rejectUnauthorized: false })
+            });
+            config.data.internalipaddress = element.internalipaddress;
+            return config
+        });
+        const configs = await Promise.all(promises);
+
+        configs.forEach((config) => {
+            result.push(config.data);
+        });
+
+        return result;
+    }
+
+    static async AcquireApplicationKey(ip) {
+        _info("AcquireApplicationKey("+ip+")");
+        return new Promise(function (resolve, reject) {
+            var id = "BridgeConfig (" + Math.floor((Math.random() * 100) + 1) + ")";
+            var request = {
+                "method": "POST",
+                "url": "http://" + ip + "/api",
+                "headers": { "Content-Type": "application/json; charset=utf-8" },
+                "data": { "devicetype": id },
+                "httpsAgent": new https.Agent({ rejectUnauthorized: false })
+            }
+
+            BridgeConfigNode._axios(request)
+            .then(function (response) {
+                _trace("AcquireApplicationKey("+ip+")", response.data);
+                if (Object.keys(response.data[0]).includes("success")) {
+                    resolve(response.data[0].success.username);
+                } else {
+                    reject(response.data[0].error);
+                }
+            })
+            .catch(function (error) {
+                reject(error);
+            });
+        });
+    }
+}
+
+module.exports = BridgeConfigNode;

package/src/nodes/ButtonNode.js

@@ -0,0 +1,51 @@
+ResourceNode = require("./ResourceNode");
+
+class ButtonNode extends ResourceNode {
+    #fill;
+
+    #info;
+    #trace;
+
+    constructor(config) {
+        super(config);
+
+        this.#info = require('debug')('info').extend('ButtonNode').extend("["+this.logid()+"]");
+        this.#trace = require('debug')('trace').extend('ButtonNode').extend("["+this.logid()+"]");
+        this.#info("constructor()");
+
+        this.#fill = "grey";
+    }
+
+    onUpdate(event) {
+        this.#trace("onUpdate(",event,")");
+        this.#fill = "blue";
+        
+        var instance = this;
+        setTimeout(()=>{
+            instance.#fill = "grey";
+            instance.updateStatus();
+        },1000);
+
+        this.updateStatus();
+        super.onUpdate(event);
+    }
+
+    updateStatus() {
+        this.#trace("updateStatus()");
+
+        var fill = this.#fill;
+        var shape = "dot";
+        var text = "";
+
+        var resource = this.resource();
+        if ((resource) && (resource.data()) && (resource.data().button)) {
+            if (resource.data().button.last_event!=null) {
+                text = resource.data().button.last_event;
+            }
+        }
+
+        this.status({fill: fill, shape: shape, text: text});
+    }
+}
+
+module.exports = ButtonNode;

package/src/nodes/DevicePowerNode.js

@@ -0,0 +1,37 @@
+ResourceNode = require("./ResourceNode");
+
+class DevicePowerNode extends ResourceNode {
+    #info;
+    #trace;
+
+    constructor(config) {
+        super(config);
+        this.#info = require('debug')('info').extend('DevicePowerNode').extend("["+this.logid()+"]");
+        this.#trace = require('debug')('trace').extend('DevicePowerNode').extend("["+this.logid()+"]");
+        this.#info("constructor()");
+    }
+
+    onUpdate(event) {
+        this.#trace("onUpdate(",event,")");
+        this.updateStatus();
+        super.onUpdate(event);
+    }
+
+    updateStatus() {
+        this.#trace("updateStatus()");
+
+        var fill = "grey";
+        var shape = "dot";
+        var text = "";
+
+        var resource = this.resource();
+        if ((resource) && (resource.data()) && (resource.data().power_state) && (resource.data().power_state.battery_level!=null)) {
+            fill = (resource.data().power_state.battery_level > 10)? "green" : "red";
+            text = resource.data().power_state.battery_level+"%";
+        }
+
+        this.status({fill: fill, shape: shape, text: text});
+    }
+}
+
+module.exports = DevicePowerNode;

package/src/nodes/GroupedLightNode.js

@@ -0,0 +1,46 @@
+ResourceNode = require("./ResourceNode");
+
+class GroupedLightNode extends ResourceNode {
+    #info;
+    #trace;
+
+    constructor(config) {
+        super(config);
+        this.#info = require('debug')('info').extend('GroupedLightNode').extend("["+this.logid()+"]");
+        this.#trace = require('debug')('trace').extend('GroupedLightNode').extend("["+this.logid()+"]");
+        this.#info("constructor()");
+    }
+
+    onUpdate(event) {
+        this.#trace("onUpdate(",event,")");
+        this.updateStatus();
+        super.onUpdate(event);
+    }
+
+    updateStatus() {
+        this.#trace("updateStatus()");
+
+        var fill = "grey";
+        var shape = "dot";
+        var text = "";
+
+        var resource = this.resource();
+        if ((resource) && (resource.data()) && (resource.data().on)) {
+            if (resource.data().on.on==true) {
+                fill = "yellow";
+
+                if (resource.data().dimming) {
+                    text = resource.data().dimming.brightness+"%";
+                }
+
+            } else if (resource.data().on.on==false) {
+                fill = "grey";
+                text = "off";
+            }
+        }
+
+        this.status({fill: fill, shape: shape, text: text});
+    }
+}
+
+module.exports = GroupedLightNode;