node-red-contrib-huemagic 4.2.2 → 5.0.1

package/huemagic/hue-speaker.js

@@ -0,0 +1,257 @@
+module.exports = function(RED)
+{
+	"use strict";
+
+	function HueSpeaker(config)
+	{
+		RED.nodes.createNode(this, config);
+
+		const scope = this;
+		const bridge = RED.nodes.getNode(config.bridge);
+		const async = require('async');
+
+		// SAVE LAST COMMAND
+		this.lastCommand = null;
+
+		//
+		// CHECK CONFIG
+		if(bridge == null)
+		{
+			this.status({fill: "red", shape: "ring", text: "hue-speaker.node.not-configured"});
+			return false;
+		}
+
+		//
+		// UNIVERSAL MODE?
+		if(!config.speakerid)
+		{
+			this.status({fill: "grey", shape: "dot", text: "hue-speaker.node.universal"});
+		}
+
+		//
+		// UPDATE STATE
+		if(config.speakerid)
+		{
+			this.status({fill: "grey", shape: "dot", text: "hue-speaker.node.silent"});
+		}
+
+		//
+		// SUBSCRIBE TO UPDATES FROM THE BRIDGE
+		this.unsubscribe = bridge.subscribe("speaker", config.speakerid, function(info)
+		{
+			let currentState = bridge.get("speaker", info.id);
+
+			// RESOURCE FOUND?
+			if(currentState !== false)
+			{
+				// SEND MESSAGE
+				if(!config.skipevents && (config.initevents || info.suppressMessage == false) && (!config.onlycommands || scope.lastCommand !== null))
+				{
+					// SET LAST COMMAND
+					if(scope.lastCommand !== null)
+					{
+						currentState.command = scope.lastCommand;
+					}
+
+					// SEND STATE
+					scope.send(currentState);
+
+					// RESET LAST COMMAND
+					scope.lastCommand = null;
+				}
+
+				// NOT IN UNIVERAL MODE? -> CHANGE UI STATES
+				if(config.speakerid)
+				{
+					if(currentState.payload.reachable == false)
+					{
+						scope.status({fill: "red", shape: "ring", text: "hue-speaker.node.not-reachable"});
+					}
+					else if(currentState.payload.muted === true)
+					{
+						scope.status({fill: "grey", shape: "ring", text: "hue-speaker.node.muted"});
+					}
+					else if(currentState.payload.alarm !== false)
+					{
+						scope.status({fill: "red", shape: "dot", text: RED._("hue-speaker.node.playing-alarm", { sound: currentState.payload.alarm })});
+					}
+					else if(currentState.payload.chime !== false)
+					{
+						scope.status({fill: "blue", shape: "dot", text: RED._("hue-speaker.node.playing-chime", { sound: currentState.payload.chime })});
+					}
+					else if(currentState.payload.alert !== false)
+					{
+						scope.status({fill: "yellow", shape: "dot", text: RED._("hue-speaker.node.playing-alert", { sound: currentState.payload.alert })});
+					}
+					else
+					{
+						scope.status({fill: "grey", shape: "dot", text: "hue-speaker.node.silent"});
+					}
+				}
+			}
+		});
+
+		//
+		// CONTROL THE SPEAKER
+		this.on('input', function(msg, send, done)
+		{
+			// REDEFINE SEND AND DONE IF NOT AVAILABLE
+			send = send || function() { scope.send.apply(scope,arguments); }
+			done = done || function() { scope.done.apply(scope,arguments); }
+
+			// SAVE LAST COMMAND
+			scope.lastCommand = RED.util.cloneMessage(msg);
+
+			// CREATE PATCH
+			let patchObject = {};
+
+			// DEFINE SPEAKER ID
+			const tempSpeakerID = (!config.speakerid && typeof msg.topic != 'undefined' && bridge.validResourceID.test(msg.topic) === true) ? msg.topic : config.speakerid;
+			if(!tempSpeakerID)
+			{
+				scope.error(RED._("hue-speaker.node.error-no-id"), msg);
+				return false;
+			}
+
+			// GET CURRENT STATE
+			let currentState = bridge.get("speaker", tempSpeakerID);
+			if(!currentState)
+			{
+				scope.error(RED._("hue-speaker.node.error-not-available"), msg);
+				return false;
+			}
+
+			// JUST GIVE BACK THE CURRENT STATE
+			if( (typeof msg.payload != 'undefined' && typeof msg.payload.status != 'undefined') || (typeof msg.__user_inject_props__ != 'undefined' && msg.__user_inject_props__ == "status") )
+			{
+				// SET LAST COMMAND
+				if(scope.lastCommand !== null)
+				{
+					currentState.command = scope.lastCommand;
+				}
+
+				// SEND STATE
+				scope.send(currentState);
+
+				// RESET LAST COMMAND
+				scope.lastCommand = null;
+
+				if(done) { done(); }
+				return true;
+			}
+
+			// MUTE / UNMUTE
+			if(typeof msg.payload != 'undefined' && typeof msg.payload.mute != 'undefined')
+			{
+				patchObject["mute"] = { mute: (msg.payload.mute === true) ? "mute" : "unmute" };
+			}
+
+			// PLAY A SOUND / STOP IT AGAIN
+			for(const channel of ["alarm", "chime", "alert"])
+			{
+				if(typeof msg.payload == 'undefined' || typeof msg.payload[channel] == 'undefined') { continue; }
+
+				const supported = currentState.info.sounds[channel];
+				if(!supported)
+				{
+					scope.error(RED._("hue-speaker.node.error-no-channel", { channel: channel }), msg);
+					return false;
+				}
+
+				// A PLAIN "false" STOPS WHATEVER IS PLAYING
+				const request = (msg.payload[channel] === false) ? { sound: "no_sound" } : ((typeof msg.payload[channel] == 'string') ? { sound: msg.payload[channel] } : msg.payload[channel]);
+
+				if(!request.sound || (request.sound !== "no_sound" && supported.indexOf(request.sound) === -1))
+				{
+					scope.error(RED._("hue-speaker.node.error-invalid-sound", { channel: channel, sounds: supported.join(", ") }), msg);
+					return false;
+				}
+
+				patchObject[channel] = { sound: request.sound };
+
+				// HOW LOUD AND HOW LONG
+				if(typeof request.volume != 'undefined')
+				{
+					const volume = parseInt(request.volume);
+					if(isNaN(volume) || volume < 0 || volume > 100)
+					{
+						scope.error(RED._("hue-speaker.node.error-invalid-volume"), msg);
+						return false;
+					}
+
+					patchObject[channel]["volume"] = { level: volume };
+				}
+
+				if(typeof request.duration != 'undefined')
+				{
+					let duration = Math.round(parseFloat(request.duration) * 1000);
+					duration = (duration < 0) ? 0 : duration;
+
+					patchObject[channel]["duration"] = duration;
+				}
+			}
+
+			//
+			// SHOULD PATCH?
+			if(Object.values(patchObject).length > 0)
+			{
+				// CHANGE NODE UI STATE
+				if(config.speakerid)
+				{
+					scope.status({fill: "grey", shape: "ring", text: "hue-speaker.node.command"});
+				}
+
+				// PATCH!
+				async.retry({
+					times: 5,
+					errorFilter: function(err) {
+						return (err.status == 503 || err.status == 429);
+					},
+					interval: function(retryCount) { return 750*retryCount; }
+				},
+				function(callback, results)
+				{
+					bridge.patch("speaker", tempSpeakerID, patchObject)
+					.then(function() { callback(null, true); })
+					.catch(function(errors) { callback(errors, null); });
+				},
+				function(errors, success)
+				{
+					if(errors)
+					{
+						scope.error(errors, msg);
+					}
+					else if(done)
+					{
+						done();
+					}
+				});
+			}
+			else
+			{
+				// SET LAST COMMAND
+				if(scope.lastCommand !== null)
+				{
+					currentState.command = scope.lastCommand;
+				}
+
+				// SEND STATE
+				scope.send(currentState);
+
+				// RESET LAST COMMAND
+				scope.lastCommand = null;
+
+				if(done) { done(); }
+			}
+		});
+
+		//
+		// CLOSE NODE / DETACH FROM THE BRIDGE
+		this.on('close', function()
+		{
+			if(scope.unsubscribe) { scope.unsubscribe(); }
+		});
+	}
+
+	RED.nodes.registerType("hue-speaker", HueSpeaker);
+}

