node-red-contrib-huemagic 4.0.2 → 4.1.0

package/huemagic/utils/api.js

@@ -5,83 +5,77 @@ const EventSource = require('eventsource');
 
 function API()
 {
-	// STORAGE
-	this.bridge = null;
-	this.ipAddress = null;
-	this.accessKey = null;
-	this.events = null;
+	// EVENTS
+	this.events = {};
 
 	//
 	// INITIALIZE
-	this.init = function({ ip, key = 'default' })
+	this.init = function({ config = null })
 	{
 		const scope = this;
 
-		// FORCE RELOAD?
-		const forceReload = (this.ipAddress != ip.toString().trim());
-
-		// STORE ACCESS INFORMATION
-		this.ipAddress = ip.toString().trim();
-		this.accessKey = key.toString().trim();
-
 		// GET BRIDGE
 		return new Promise(function(resolve, reject)
 		{
-			if(scope.bridge !== null && forceReload === false)
+			if(!config)
 			{
-				resolve(scope.bridge);
+				reject("Bridge is not configured!");
+				return false;
 			}
-			else
+
+			// GET BRIDGE INFORMATION
+			axios({
+				"method": "GET",
+				"url": "https://" + config.bridge + "/api/config",
+				"headers": { "Content-Type": "application/json; charset=utf-8" },
+				"httpsAgent": new https.Agent({ rejectUnauthorized: false }),
+			})
+			.then(function(response)
 			{
-				// GET BRIDGE INFORMATION
-				axios({
-					"method": "GET",
-					"url": "https://" + ip + "/api/config",
-					"headers": { "Content-Type": "application/json; charset=utf-8" },
-					"httpsAgent": new https.Agent({ rejectUnauthorized: false }),
-				})
-				.then(function(response)
-				{
-					scope.bridge = response.data;
-					resolve(scope.bridge);
-				})
-				.catch(function(error)
-				{
-					reject(error);
-				});
-			}
+				resolve(response.data);
+			})
+			.catch(function(error)
+			{
+				reject(error);
+			});
 		});
 	}
 
 	//
 	// MAKE A REQUEST
