node-red-contrib-huemagic 3.0.0 → 4.0.3

package/huemagic/hue-bridge-config.js

@@ -2,226 +2,592 @@ module.exports = function(RED)
 {
 	"use strict";
 
+	const API = require('./utils/api');
+	const merge = require('./utils/merge');
+	const events = require('events');
+	const dayjs = require('dayjs');
+	const diff = require("deep-object-diff").diff;
+	const axios = require('axios');
+	const https = require('https');
+
+	// READABLE RESOURCE MESSAGES
+	const { HueBridgeMessage,
+			HueLightMessage,
+			HueGroupMessage,
+			HueMotionMessage,
+			HueTemperatureMessage,
+			HueBrightnessMessage,
+			HueButtonsMessage,
+			HueRulesMessage
+		} = require('./utils/messages');
+
 	function HueBridge(config)
 	{
-		var scope = this;
-		var events = require('events');
-		let huejay = require('huejay');
+		const scope = this;
 
-		// INTERVAL AND EVENT EMITTER
+		// STATES
 		this.nodeActive = true;
-		this.lights = [];
-		this.sensors = [];
-		this.groups = [];
-		this.rules = [];
+		this.config = config;
+		this.resources = {};
+		this.resourcesInGroups = {};
+		this.lastStates = {};
 		this.events = new events.EventEmitter();
 
+		// RESOURCE ID PATTERN
+		this.validResourceID = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+
 		// CREATE NODE
 		RED.nodes.createNode(scope, config);
 
-		// DEFINE CLIENT
-		let ipHostArray = (config.bridge).toString().trim().split(":");
-		this.client = new huejay.Client({
-			host: ipHostArray[0],
-			port: (ipHostArray > 1) ? parseInt(ipHostArray[1]) : 80,
-			username: config.key
-		});
-
-		// DELAY
-		this.delay = function(ms)
+		// INITIALIZE
+		this.start = function()
 		{
-			return new Promise(resolve => setTimeout(resolve, ms));
-		}
-
-		// RECHECK DEVICES
-		this.recheckAll = function()
-		{
-			scope.client.sensors.getAll().then(sensors => {
-				let sensorUpdates = scope.getUpdates("sensor", sensors);
-				scope.emitUpdates("sensor", sensorUpdates);
-
-				return true;
+			scope.log("Initializing the bridge…");
+			API.init({ ip: config.bridge, key: config.key })
+			.then(function(bridge) {
+				scope.log("Connected to bridge");
+				return scope.getAllResources();
 			})
-			scope.delay(500).then(() => { return "next"; })
-			scope.client.lights.getAll().then(lights => {
-				let lightUpdates = scope.getUpdates("light", lights);
-				scope.emitUpdates("light", lightUpdates);
-
-				return true;
+			.then(function(allResources)
+			{
+				scope.log("Process resources…");
+				return API.processResources(allResources);
 			})
-			scope.delay(500).then(() => { return "next"; })
-			scope.client.groups.getAll().then(groups => {
-				let groupUpdates = scope.getUpdates("group", groups);
-				scope.emitUpdates("group", groupUpdates);
+			.then(function(allResources)
+			{
+				// SAVE CURRENT RESOURCES
+				scope.resources = allResources;
 
-				return true;
+				// EMIT INITIAL STATES -> NODES
+				scope.log("Initial emit of resource states…");
+				return scope.emitInitialStates();
 			})
-			scope.delay(500).then(() => { return "next"; })
-			scope.client.rules.getAll().then(rules => {
-				let ruleUpdates = scope.getUpdates("rule", rules);
-				scope.emitUpdates("rule", ruleUpdates);
+			.then(function(emitted)
+			{
+				// START REFRESHING STATES
+				scope.keepUpdated();
 
+				// START LOOKING FOR FIRMWARE-UPDATES
+				scope.autoUpdateFirmware();
 				return true;
 			})
-			.then(proceed => {
-				// RECHECK
-				if(scope.nodeActive == true && proceed == true) { setTimeout(function(){ scope.recheckAll(); }, config.interval); }
-				return true;
-			})
-			.catch(error => {
-				scope.debug(error.stack);
+			.catch(function(error)
+			{
+				// RETRY AFTER 30 SECONDS
+				scope.log(error);
+				if(scope.nodeActive == true) { setTimeout(function(){ scope.start(); }, 30000); }
+			});
+		}
 
-				if(scope.nodeActive == true)
+		// FETCH BRIDGE INFORMATION
+		this.getBridgeInformation = function(replaceResources = false)
+		{
+			return new Promise(function(resolve, reject)
+			{
+				API.request({ resource: "/config", version: 1 })
+				.then(function(bridgeInformation)
 				{
-					setTimeout(function(){ scope.recheckAll(); }, 5000);
-				}
+					// PREPARE TO MATCH V2 RESOURCES
+					bridgeInformation.id = "bridge";
+					bridgeInformation.id_v1 = "/config";
+					bridgeInformation.updated = dayjs().format();
+
+					// ALSO REPLACE CURRENT RESOURCE?
+					if(replaceResources === true)
+					{
+						scope.resources[bridgeInformation.id] = bridgeInformation;
+					}
+
+					// GIVE BACK
+					resolve(bridgeInformation);
+				})
+				.catch(function(error)
+				{
+					reject(error);
+				});
 			});
 		}
 
-		// RECHECK ONLY SENSORS
-		this.recheckSensors = function()
+		// GET ALL RESOURCES + RULES
+		this.getAllResources = function()
 		{
-			scope.client.sensors.getAll().then(sensors => {
-				let sensorUpdates = scope.getUpdates("sensor", sensors);
-				scope.emitUpdates("sensor", sensorUpdates);
+			return new Promise(function(resolve, reject)
+			{
+				var allResources = [];
 
-				return true;
-			})
-			.then(proceed => {
-				// RECHECK
-				if(scope.nodeActive == true && proceed == true) { setTimeout(function(){ scope.recheckSensors(); }, config.interval); }
-				return true;
-			})
-			.catch(error => {
-				scope.debug(error.stack);
+				// GET BRIDGE INFORMATION
+				scope.getBridgeInformation()
+				.then(function(bridgeInformation)
+				{
+					// PUSH TO RESOURCES
+					allResources.push(bridgeInformation);
 
-				if(scope.nodeActive == true)
+					// CONTINUE WITH ALL RESOURCES
+					return API.request({ resource: "all" });
+				})
+				.then(function(v2Resources)
 				{
-					setTimeout(function(){ scope.recheckSensors(); }, 5000);
-				}
+					// MERGE RESOURCES
+					allResources = allResources.concat(v2Resources);
+
+					// GET RULES (LEGACY API)
+					return API.request({ resource: "/rules", version: 1 });
+				})
+				.then(function(rules)
+				{
+					for (var [id, rule] of Object.entries(rules))
+					{
+						// "RENAME" OWNER
+						rule["_owner"] = rule["owner"];
+						delete rule["owner"];
+
+						// ADD RULE ID(S)
+						rule["id"] = "rule_" + id;
+						rule["id_v1"] = "/rules/" + id;
+
+						// ADD RULE TYPE
+						rule["type"] = "rule";
+
+						// PUSH RULES
+						allResources.push(rule);
+					}
+
+					resolve(allResources);
+				})
+				.catch(function(error) { reject(error); });
 			});
 		}
 
-		// START FIRST CHECK
-		if(!config.disableupdates)
+		// EMIT INITIAL STATES -> NODES
+		this.emitInitialStates = function(resources = false)
 		{
-			this.recheckAll();
+			return new Promise(function(resolve, reject)
+			{
+				// PUSH STATES
+				setTimeout(function()
+				{
+					// PUSH ALL STATES
+					for (const [id, resource] of Object.entries(scope.resources))
+					{
+						scope.pushUpdatedState(resource, resource.type, true);
+					}
+
+					resolve(true);
+				}, 500);
+			});
 		}
-		else
+
+		// KEEEP STATES UP-TO-DATE
+		this.keepUpdated = function()
 		{
-			this.recheckSensors();
+			if(!config.disableupdates)
+			{
+				scope.log("Keeping nodes up-to-date…");
+
+				// REFRESH STATES (SSE)
+				this.refreshStatesSSE();
+			}
 		}
 
-		// DETERMINE UPDATES
-		this.getUpdates = function(mode, content)
+		// GET UPDATED STATES (SSE)
+		this.refreshStatesSSE = function()
 		{
-			var updates = [];
-			for (var i = content.length - 1; i >= 0; i--)
+			scope.log("Subscribing to bridge events…");
+			API.subscribe(function(updates)
 			{
-				let device = content[i];
-				var updated = false;
-				var uniqueStatus = "";
+				const currentDateTime = dayjs().format();
 
-				if(mode == "light")
+				for(let resource of updates)
 				{
-					uniqueStatus = ((device.on) ? "1" : "0") + device.brightness + device.hue + device.saturation + device.colorTemp + device.reachable;
+					let id = resource.id;
+					let type = resource.type;
+
+					let previousState = false;
 
-					if(device.id in this.lights)
+					// HAS OWNER?
+					if(resource["owner"])
 					{
-						if(this.lights[device.id] != uniqueStatus)
+						let targetId = resource["owner"]["rid"];
+
+						if(scope.resources[targetId])
 						{
-							this.lights[device.id] = uniqueStatus;
-							updated = true;
+							// GET PREVIOUS STATE
+							previousState = scope.resources[targetId]["services"][type][id];
+
+							// IS BUTTON? -> REMOVE PREVIOUS STATES
+							if(type === "button")
+							{
+								for (const [oneButtonID, oneButton] of Object.entries(scope.resources[targetId]["services"]["button"]))
+								{
+									delete scope.resources[targetId]["services"]["button"][oneButtonID]["button"];
+								}
+							}
 						}
 					}
-					else
+					else if(scope.resources[id])
 					{
-						this.lights[device.id] = uniqueStatus;
-						updated = true;
+						// GET PREVIOUS STATE
+						previousState = scope.resources[id];
 					}
-				}
-				else if(mode == "sensor")
-				{
-					uniqueStatus = device.state.lastUpdated;
-					if(device.id in this.sensors)
+
+					// NO PREVIOUS STATE?
+					if(!previousState) { return false; }
+
+					// CHECK DIFFERENCES
+					const mergedState = merge.deep(previousState, resource);
+					const updatedResources = diff(previousState, mergedState);
+
+					if(Object.values(updatedResources).length > 0)
 					{
-						if(this.sensors[device.id] != uniqueStatus)
+						if(resource["owner"])
 						{
-							this.sensors[device.id] = uniqueStatus;
-							updated = true;
+							let targetId = resource["owner"]["rid"];
+
+							scope.resources[targetId]["services"][type][id] = mergedState;
+							scope.resources[targetId]["updated"] = currentDateTime;
+
+							// PUSH STATE
+							scope.pushUpdatedState(scope.resources[targetId], resource.type);
+						}
+						else
+						{
+							scope.resources[id] = mergedState;
+							scope.resources[id]["updated"] = currentDateTime;
+
+							// PUSH STATE
+							scope.pushUpdatedState(scope.resources[id], resource.type);
 						}
 					}
-					else
-					{
-						this.sensors[device.id] = uniqueStatus;
-						updated = true;
-					}
 				}
-				else if(mode == "group")
+			});
+		}
+
+		// PUSH UPDATED STATE
+		this.pushUpdatedState = function(resource, updatedType, suppressMessage = false)
+		{
+			const msg = { id: resource.id, type: resource.type, updatedType: updatedType, services: resource["services"] ? Object.keys(resource["services"]) : [], suppressMessage: suppressMessage };
+			this.events.emit(resource.id, msg);
+			this.events.emit("globalResourceUpdates", msg);
+
+			// RESOURCE CONTAINS SERVICES? -> SERVICE IN GROUP? -> EMIT CHANGES TO GROUPS ALSO
+			if(this.resources["_groupsOf"][resource.id])
+			{
+				for (var g = this.resources["_groupsOf"][resource.id].length - 1; g >= 0; g--)
+				{
+					const groupID = this.resources["_groupsOf"][resource.id][g];
+					const groupMessage = { id: groupID, type: "group", updatedType: updatedType, services: [], suppressMessage: suppressMessage };
+
+					this.events.emit(groupID, groupMessage);
+					this.events.emit("globalResourceUpdates", groupMessage);
+				}
+			}
+		}
+
+		// GET RESOURCE (FROM NODES)
+		this.get = function(type, id = false, options = {})
+		{
+			// GET SPECIFIC RESOURCE
+			if(id)
+			{
+				// RESOURCE EXISTS? -> PROCEED
+				if(scope.resources[id])
 				{
-					uniqueStatus = ((device.on) ? "1" : "0") + device.brightness + device.hue + device.saturation + device.colorTemp + ((device.anyOn) ? "1" : "0") + ((device.allOn) ? "1" : "0");
-					if(device.id in this.groups)
+					// RESOLVE LINKS
+					const targetResource = scope.resources[id];
+					const lastState = scope.lastStates[type+targetResource.id] ? Object.assign({}, scope.lastStates[type+targetResource.id]) : false;
+
+					if(type == "bridge")
 					{
-						if(this.groups[device.id] != uniqueStatus)
-						{
-							this.groups[device.id] = uniqueStatus;
-							updated = true;
-						}
+						const message = new HueBridgeMessage(targetResource, options);
+
+						// GET CURRENT STATE MESSAGE
+						let currentState = message.msg;
+						return currentState;
+					}
+					else if(type == "light")
+					{
+						const message = new HueLightMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "group")
+					{
+						// GET MESSAGE
+						const message = new HueGroupMessage(targetResource, { resources: scope.resources, ...options});
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "button")
+					{
+						const message = new HueButtonsMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "motion")
+					{
+						const message = new HueMotionMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "temperature")
+					{
+						const message = new HueTemperatureMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "light_level")
+					{
+						const message = new HueBrightnessMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
+					}
+					else if(type == "rule")
+					{
+						const message = new HueRulesMessage(targetResource, options);
+
+						// GET & SAVE LAST STATE AND DIFFERENCES
+						let currentState = message.msg;
+						scope.lastStates[type+targetResource.id] = Object.assign({}, currentState);
+						currentState.updated = (lastState === false) ? {} : diff(lastState, currentState);
+						currentState.lastState = lastState;
+
+						return currentState;
 					}
 					else
 					{
-						this.groups[device.id] = uniqueStatus;
-						updated = true;
+						return false;
 					}
 				}
-				else if(mode == "rule")
+				else
+				{
+					return false;
+				}
+			}
+			else
+			{
+				// FILTER RESOURCES BY TYPE
+				let allFilteredResources = {};
+
+				for (const [rootID, resource] of Object.entries(scope.resources))
 				{
-					let rule = device;
-					uniqueStatus = rule.lastTriggered + rule.status;
+					const isGroup = (resource["type"] == "room" || resource["type"] == "zone" || resource["type"] == "bridge_home");
 
-					if(rule.id in this.rules)
+					// NORMAL DEVICES
+					if(!isGroup && resource["services"] && resource["services"][type])
 					{
-						if(this.rules[rule.id] != uniqueStatus)
+						for (const [serviceID, targetDevice] of Object.entries(resource["services"][type]))
 						{
-							this.rules[rule.id] = uniqueStatus;
-							updated = true;
+							allFilteredResources[rootID] = scope.get(type, rootID);
 						}
 					}
-					else
+					// GROUPED RESOURCES
+					else if(isGroup && type === "group")
 					{
-						this.rules[rule.id] = uniqueStatus;
-						updated = true;
+						allFilteredResources[rootID] = scope.get(type, rootID);
 					}
 				}
 
-				// IS UPDATED?
-				if(updated == true)
+				return Object.values(allFilteredResources);
+			}
+		}
+
+		// PATCH RESOURCE (FROM NODES)
+		this.patch = function(type, id, patch, version = 2)
+		{
+			return new Promise(function(resolve, reject)
+			{
+				// GET SERVICE ID
+				if(version !== 1 && scope.resources[id] && scope.resources[id]["services"] && scope.resources[id]["services"][type])
 				{
-					updates.push(device);
+					const targetResource = Object.values(scope.resources[id]["services"][type])[0];
+					id = targetResource.id;
 				}
+
+				// ACTION!
+				API.request({ method: "PUT", resource: (version === 2) ? (type+"/"+id) : id, data: patch, version: version })
+				.then(function(response) {
+					resolve(response);
+				})
+				.catch(function(error) {
+					reject(error);
+				});
+			});
+		}
+
+		// RE-FETCH RULE (RECEIVES NO UPDATES VIA SSE)
+		this.refetchRule = function(id)
+		{
+			return new Promise(function(resolve, reject)
+			{
+				API.request({ resource: "/rules/" + id, version: 1 })
+				.then(function(rule)
+				{
+					// "RENAME" OWNER
+					rule["_owner"] = rule["owner"];
+					delete rule["owner"];
+
+					// ADD RULE ID(S)
+					rule["id"] = "rule_" + id;
+					rule["id_v1"] = "/rules/" + id;
+
+					// ADD RULE TYPE
+					rule["type"] = "rule";
+
+					// UPDATED TIME
+					rule["updated"] = dayjs().format();
+
+					// ADD BACK TO RESOURCES
+					scope.resources[rule["id"]] = rule;
+
+					// PUSH UPDATED STATE
+					scope.pushUpdatedState(rule, "rule");
+					resolve(resolve);
+				})
+				.catch(function(error) {
+					reject(error);
+				});
+			});
+		}
+
+		// SUBSCRIBE (FROM NODES)
+		this.subscribe = function(type, id = null, callback = null)
+		{
+			// IS RULE?
+			if(type == "rule" && !!id)
+			{
+				id = "rule_" + id;
 			}
 
-			// RETURN UPDATES
-			return updates;
+			// PUSH WHITELIST
+			const messageWhitelist = {
+				"light": ["light", "zigbee_connectivity", "zgp_connectivity", "device"],
+				"motion": ["motion", "zigbee_connectivity", "zgp_connectivity", "device_power", "device"],
+				"temperature": ["temperature", "zigbee_connectivity", "zgp_connectivity", "device_power", "device"],
+				"light_level": ["light_level", "zigbee_connectivity", "zgp_connectivity", "device_power", "device"],
+				"button": ["button", "zigbee_connectivity", "zgp_connectivity", "device_power", "device"],
+				"group": ["group", "light", "grouped_light"],
+				"rule": ["rule"]
+			};
+
+			if(!id)
+			{
+				// UNIVERSAL MODE
+				this.events.on("globalResourceUpdates", function(info)
+				{
+					if(type === "bridge")
+					{
+						callback(info);
+					}
+					else if(info.services.includes(type) && messageWhitelist[type].includes(info.updatedType))
+					{
+						callback(info);
+					}
+					else if(type == "rule" && messageWhitelist[type].includes(info.updatedType))
+					{
+						callback(info);
+					}
+				});
+			}
+			else
+			{
+				// SPECIFIC RESOURCE MODE
+				this.events.on(id, function(info)
+				{
+					if(type === "bridge" || messageWhitelist[type].includes(info.updatedType))
+					{
+						callback(info);
+					}
+				});
+			}
 		}
 
-		// EMIT UPDATES
-		this.emitUpdates = function(device, updates)
+		// AUTO UPDATES?
+		this.autoUpdateFirmware = function()
 		{
-			for(let deviceUpdate of updates)
+			if((config.autoupdates && config.autoupdates == true) || typeof config.autoupdates == 'undefined')
 			{
-				let eventName = device + deviceUpdate.id;
-				scope.events.emit(eventName, deviceUpdate);
-				scope.events.emit(device, deviceUpdate);
-				scope.events.emit("globalDeviceUpdates", {type: device, payload: deviceUpdate});
+				scope.log("Checking for Hue Bridge firmware updates…");
+				API.request({
+					method: "PUT",
+					resource: "/config",
+					version: 1,
+					data: {
+						swupdate2: {
+							checkforupdate: true,
+							install: true
+						}
+					}
+				})
+				.then(function(status)
+				{
+					if(scope.nodeActive == true)
+					{
+						setTimeout(function(){ scope.autoUpdateFirmware(); }, 60000 * 5);
+					}
+				})
+				.catch(function(error)
+				{
+					// NO UPDATES AVAILABLE // TRY AGAIN IN 3H
+					if(scope.nodeActive == true)
+					{
+						setTimeout(function(){ scope.autoUpdateFirmware(); }, 60000 * 180);
+					}
+				});
 			}
 		}
 
+		//
+		// START THE MAGIC
+		this.start();
+
 		//
 		// CLOSE NODE / REMOVE EVENT LISTENER
 		this.on('close', function()
 		{
 			scope.nodeActive = false;
+
+			// UNSUBSCRIBE FROM BRIDGE EVENTS
+			scope.log("Unsubscribing from bridge events…");
+			API.unsubscribe();
+
+			// UNSUBSCRIBE FROM "READY" EVENTS
+			scope.events.removeAllListeners();
 		});
 	}
 
@@ -229,16 +595,29 @@ module.exports = function(RED)
 
 	//
 	// DISCOVER HUE BRIDGES ON LOCAL NETWORK
-	RED.httpAdmin.get('/hue/bridges', function(req, res, next)
+	RED.httpAdmin.get('/hue/bridges', async function(req, res, next)
 	{
-		let huejay = require('huejay');
+		axios({
+			"method": "GET",
+			"url": "https://discovery.meethue.com",
+			"headers": {
+				"Content-Type": "application/json; charset=utf-8"
+			},
+		})
+		.then(function(response)
+		{
+			// PREPARE BRIDGES OUTPUT
+			var bridges = {};
+			for (var i = response.data.length - 1; i >= 0; i--)
+			{
+				var ipAddress = response.data[i].internalipaddress;
+				bridges[ipAddress] = { ip: ipAddress, name: ipAddress };
+			}
 
-		huejay.discover()
-		.then(bridges => {
-			res.end(JSON.stringify(bridges));
+			res.end(JSON.stringify(Object.values(bridges)));
 		})
-		.catch(error => {
-			res.send(500).send(error.message);
+		.catch(function(error) {
+			res.send(error);
 		});
 	});
 
@@ -252,17 +631,12 @@ module.exports = function(RED)
 	    }
 	    else
 	    {
-			var huejay = require('huejay');
-
-			var bridgeIP = (req.query.ip).toString();
-			var client = new huejay.Client({host: bridgeIP, username: 'default'});
-
-			client.bridge.get()
-			.then(bridge => {
+			API.init({ ip: req.query.ip })
+			.then(function(bridge) {
 				res.end(bridge.name);
 			})
-			.catch(error => {
-				res.send(500).send(error.message);
+			.catch(function(error) {
+				res.send(error);
 			});
 	    }
 	});
@@ -277,200 +651,138 @@ module.exports = function(RED)
 		}
 		else
 		{
-			var request = require('request');
-			let bridgeIP = (req.query.ip).toString();
-
-			request.post('http://'+bridgeIP+'/api', {body: JSON.stringify({"devicetype": "nodered_" + Math.floor((Math.random() * 100) + 1)}) }, function(err,httpResponse,body)
+			axios({
+				"method": "POST",
+				"url": "http://"+req.query.ip+"/api",
+				"httpsAgent": new https.Agent({ rejectUnauthorized: false }),
+				"headers": {
+					"Content-Type": "application/json; charset=utf-8"
+				},
+				"data": {
+					"devicetype": "huemagic_" + Math.floor((Math.random() * 100) + 1)
+				}
+			})
+			.then(function(response)
 			{
-				if(err)
+				var bridge = response.data;
+				if(bridge[0].error)
 				{
 					rescope.end("error");
 				}
 				else
 				{
-					var bridge = JSON.parse(body);
-
-					if(bridge[0].error)
-					{
-						rescope.end("error");
-					}
-					else
-					{
-						rescope.end(JSON.stringify(bridge));
-					}
+					rescope.end(JSON.stringify(bridge));
 				}
+			})
+			.catch(function(error) {
+				rescope.status(500).send(error);
 			});
 		}
 	});
 
 	//
-	// DISCOVER SENSORS
-	RED.httpAdmin.get('/hue/sensors', function(req, res, next)
+	// DISCOVER RESOURCES
+	RED.httpAdmin.get('/hue/resources', function(req, res, next)
 	{
-		let huejay = require('huejay');
-		var bridge = (req.query.bridge).toString();
-		var username = req.query.key;
-		var type = req.query.type;
-
-		let client = new huejay.Client({
-			host: bridge,
-			username: username
-		});
-
-		client.sensors.getAll()
-		.then(sensors => {
-			var allSensorDevices = [];
+		const targetType = req.query.type;
 
-			for (let sensor of sensors)
+		// GET ALL RULES
+		if(targetType == "rule")
+		{
+			API.init({ ip: req.query.bridge, key: req.query.key })
+			.then(function(bridge) {
+				return API.request({ resource: "/rules", version: 1 });
+			})
+			.then(function(rules)
 			{
-				if(sensor.type == type)
+				let targetRules = {};
+
+				for (var [id, rule] of Object.entries(rules))
 				{
-					var oneSensor = {};
-					oneSensor.id = sensor.id;
-					oneSensor.name = sensor.name;
-					oneSensor.model = sensor.model.name;
-					oneSensor.model_id = sensor.attributes.attributes.modelid;
+					var oneDevice = {};
+					oneDevice.id = id;
+					oneDevice.name = rule.name;
+					oneDevice.model = false;
 
-					allSensorDevices.push(oneSensor);
+					targetRules[id] = oneDevice;
 				}
-			}
-
-			res.end(JSON.stringify(allSensorDevices));
-		})
-		.catch(error => {
-			res.send(500).send(error.stack);
-		});
-	});
 
-	//
-	// DISCOVER LIGHTS
-	RED.httpAdmin.get('/hue/lights', function(req, res, next)
-	{
-		let huejay = require('huejay');
-		var bridge = (req.query.bridge).toString();
-		var username = req.query.key;
+				// CONVERT TO ARRAY
+				targetRules = Object.values(targetRules);
 
-		let client = new huejay.Client({
-			host: bridge,
-			username: username
-		});
-
-		client.lights.getAll()
-		.then(lights => {
-			var allLights = [];
-
-			for (let light of lights)
-			{
-				var oneLightBulb = {};
-				oneLightBulb.id = light.id;
-				oneLightBulb.name = light.name;
-
-				allLights.push(oneLightBulb);
-			}
-
-			res.end(JSON.stringify(allLights));
-		})
-		.catch(error => {
-			res.send(500).send(error.stack);
-		});
-	});
-
-	//
-	// DISCOVER GROUPS
-	RED.httpAdmin.get('/hue/groups', function(req, res, next)
-	{
-		let huejay = require('huejay');
-		var bridge = (req.query.bridge).toString();
-		var username = req.query.key;
-
-		let client = new huejay.Client({
-			host: bridge,
-			username: username
-		});
-
-		client.groups.getAll()
-		.then(groups => {
-			var allGroups = [];
-
-			for (let group of groups)
+				// GIVE BACK
+				res.end(JSON.stringify(targetRules));
+			})
+			.catch(function(error) {
+				res.status(500).send(JSON.stringify(error));
+			});
+		}
+		// GET ALL OTHER RESOURCES
+		else
+		{
+			API.init({ ip: req.query.bridge, key: req.query.key })
+			.then(function(bridge) {
+				return API.request({ resource: "all" });
+			})
+			.then(function(allResources)
 			{
-				var oneGroup = {};
-				oneGroup.id = group.id;
-				oneGroup.name = group.name;
-
-				allGroups.push(oneGroup);
-			}
-
-			res.end(JSON.stringify(allGroups));
-		})
-		.catch(error => {
-			res.send(500).send(error.stack);
-		});
-	});
-
-	//
-	// DISCOVER SCENES
-	RED.httpAdmin.get('/hue/scenes', function(req, res, next)
-	{
-		let huejay = require('huejay');
-		var bridge = (req.query.bridge).toString();
-		var username = req.query.key;
-
-		let client = new huejay.Client({
-			host: bridge,
-			username: username
-		});
-
-		client.scenes.getAll()
-		.then(scenes => {
-			var allScenes = [];
-
-			for (let scene of scenes)
+				return API.processResources(allResources);
+			})
+			.then(function(processedResources)
 			{
-				var oneScene = {};
-				oneScene.id = scene.id;
-				oneScene.name = scene.name;
-
-				allScenes.push(oneScene);
-			}
+				let targetDevices = {};
 
-			res.end(JSON.stringify(allScenes));
-		})
-		.catch(error => {
-			res.send(500).send(error.stack);
-		});
-	});
+				for (const [id, resource] of Object.entries(processedResources))
+				{
+					const isGroup = (resource["type"] == "room" || resource["type"] == "zone" || resource["type"] == "bridge_home");
 
-	//
-	// DISCOVER RULES
-	RED.httpAdmin.get('/hue/rules', function(req, res, next)
-	{
-		let huejay = require('huejay');
-		var bridge = (req.query.bridge).toString();
-		var username = req.query.key;
+					// NORMAL DEVICES
+					if(!isGroup && resource["services"] && resource["services"][targetType])
+					{
+						for (const [deviceID, targetDevice] of Object.entries(resource["services"][targetType]))
+						{
+							var oneDevice = {};
+							oneDevice.id = id;
+							oneDevice.name = resource.metadata ? resource.metadata.name : false;
+							oneDevice.model = resource.product_data ? resource.product_data.product_name : false;
 
-		let client = new huejay.Client({
-			host: bridge,
-			username: username
-		});
+							targetDevices[id] = oneDevice;
+						}
+					}
+					// GROUPED (LIGHT) RESOURCES
+					else if(isGroup && targetType === "group")
+					{
+						if(resource["services"] && resource["services"]["grouped_light"])
+						{
+							var oneDevice = {};
+							oneDevice.id = id;
+							oneDevice.name = resource.metadata ? resource.metadata.name : false;
+							oneDevice.model = resource["type"];
 
-		client.rules.getAll()
-		.then(rules => {
-			var allRules = [];
+							targetDevices[id] = oneDevice;
+						}
+					}
+					// SCENES
+					else if(targetType === "scene" && resource["type"] == "scene")
+					{
+						var oneDevice = {};
+						oneDevice.id = id;
+						oneDevice.name = resource.metadata ? resource.metadata.name : false;
+						oneDevice.group = processedResources[resource["group"]["rid"]].metadata.name;
 
-			for (let rule of rules)
-			{
-				var oneRule = {};
-				oneRule.id = rule.id;
-				oneRule.name = rule.name;
+						targetDevices[id] = oneDevice;
+					}
+				}
 
-				allRules.push(oneRule);
-			}
+				// CONVERT TO ARRAY
+				targetDevices = Object.values(targetDevices);
 
-			res.end(JSON.stringify(allRules));
-		})
-		.catch(error => {
-			res.send(500).send(error.stack);
-		});
+				// GIVE BACK
+				res.end(JSON.stringify(targetDevices));
+			})
+			.catch(function(error) {
+				res.status(500).send(JSON.stringify(error));
+			});
+		}
 	});
 };