package/huemagic/hue-syncbox-config.html

@@ -0,0 +1,123 @@
+<script type="text/x-red" data-template-name="hue-syncbox-config">
+	<div class="form-row">
+		<label for="node-config-input-name"><i class="fa fa-tag"></i> <span data-i18n="hue-syncbox-config.config.name"></span></label>
+		<input type="text" id="node-config-input-name" style="width: calc(100% - 105px)">
+	</div>
+	<div class="form-row">
+		<label for="node-config-input-syncbox"><i class="fa fa-television"></i> <span data-i18n="hue-syncbox-config.config.syncbox-ip"></span></label>
+		<input type="text" id="node-config-input-syncbox" placeholder="X.X.X.X" style="width: calc(100% - 105px)">
+	</div>
+	<div class="form-row">
+		<label for="node-config-input-token"><i class="fa fa-key"></i> <span data-i18n="hue-syncbox-config.config.token"></span></label>
+		<div style="display: inline-flex; width: calc(100% - 105px)">
+			<div style="flex-grow: 1;">
+				<input type="text" id="node-config-input-token" style="width: 100%"/>
+			</div>
+			<button id="node-config-input-register-syncbox" type="button" class="red-ui-button" style="margin-left: 10px;">
+				<i class="fa fa-user-circle-o"></i>
+			</button>
+		</div>
+	</div>
+	<div class="form-row">
+		<label for="node-config-input-pollinterval"><i class="fa fa-refresh"></i> <span data-i18n="hue-syncbox-config.config.pollinterval"></span></label>
+		<input type="number" id="node-config-input-pollinterval" placeholder="10" min="2" style="width: calc(100% - 105px)">
+	</div>
+</script>
+
+<script type="text/javascript">
+	RED.nodes.registerType("hue-syncbox-config", {
+		category: "config",
+		color: '#c7d8d8',
+		defaults: {
+			name: { value:"Hue Sync Box", required: true },
+			syncbox: { value:"", required: true },
+			token: { value:"", required: true },
+			pollinterval: { value: 10, required: true, validate: function(v) {
+				return (!isNaN(v) && v >= 2);
+			}}
+		},
+		icon: "hue-syncbox.svg",
+		label: function() {
+			return this.name;
+		},
+		paletteLabel: function() {
+			return this._("hue-syncbox-config.node.title");
+		},
+		oneditprepare: function()
+		{
+			const scope = this;
+
+			// CHANGED IP? -> GET NAME (IF POSSIBLE)
+			$(document).off('change', '#node-config-input-syncbox');
+			$(document).on('change', '#node-config-input-syncbox', function(e)
+			{
+				let currentIP = $(e.currentTarget).val();
+				if(currentIP.length > 3)
+				{
+					var notification = RED.notify(scope._("hue-syncbox-config.config.connecting"), { type: "compact", modal: true, fixed: true });
+
+					$.ajax({
+						url: 'hue/syncbox/name',
+						type: "GET",
+						data: { ip: currentIP },
+						timeout: 5000
+					})
+					.done( function(data)
+					{
+						$('#node-config-input-name').val(data);
+						setTimeout(function() { notification.close(); }, 500);
+					})
+					.fail(function(err)
+					{
+						notification.close();
+						RED.notify(scope._("hue-syncbox-config.config.invalid") + err.statusText, "error");
+					});
+				}
+			});
+
+			$('#node-config-input-register-syncbox').click(function()
+			{
+				if(!$('#node-config-input-syncbox').val())
+				{
+					RED.notify(scope._("hue-syncbox-config.config.error-select-first"), "error");
+					return false;
+				}
+
+				$('#node-config-input-token').val("");
+				$('#node-config-input-token').attr("placeholder", scope._("hue-syncbox-config.config.waiting"));
+
+				RED.notify(scope._("hue-syncbox-config.config.new-user-press"));
+
+				// KEEP ASKING THE BOX UNTIL THE BUTTON HAS BEEN PRESSED
+				var attempt = 0;
+				var register = function()
+				{
+					attempt += 1;
+
+					$.get('hue/syncbox/register', { ip: $('#node-config-input-syncbox').val() } )
+					.done( function(data)
+					{
+						if(data == "error")
+						{
+							if(attempt < 30) { return setTimeout(register, 2000); }
+
+							RED.notify(scope._("hue-syncbox-config.config.retry"), "error");
+							$('#node-config-input-token').attr("placeholder", "");
+						}
+						else
+						{
+							var registration = JSON.parse(data);
+							$('#node-config-input-token').val(registration.accessToken);
+							RED.notify(scope._("hue-syncbox-config.config.success"));
+						}
+					}).fail(function(err)
+					{
+						RED.notify(err.responseText, "error");
+					});
+				}
+
+				register();
+			});
+		}
+	});
+</script>

