Brought in latest

package.json

@@ -12,34 +12,36 @@
   "license": "ISC",
   "dependencies": {
     "ad2usb": "git+https://github.com/alistairg/node-ad2usb.git#local",
+    "async": "^1.4.2",
     "carwingsjs": "0.0.x",
     "chokidar": "^1.0.5",
     "color": "0.10.x",
+    "debug": "^2.2.0",
     "eibd": "^0.3.1",
     "elkington": "kevinohara80/elkington",
     "hap-nodejs": "^0.0.2",
     "harmonyhubjs-client": "^1.1.4",
     "harmonyhubjs-discover": "git+https://github.com/swissmanu/harmonyhubjs-discover.git",
     "isy-js": "",
-    "lifx-api": "^1.0.1",
+    "komponist": "0.1.0",
     "lifx": "git+https://github.com/magicmonkey/lifxjs.git",
+    "lifx-api": "^1.0.1",
     "mdns": "^2.2.4",
     "node-hue-api": "^1.0.5",
     "node-icontrol": "^0.1.5",
     "node-milight-promise": "0.0.x",
     "node-persist": "0.0.x",
     "q": "1.4.x",
-    "tough-cookie": "^2.0.0",
     "request": "2.49.x",
     "sonos": "0.8.x",
+    "telldus-live": "^0.2.1",
     "teslams": "1.0.1",
+    "tough-cookie": "^2.0.0",
     "unofficial-nest-api": "git+https://github.com/hachidorii/unofficial_nodejs_nest.git#d8d48edc952b049ff6320ef99afa7b2f04cdee98",
     "wemo": "0.2.x",
     "wink-js": "0.0.5",
     "xml2js": "0.4.x",
     "xmldoc": "0.1.x",
-    "komponist" : "0.1.0",
+    "yamaha-nodejs": "0.4.x"
-    "yamaha-nodejs": "0.4.x",
-    "debug": "^2.2.0"
   }
 }

platforms/Indigo.js

@@ -68,7 +68,7 @@ IndigoPlatform.prototype = {
             }
 
             var json = JSON.parse(body);