-	this.request = function({ method = 'GET', ressource = null, data = null, version = 2 })
+	this.request = function({ config = null, method = 'GET', resource = null, data = null, version = 2 })
 	{
 		const scope = this;
 		return new Promise(function(resolve, reject)
 		{
+			if(!config)
+			{
+				reject("Bridge is not configured!");
+				return false;
+			}
+
 			// BUILD REQUEST OBJECT
 			var request = {
 				"method": method,
-				"url": "https://" + scope.ipAddress,
+				"url": "https://" + config.bridge,
 				"headers": {
 					"Content-Type": "application/json; charset=utf-8",
-					"hue-application-key": scope.accessKey
+					"hue-application-key": config.key
 				},
 				"httpsAgent": new https.Agent({ rejectUnauthorized: false }), // Node is somehow not able to parse the official Philips Hue PEM
 			};
 
-			// HAS RESSOURCE? -> APPEND
-			if(ressource !== null)
+			// HAS RESOURCE? -> APPEND
+			if(resource !== null)
 			{
 				if(version === 2)
 				{
-					ressource = (ressource !== "all") ? "/"+ressource : "";
-					request['url'] += "/clip/v2/resource" + ressource;
+					resource = (resource !== "all") ? "/"+resource : "";
+					request['url'] += "/clip/v2/resource" + resource;
 				}
 				else if(version === 1)
 				{
-					request['url'] += "/api/" + scope.accessKey + ressource;
+					request['url'] += "/api/" + config.key + resource;
 				}
 			}
 
@@ -119,23 +113,23 @@ function API()
 
 	//
 	// SUBSCRIBE TO BRIDGE EVENTS
-	this.subscribe = function(callback)
+	this.subscribe = function(config, callback)
 	{
 		const scope = this;
 		return new Promise(function(resolve, reject)
 		{
-			if(scope.events === null)
+			if(!scope.events[config.id])
 			{
-				var sseURL = "https://" + scope.ipAddress + "/eventstream/clip/v2";
+				var sseURL = "https://" + config.bridge + "/eventstream/clip/v2";
 
 				// INITIALIZE EVENT SOURCE
-				scope.events = new EventSource(sseURL, {
-					headers: { 'hue-application-key': scope.accessKey },
+				scope.events[config.id] = new EventSource(sseURL, {
+					headers: { 'hue-application-key': config.key },
 					https: { rejectUnauthorized: false },
 				});
 
 				// PIPE MESSAGE TO TARGET FUNCTION
-				scope.events.onmessage = function(event)
+				scope.events[config.id].onmessage = function(event)
 				{
 					if(event && event.type === 'message' && event.data)
 					{
@@ -152,71 +146,71 @@ function API()
 				};
 
 				// CONNECTED?
-				scope.events.onopen = function()
+				scope.events[config.id].onopen = function()
 				{
 					resolve(true);
 				}
 
 				// ERROR? -> RETRY?
-				scope.events.onerror = function(error)
+				scope.events[config.id].onerror = function(error)
 				{
 					console.log("HueMagic:", "Connection to bridge lost. Trying to reconnect again in 30 seconds…", err);
-					setTimeout(function(){ scope.subscribe(callback); }, 30000);
+					setTimeout(function(){ scope.subscribe(config, callback); }, 30000);
 					resolve(true);
 				}
 			}
 			else
 			{
-				scope.unsubscribe();
-				scope.subscribe(callback);
+				scope.unsubscribe(config);
+				scope.subscribe(config, callback);
 			}
 		});
 	}
 
 	//
 	// UNSUBSCRIBE
-	this.unsubscribe = function()
+	this.unsubscribe = function(config)
 	{
-		if(this.events !== null) { this.events.close(); }
-		this.events = null;
+		if(this.events[config.id] !== null) { this.events[config.id].close(); }
+		this.events[config.id] = null;
 	}
 
 	//
-	// GET FULL/ROOT RESSOURCE
-	this.fullRessource = function(ressource, allRessources = {})
+	// GET FULL/ROOT RESOURCE
+	this.fullResource = function(resource, allResources = {})
 	{
 		const scope = this;
-		var fullRessource = Object.assign({}, ressource);
+		var fullResource = Object.assign({}, resource);
 
-		if(ressource["owner"])
+		if(resource["owner"])
 		{
-			fullRessource = scope.fullRessource(allRessources[fullRessource["owner"]["rid"]], allRessources);
+			fullResource = scope.fullResource(allResources[fullResource["owner"]["rid"]], allResources);
 		}
-		else if(ressource["type"] === "device" || ressource["type"] === "room" || ressource["type"] === "zone" || ressource["type"] === "bridge_home")
+		else if(resource["type"] === "device" || resource["type"] === "room" || resource["type"] === "zone" || resource["type"] === "bridge_home")
 		{
 			// RESOLVE SERVICES
 			var allServices = {};
 
-			for (var i = ressource["services"].length - 1; i >= 0; i--)
+			for (var i = resource["services"].length - 1; i >= 0; i--)
 			{
-				const targetService = ressource["services"][i];
+				const targetService = resource["services"][i];
 				const targetType = targetService["rtype"];
 				const targetID = targetService["rid"];
 
 				if(!allServices[targetType]) { allServices[targetType] = {}; }
-				allServices[targetType][targetID] = Object.assign({}, allRessources[targetID]);
+				allServices[targetType][targetID] = Object.assign({}, allResources[targetID]);
 			}
 
 			// REPLACE SERVICES
-			fullRessource["services"] = allServices;
+			fullResource["services"] = allServices;
 		}
 
-		return fullRessource;
+		return fullResource;
 	}
 
 	//
-	// PROCESS RESSOURCES
-	this.processRessources = function(ressources)
+	// PROCESS RESOURCES
+	this.processResources = function(resources)
 	{
 		const scope = this;
 
@@ -226,62 +220,62 @@ function API()
 		// ACTION!
 		return new Promise(function(resolve, reject)
 		{
-			let ressourceList = {};
-			let processedRessources = {
+			let resourceList = {};
+			let processedResources = {
 				_groupsOf: {}
 			};
 
-			// CREATE ID BASED OBJECT OF ALL RESSOURCES
-			ressources.forEach(function(ressource, index)
+			// CREATE ID BASED OBJECT OF ALL RESOURCES
+			resources.forEach(function(resource, index)
 			{
 				// IS BUTTON? -> REMOVE PREVIOUS STATE
-				if(ressource.type === "button")
+				if(resource.type === "button")
 				{
-					delete ressource["button"];
+					delete resource["button"];
 				}
 
-				ressourceList[ressource.id] = ressource;
+				resourceList[resource.id] = resource;
 			});
 
-			// GET FULL RESSOURCES OF EACH OBJECT
-			ressources.forEach(function(ressource, index)
+			// GET FULL RESOURCES OF EACH OBJECT
+			resources.forEach(function(resource, index)
 			{
-				// GET FULL RESSOURCE
-				let fullRessource = scope.fullRessource(ressource, ressourceList);
+				// GET FULL RESOURCE
+				let fullResource = scope.fullResource(resource, resourceList);
 
 				// ADD CURRENT DATE/TIME
-				fullRessource["updated"] = currentDateTime;
+				fullResource["updated"] = currentDateTime;
 
-				// ALL ALL TYPES BEHIND RESSOURCE
-				fullRessource["types"] = [ fullRessource["type"] ];
+				// ALL ALL TYPES BEHIND RESOURCE
+				fullResource["types"] = [ fullResource["type"] ];
 
-				// RESSOURCE HAS SERVICES?
-				if(fullRessource["services"])
+				// RESOURCE HAS SERVICES?
+				if(fullResource["services"])
 				{
-					let additionalServiceTypes = Object.keys(fullRessource["services"]);
+					let additionalServiceTypes = Object.keys(fullResource["services"]);
 
 					// SET ADDITIONAL TYPES BEHIND RECCOURCE
-					fullRessource["types"] = fullRessource["types"].concat(additionalServiceTypes);
+					fullResource["types"] = fullResource["types"].concat(additionalServiceTypes);
 				}
 
 				// RESOURCE HAS GROUPED SERVICES?
-				if(fullRessource["grouped_services"])
+				if(fullResource["grouped_services"])
 				{
-					for (var g = fullRessource["grouped_services"].length - 1; g >= 0; g--)
+					for (var g = fullResource["grouped_services"].length - 1; g >= 0; g--)
 					{
-						const groupedService = fullRessource["grouped_services"][g];
+						const groupedService = fullResource["grouped_services"][g];
 						const groupedServiceID = groupedService["rid"];
 
-						if(!processedRessources["_groupsOf"][groupedServiceID]) { processedRessources["_groupsOf"][groupedServiceID] = []; }
-						processedRessources["_groupsOf"][groupedServiceID].push(fullRessource.id);
+						if(!processedResources["_groupsOf"][groupedServiceID]) { processedResources["_groupsOf"][groupedServiceID] = []; }
+						processedResources["_groupsOf"][groupedServiceID].push(fullResource.id);
 					}
 				}
 
-				// GIVE FULL RESSOURCE BACK TO COLLECTION
-				processedRessources[fullRessource.id] = fullRessource;
+				// GIVE FULL RESOURCE BACK TO COLLECTION
+				processedResources[fullResource.id] = fullResource;
 			});
 
-			resolve(processedRessources);
+			resolve(processedResources);
 		});
 	}
 }