package/huemagic/hue-syncbox-config.js

@@ -0,0 +1,179 @@
+module.exports = function(RED)
+{
+	"use strict";
+
+	const API = require('./utils/syncbox');
+	const events = require('events');
+	const dayjs = require('dayjs');
+	const diff = require("deep-object-diff").diff;
+
+	const { HueSyncBoxMessage } = require('./utils/messages');
+
+	function HueSyncBox(config)
+	{
+		const scope = this;
+
+		// STATES
+		this.nodeActive = true;
+		this.config = config;
+		this.state = false;
+		this.lastState = false;
+		this.events = new events.EventEmitter();
+		this.events.setMaxListeners(0);
+		this.pollTimeout = null;
+		this.failures = 0;
+
+		// RESOURCE ID PATTERN (NEVER GLOBAL, "test" WOULD BECOME STATEFUL)
+		this.validResourceID = /^[a-zA-Z0-9-]+$/i;
+
+		// CREATE NODE
+		RED.nodes.createNode(scope, config);
+
+		// THE BOX HAS NO EVENT STREAM, SO IT HAS TO BE ASKED
+		this.pollInterval = config.pollinterval ? parseInt(config.pollinterval) * 1000 : 10000;
+
+		//
+		// KEEP THE STATE UP-TO-DATE
+		this.poll = function(immediately = false)
+		{
+			if(scope.pollTimeout !== null) { clearTimeout(scope.pollTimeout); }
+			if(scope.nodeActive === false) { return false; }
+
+			scope.pollTimeout = setTimeout(function()
+			{
+				API.state(config)
+				.then(function(state)
+				{
+					if(scope.failures > 0) { scope.log(RED._("hue-syncbox-config.node.connected")); }
+					scope.failures = 0;
+
+					state.updated = dayjs().format();
+					scope.state = state;
+
+					scope.pushUpdatedState();
+					scope.poll();
+				})
+				.catch(function(error)
+				{
+					scope.failures += 1;
+
+					// ONLY COMPLAIN ONCE PER OUTAGE
+					if(scope.failures === 1)
+					{
+						scope.log(RED._("hue-syncbox-config.node.request-error", { error: JSON.stringify(error.errors ? error.errors : error) }));
+					}
+
+					scope.events.emit(config.id + "_unreachable", true);
+					scope.poll();
+				});
+			}, immediately ? 100 : scope.pollInterval);
+		}
+
+		//
+		// PUSH THE STATE TO THE NODES
+		this.pushUpdatedState = function()
+		{
+			const suppressMessage = (scope.lastState === false);
+			scope.events.emit(config.id + "_syncbox", { suppressMessage: suppressMessage });
+		}
+
+		//
+		// GET THE CURRENT STATE (FROM NODES)
+		this.get = function()
+		{
+			if(!scope.state) { return false; }
+
+			try {
+				const message = new HueSyncBoxMessage(scope.state);
+				const previous = scope.lastState ? structuredClone(scope.lastState) : false;
+
+				let currentState = message.msg;
+				scope.lastState = structuredClone(currentState);
+
+				currentState.updated = (previous === false) ? {} : diff(previous, currentState);
+				currentState.lastState = previous;
+
+				return currentState;
+			} catch (error) {
+				return false;
+			}
+		}
+
+		//
+		// CHANGE WHAT THE BOX IS DOING (FROM NODES)
+		this.execute = function(patch)
+		{
+			return API.execute(config, patch).then(function(response)
+			{
+				// THE BOX ANSWERS WITHOUT A BODY, SO ASK IT AGAIN RIGHT AWAY
+				scope.poll(true);
+				return response;
+			});
+		}
+
+		//
+		// SUBSCRIBE (FROM NODES)
+		this.subscribe = function(callback)
+		{
+			const eventName = config.id + "_syncbox";
+			scope.events.on(eventName, callback);
+
+			// THE CONFIG NODE OUTLIVES A REDEPLOY, SO EVERY NODE HAS TO DETACH ITSELF AGAIN
+			return function() { scope.events.removeListener(eventName, callback); };
+		}
+
+		//
+		// START POLLING
+		this.log(RED._("hue-syncbox-config.node.initializing", { syncbox: config.syncbox }));
+		this.poll(true);
+
+		//
+		// CLOSE NODE
+		this.on('close', function()
+		{
+			scope.nodeActive = false;
+			if(scope.pollTimeout !== null) { clearTimeout(scope.pollTimeout); }
+			scope.events.removeAllListeners();
+		});
+	}
+
+	RED.nodes.registerType("hue-syncbox-config", HueSyncBox);
+
+	//
+	// GET THE NAME OF A SYNC BOX
+	RED.httpAdmin.get('/hue/syncbox/name', RED.auth.needsPermission('hue-syncbox-config.read'), function(req, res, next)
+	{
+		if(!req.query.ip)
+		{
+			return res.status(500).send(RED._("hue-syncbox-config.config.missing-ip"));
+		}
+
+		// THE DEVICE ENDPOINT ANSWERS THE NAME EVEN WITHOUT A TOKEN
+		API.request({ config: { syncbox: req.query.ip }, resource: "/device", token: false })
+		.then(function(device) { res.end(device.name ? device.name : "Hue Sync Box"); })
+		.catch(function(error) { res.status(500).send(error.errors ? JSON.stringify(error.errors) : "error"); });
+	});
+
+	//
+	// REGISTER WITH A SYNC BOX
+	RED.httpAdmin.get('/hue/syncbox/register', RED.auth.needsPermission('hue-syncbox-config.read'), function(req, res, next)
+	{
+		if(!req.query.ip)
+		{
+			return res.status(500).send(RED._("hue-syncbox-config.config.missing-ip"));
+		}
+
+		API.register({ syncbox: req.query.ip })
+		.then(function(registration)
+		{
+			if(!registration || !registration.accessToken) { return res.end("error"); }
+			res.end(JSON.stringify(registration));
+		})
+		.catch(function(error)
+		{
+			// CODE 16 MEANS THE BUTTON ON THE BOX HAS NOT BEEN PRESSED YET
+			if(error.code === 16) { return res.end("error"); }
+			res.status(500).send(error.errors ? JSON.stringify(error.errors) : "error");
+		});
+	});
+};