-            async.each(json, function(item, asyncCallback) {
+            async.eachSeries(json, function(item, asyncCallback) {
                 var deviceURL = that.baseURL + item.restURL;
                 var deviceOptions = {
                   url: deviceURL,
@@ -81,15 +81,19 @@ IndigoPlatform.prototype = {
                 request(deviceOptions, function(deviceError, deviceResponse, deviceBody) {
                     if (deviceError) {
                         console.trace("Requesting Indigo device info: " + deviceURL + "\nError: " + deviceError + "\nResponse: " + deviceBody);
-                        asyncCallback(deviceError)
                     }
                     else {
-                        var deviceJson = JSON.parse(deviceBody);
+                        try {
-                        that.log("Discovered " + deviceJson.type + ": " + deviceJson.name);
+                            var deviceJson = JSON.parse(deviceBody);
-                        that.foundAccessories.push(
+                            that.log("Discovered " + deviceJson.type + ": " + deviceJson.name);
-                            new IndigoAccessory(that.log, that.auth, deviceURL, deviceJson));
+                            that.foundAccessories.push(
-                        asyncCallback();
+                                new IndigoAccessory(that.log, that.auth, deviceURL, deviceJson));
+                        }
+                        catch (e) {
+                            that.log("Error parsing Indigo device info: " + deviceURL + "\nException: " + e + "\nResponse: " + deviceBody);
+                        }
                     }
+                    asyncCallback();
                 });
             }, function(asyncError) {
                 // This will be called after all the requests complete
@@ -135,11 +139,18 @@ IndigoAccessory.prototype = {
             if (error) {
                 console.trace("Requesting Device Status.");
                 that.log(error);
-                return error;
             }
-
+            else {
-            that.log("getStatus of " + that.name + ": " + body);
+                that.log("getStatus of " + that.name + ": " + body);
-            callback(JSON.parse(body));
+                try {
+                    var json = JSON.parse(body);
+                    callback(json);
+                }
+                catch (e) {
+                    console.trace("Requesting Device Status.");
+                    that.log("Exception: " + e + "\nResponse: " + body);
+                }
+            }
         });
     },
 

platforms/Openhab.js

@@ -0,0 +1,347 @@
+// OpenHAB Platform Shim for HomeBridge
+// Written by Tommaso Marchionni
+// Based on many of the other HomeBridge platform modules
+// 
+// Revisions:
+//
+// 17 October 2015 [tommasomarchionni]
+// - Initial release
+//
+// Remember to add platform to config.json. Example:
+// "platforms": [
+//     {
+//         "platform": "Openhab",
+//         "name": "Openhab",
+//         "server": "127.0.0.1",
+//         "port": "8080",
+//         "sitemap": "demo"
+//     }
+// ],
+//
+// Example of sitemap in OpenHAB:
+// sitemap homekit label="HomeKit" {
+//	   Switch item=Light_1 label="Light 1"
+// }
+//
+// When you attempt to add a device, it will ask for a "PIN code".
+// The default code for all HomeBridge accessories is 031-45-154.
+//
+
+var types = require("hap-nodejs/accessories/types.js");
+var request = require("request");
+var Service = require("hap-nodejs/lib/Service.js").Service;
+var Characteristic = require("hap-nodejs").Characteristic;
+
+function OpenhabPlatform(log, config){
+	this.log      = log;
+	this.user     = config["user"];
+	this.password = config["password"];
+	this.server   = config["server"];
+	this.port     = config["port"];
+	
+	this.protocol = "http";
+	
+	this.sitemap  = "demo";
+	if (typeof config["sitemap"] != 'undefined') {
+		this.sitemap = config["sitemap"];
+	}
+	
+}
+
+OpenhabPlatform.prototype = {
+    
+    sitemapUrl: function() {
+    	var serverString = this.server;
+    	//TODO da verificare
+    	if (this.user && this.password) {
+      		serverString = this.user + ":" + this.password + "@" + serverString;
+    	}
+    
+    	return this.protocol + "://" + serverString + ":" + this.port + "/rest/sitemaps/" + this.sitemap + "?type=json";
+  	},
+  	
+  	parseSitemap: function(sitemap) {
+		var widgets = [].concat(sitemap.homepage.widget);
+		var result = [];
+		for (var i = 0; i < widgets.length; i++) {
+			var widget = widgets[i];
+			if (!widget.item) {
+          		//TODO to handle frame
+          		this.log("WARN: The widget '" + widget.label + "' does not reference an item.");
+        		continue;
+        	}                	
+        
+        	if (widget.item.type=="SwitchItem" || widget.item.type=="DimmerItem" || widget.item.type == "RollershutterItem"){
+        		accessory = new OpenhabAccessory(this.log,this,widget.widgetId,widget.label,widget.item)
+            this.log("Accessory Found: " + widget.label);
+            result.push(accessory);
+        	}
+        
+        	
+        	
+    	}
+    	return result;
+	},
+    
+    accessories: function(callback) {
+        this.log("Fetching OpenHAB devices.");
+        var that = this;
+
+		url = that.sitemapUrl();
+		this.log("Connecting to " + url);
+		request.get({
+			url: url,
+			json: true
+		}, function(err, response, json) {
+			if (!err && response.statusCode == 200) {
+        		callback(that.parseSitemap(json));
+			} else {
+				that.log("There was a problem connecting to OpenHAB.");
+			}
+		});
+    }
+};
+
+function OpenhabAccessory(log, platform, widgetId, label, detail) {
+    this.log = log;
+    this.platform = platform;
+    this.idx = widgetId;
+    this.name = label;
+    this.label = label;
+    this.type = detail.type;
+    this.deviceURL = detail.link;
+    this.addressStr = "n/a";
+    this.state = detail.state;
+    
+    if (this.type == "DimmerItem") {
+    	this.typeSupportsOnOff = true;
+    	this.typeSupportsDim = true;
+    }
+    
+    if (this.type == "SwitchItem") {
+    	this.typeSupportsOnOff = true;
+    }
+    
+    if (this.type == "RollershutterItem") {
+    	this.typeSupportsWindowCovering = true;    	
+    }
+    
+}
+
+OpenhabAccessory.prototype = {
+
+    updateStatus: function(command) {
+        var that = this;
+        
+        var options = {
+            url: this.deviceURL,
+            method: 'POST',
+            body: "" + command
+        };
+        if (this.auth) {
+            options['auth'] = this.auth;
+        }
+        
+        that.log("eseguo post");
+        
+        request(options, function(error, response, body) {
+            if (error) {
+                console.trace("Updating Device Status.");
+                that.log(error);
+                return error;
+            }
+            
+        	that.log("updateStatus of " + that.name + ": " + command);        	
+            
+        });        
+    },
+	
+ 	getServiceType: function() {
+     	if (this.typeSupportsWindowCovering){
+     		return new Service.WindowCovering;
+     	} else if (this.typeSupportsDim) {
+         	return new Service.Lightbulb;
+     	} else if (this.typeSupportsOnOff) {
+         	return new Service.Switch;
+     	}
+   	},
+	
+	updateStatus: function(command, callback) {
+        var that = this;
+        
+        var options = {
+            url: this.deviceURL,
+            method: 'POST',
+            body: "" + command
+        };
+        if (this.auth) {
+            options['auth'] = this.auth;
+        }
+        
+        request(options, function(error, response, body) {
+            if (error) {
+                //console.trace("Updating Device Status.");
+                //that.log(error);
+                //return error;
+                callback(new Error(error));
+            } else {
+            	that.log("updateStatus of " + that.name + ": " + command); 
+            	callback(true);
+            }
+        }.bind(this));      
+    },
+	
+	setPowerState: function(powerOn, callback) {
+    	var that = this;
+		
+        if (this.typeSupportsOnOff) {
+            if (powerOn) {
+            	var command = "ON";
+            } else {
+            	var command = "OFF";
+            }
+            
+            this.log("Setting power state on the '"+this.name+"' to " + command);
+            this.updateStatus(command, function(noError){
+            	if (noError) {
+        			that.log("Successfully set '"+that.name+"' to " + command);
+        			callback();
+      			} else {
+      				callback(new Error('Can not communicate with OpenHAB.'));
+            	}
+            }.bind(this));
+            
+        }else{
+        	callback(new Error(this.name + " not supports ONOFF"));
+        }
+  	},
+	
+	getStatus: function(callback){
+		var that = this;
+    	this.log("Fetching status brightness for: " + this.name);
+
+		var options = {
+            url: this.deviceURL + '/state?type=json',
+            method: 'GET'
+        };
+        
+        if (this.auth) {
+            options['auth'] = this.auth;
+        }
+
+		request(options, function(error, response, body) {
+            if (error) {
+                //console.trace("Requesting Device Status.");
+                //that.log(error);
+                //return error;
+                callback(new Error('Can not communicate with Home Assistant.'));
+            } else {
+            	that.log("getStatus of " + that.name + ": " + body);
+            	callback(null,body);
+            }
+
+            
+            
+        }.bind(this));
+
+  	},
+  	
+  	getCurrentPosition: function(callback){
+  		callback(100);
+  	},
+  	
+  	getPositionState: function(callback){
+		this.log("Fetching position state for: " + this.name);
+		callback(Characteristic.PositionState.STOPPED);
+  	},
+	
+	setTargetPosition: function(level, callback) {
+    	var that = this;
+    	
+        this.log("Setting target position on the '"+this.name+"' to " + level);
+            
+        this.updateStatus(level, function(noError){
+            if (noError) {
+        		that.log("Successfully set position on the '"+that.name+"' to " + level);
+        		callback();
+      		} else {
+      			callback(new Error('Can not communicate with OpenHAB.'));
+            }
+        }.bind(this));
+        
+  	},
+	
+	setBrightness: function(level, callback) {
+    	var that = this;
+    	
+		if (this.typeSupportsDim && level >= 0 && level <= 100) {
+            
+            this.log("Setting brightness on the '"+this.name+"' to " + level);
+            
+            this.updateStatus(level, function(noError){
+            	if (noError) {
+        			that.log("Successfully set brightness on the '"+that.name+"' to " + level);
+        			callback();
+      			} else {
+      				callback(new Error('Can not communicate with OpenHAB.'));
+            	}
+            }.bind(this));
+        }
+  	},
+	
+	getServices: function() {
+    	
+	    var informationService = new Service.AccessoryInformation();
+
+    	informationService
+      		.setCharacteristic(Characteristic.Manufacturer, "OpenHAB")
+      		.setCharacteristic(Characteristic.Model, this.type)
+      		.setCharacteristic(Characteristic.SerialNumber, "1234567890")
+      		.setCharacteristic(Characteristic.Name, this.label);
+
+		var otherService = this.getServiceType();
+    	
+    	if (this.typeSupportsOnOff) {
+    		otherService
+      			.getCharacteristic(Characteristic.On)
+      			.on('get', this.getStatus.bind(this))
+      			.on('set', this.setPowerState.bind(this));
+      			
+      	}
+		
+		if (this.typeSupportsDim) {
+    		otherService
+      			.addCharacteristic(Characteristic.Brightness)
+      			.on('get', this.getStatus.bind(this))
+      			.on('set', this.setBrightness.bind(this));
+      	}
+      	
+      	if (this.typeSupportsWindowCovering) {
+      		var currentPosition = 100;
+      		
+      		otherService
+      			.getCharacteristic(Characteristic.CurrentPosition)
+  				.on('get', this.getCurrentPosition.bind(this))
+  				.setValue(currentPosition);	
+  			
+  			otherService
+  				.getCharacteristic(Characteristic.PositionState)
+  				.on('get', this.getPositionState.bind(this))
+  				.setValue(Characteristic.PositionState.STOPPED);
+  				
+  			otherService
+  				.getCharacteristic(Characteristic.TargetPosition)
+  				.on('get', this.getCurrentPosition.bind(this))
+  				.on('set', this.setTargetPosition.bind(this));
+  		
+  		}
+
+		console.log(informationService);
+		
+    	return [informationService, otherService];
+  	}
+    	
+}
+
+module.exports.accessory = OpenhabAccessory;
+module.exports.platform = OpenhabPlatform;