package/huemagic/hue-syncbox.html

@@ -0,0 +1,82 @@
+<script type="text/x-red" data-template-name="hue-syncbox">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="hue-syncbox.config.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]hue-syncbox.config.input-name" style="width: calc(100% - 105px)">
+    </div>
+    <div class="form-row">
+        <label for="node-input-syncbox"><i class="fa fa-television"></i> <span data-i18n="hue-syncbox.config.syncbox"></span></label>
+        <input type="text" id="node-input-syncbox" style="width: calc(100% - 105px)">
+    </div>
+    <div class="form-row" style="margin-top: 30px">
+        <div style="display: inline-flex; align-items: center; width: calc(100% - 105px)">
+            <input type="checkbox" id="node-input-skipevents" style="flex: 0 0 auto; width: auto; margin: 0;">
+            <span data-i18n="hue-syncbox.config.skipevents-node" style="flex: 1; margin-left: 8px;"></span>
+        </div>
+    </div>
+    <div class="form-row">
+        <div style="display: inline-flex; align-items: center; width: calc(100% - 105px)">
+            <input type="checkbox" id="node-input-initevents" style="flex: 0 0 auto; width: auto; margin: 0;">
+            <span data-i18n="hue-syncbox.config.sendinitevents-node" style="flex: 1; margin-left: 8px;"></span>
+        </div>
+    </div>
+    <div class="form-row">
+        <div style="display: inline-flex; align-items: center; width: calc(100% - 105px)">
+            <input type="checkbox" id="node-input-onlycommands" style="flex: 0 0 auto; width: auto; margin: 0;">
+            <span data-i18n="hue-syncbox.config.onlycommands-node" style="flex: 1; margin-left: 8px;"></span>
+        </div>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('hue-syncbox',{
+        category: 'HueMagic',
+        color: '#e0674d',
+        defaults: {
+            name: { value:"" },
+            syncbox: { type: "hue-syncbox-config", required: true },
+            skipevents: { value: false },
+            initevents: { value: false },
+            onlycommands: { value: false }
+        },
+        align: 'left',
+        icon: "hue-syncbox.svg",
+        inputs: 1,
+        outputs: 1,
+        label: function() {
+            return this.name || this._("hue-syncbox.node.title");
+        },
+        paletteLabel: function() {
+            return this._("hue-syncbox.node.title");
+        },
+        inputLabels: function() {
+            return this._("hue-syncbox.node.input");
+        },
+        outputLabels: function() {
+            return this._("hue-syncbox.node.output");
+        },
+        button: {
+            enabled: function() {
+                return !!this.syncbox
+            },
+            visible: function() {
+                return !!this.syncbox
+            },
+            onclick: function()
+            {
+                const node = this;
+                if(node.syncbox)
+                {
+                    $.ajax({
+                        url: "inject/" + node.id,
+                        type: "POST",
+                        data: JSON.stringify({ __user_inject_props__: "status"}),
+                        contentType: "application/json; charset=utf-8",
+                        success: function (resp) {
+                            RED.notify(node.name + ": " + node._("hue-syncbox.node.statusmsg"), { type: "success", id: "status", timeout: 2000 });
+                        }
+                    });
+                }
+            }
+        }
+    });
+</script>