Added settings write synchronization

happens.

.gitattributes

@@ -1,5 +1,5 @@
 # Auto detect text files and perform LF normalization
-* text=auto
+text=auto
 
 # Custom for Visual Studio
 *.cs     diff=csharp

.gitignore

@@ -1,4 +1,3 @@
-target/
 pom.xml.tag
 pom.xml.releaseBackup
 pom.xml.versionsBackup
@@ -9,3 +8,7 @@ buildNumber.properties
 *.iml
 data
 .idea
+/target/
+/.settings/
+/start.bat
+/.classpath

.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ha-bridge</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -1,5 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.compliance=1.8
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -1,4 +0,0 @@
-activeProfiles=
-eclipse.preferences.version=1
-resolveWorkspaceProjects=true
-version=1

pom.xml

@@ -3,84 +3,228 @@
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 
-	<groupId>com.bwssytems.HABridge</groupId>
-	<artifactId>amazon-echo-bridge-compact</artifactId>
-	<version>0.1.0</version>
+	<groupId>com.bwssystems.HABridge</groupId>
+	<artifactId>ha-bridge</artifactId>
+	<version>4.5.0alpha-4</version>
 	<packaging>jar</packaging>
 
-	<name>Amazon Echo Bridge Compact</name>
-	<description>Emulates a Philips Hue bridge to allow the Amazon Echo to hook up to other HA using lightweight frameworks</description>
+	<name>HA Bridge</name>
+	<description>Emulates a Philips Hue bridge to allow the Amazon Echo to hook up to other HA systems, i.e. Vera or Harmony Hub or Nest, using lightweight frameworks</description>
 
 	<properties>
 		<java.version>1.8</java.version>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 	</properties>
 
+	<repositories>
+		<repository>
+	    	<id>jitpack.io</id>
+		    <url>https://jitpack.io</url>
+		</repository>
+	    <repository>
+	        <id>Eclipse Paho Repo</id>
+	        <url>https://repo.eclipse.org/content/repositories/paho-releases/</url>
+	    </repository>
+	</repositories>
+
 	<dependencies>
+		<dependency>
+		    <groupId>com.github.bwssytems</groupId>
+		    <artifactId>harmony-java-client</artifactId>
+		    <version>1.1.1</version>
+		    <exclusions>
+		       <exclusion> 
+		          <groupId>org.slf4j</groupId>
+		          <artifactId>slf4j-simple</artifactId>
+		       </exclusion>
+		       <exclusion> 
+		            <groupId>org.slf4j</groupId>
+		            <artifactId>log4j-over-slf4j</artifactId>
+		       </exclusion>
+		    </exclusions> 
+		</dependency>
+        <dependency>
+            <groupId>com.github.bwssytems</groupId>
+            <artifactId>nest-controller</artifactId>
+            <version>1.0.14</version>
+		    <exclusions>
+		       <exclusion> 
+		          <groupId>org.slf4j</groupId>
+		          <artifactId>slf4j-simple</artifactId>
+		       </exclusion>
+		       <exclusion> 
+		            <groupId>org.slf4j</groupId>
+		            <artifactId>log4j-over-slf4j</artifactId>
+		       </exclusion>
+		    </exclusions> 
+        </dependency>
 		<dependency>
 		    <groupId>com.sparkjava</groupId>
 		    <artifactId>spark-core</artifactId>
-		    <version>2.2</version>
+		    <version>2.3</version>
+		    <exclusions>
+		    	<exclusion>
+		    		<artifactId>slf4j-simple</artifactId>
+		    		<groupId>org.slf4j</groupId>
+		    	</exclusion>
+		    </exclusions>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.httpcomponents</groupId>
 			<artifactId>httpclient</artifactId>
-			<version>4.3.6</version>
+			<version>4.5.1</version>
 		</dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpcore</artifactId>
+            <version>4.4.4</version>
+        </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-simple</artifactId>
+            <artifactId>slf4j-api</artifactId>
             <version>1.7.5</version>
         </dependency>
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-classic</artifactId>
+			<version>1.1.5</version>
+		</dependency>
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.2.4</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>2.6.0</version>
+            <version>2.6.2</version>
         </dependency>
+		<dependency>
+		  <groupId>net.java.dev.eval</groupId>
+		  <artifactId>eval</artifactId>
+		  <version>0.5</version>
+		</dependency>
+		<dependency>
+			<groupId>com.google.inject</groupId>
+			<artifactId>guice</artifactId>
+			<version>4.0-beta4</version>
+		</dependency>
+		<dependency>
+		  <groupId>org.igniterealtime.smack</groupId>
+		  <artifactId>smack-core</artifactId>
+		  <version>4.0.7</version>
+		</dependency>
+	    <dependency>
+	        <groupId>org.eclipse.paho</groupId>
+	        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
+	        <version>1.1.0</version>
+	    </dependency>
+		<dependency>
+		    <groupId>junit</groupId>
+		    <artifactId>junit</artifactId>
+		    <version>4.11</version>
+		</dependency>
+		<dependency>
+		  <groupId>com.github.bwssytems</groupId>
+		  <artifactId>lifx-sdk-java</artifactId>
+		  <version>2.1.6</version>
+		</dependency>
+		<dependency>
+		  <groupId>org.apache.commons</groupId>
+		  <artifactId>commons-lang3</artifactId>
+		  <version>3.5</version>
+		</dependency>
 	</dependencies>
-	
+
 	<build>
-	        <plugins>
-	            <plugin>
-	                <groupId>org.apache.maven.plugins</groupId>
-	                <artifactId>maven-shade-plugin</artifactId>
-	                <version>2.3</version>
-	                <configuration>
-	                    <createDependencyReducedPom>true</createDependencyReducedPom>
-	                    <filters>
-	                        <filter>
-	                            <artifact>*:*</artifact>
-	                            <excludes>
-	                                <exclude>META-INF/*.SF</exclude>
-	                                <exclude>META-INF/*.DSA</exclude>
-	                                <exclude>META-INF/*.RSA</exclude>
-	                            </excludes>
-	                        </filter>
-	                    </filters>
-	                </configuration>
-	                <executions>
-	                    <execution>
-	                        <phase>package</phase>
-	                        <goals>
-	                            <goal>shade</goal>
-	                        </goals>
-	                        <configuration>
-	                            <transformers>
-	                                <transformer
-	                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-	                                    <mainClass>com.bwssytems.HABridge.AmazonEchoBridge</mainClass>
-	                                </transformer>
-	                            </transformers>
-	                        </configuration>
-	                    </execution>
-	                </executions>
-	            </plugin>
-	        </plugins>
+	    <resources>
+	      <resource>
+	        <directory>src/main/resources</directory>
+	        <includes>
+	          <include>version.properties</include>
+	        </includes>
+	        <filtering>true</filtering>
+	      </resource>
+	      <resource>
+	        <directory>src/main/resources</directory>
+	        <excludes>
+	          <exclude>version.properties</exclude>
+	        </excludes>
+	        <filtering>false</filtering>
+	      </resource>
+	    </resources>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-shade-plugin</artifactId>
+				<version>2.4.3</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>shade</goal>
+						</goals>
+						<configuration>
+							<minimizeJar>true</minimizeJar>
+							<filters>
+								<filter>
+									<artifact>*:*</artifact>
+									<excludes>
+										<exclude>META-INF/*.SF</exclude>
+										<exclude>META-INF/*.DSA</exclude>
+										<exclude>META-INF/*.RSA</exclude>
+										<exclude>META-INF/*.txt</exclude>
+										<exclude>META-INF/maven/**</exclude>
+										<exclude>about_files/**</exclude>
+									</excludes>
+								</filter>
+								<filter>
+									<artifact>*:*</artifact>
+								</filter>
+								<filter>
+									<artifact>org.slf4j:slf4j-api</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+								<filter>
+									<artifact>commons-logging:commons-logging</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+								<filter>
+									<artifact>xpp3:xpp3</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+								<filter>
+									<artifact>org.igniterealtime.smack:*</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+								<filter>
+									<artifact>com.github.bwssytems:harmony-java-client</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+								<filter>
+									<artifact>org.eclipse.paho:org.eclipse.paho.client.mqttv3</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
+							</filters>
+							<transformers>
+								<transformer
+									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+									<mainClass>com.bwssystems.HABridge.HABridge</mainClass>
+								</transformer>
+							</transformers>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
 	</build>
-</project>
+</project>

src/main/java/com/bwssystems/HABridge/BridgeControlDescriptor.java

@@ -0,0 +1,34 @@
+package com.bwssystems.HABridge;
+
+public class BridgeControlDescriptor {
+	private boolean reinit;
+	private boolean stop;
+	private boolean linkButton;
+
+	public BridgeControlDescriptor() {
+		super();
+		this.reinit = false;
+		this.stop = false;
+	}
+
+	public boolean isReinit() {
+		return reinit;
+	}
+	public void setReinit(boolean reinit) {
+		this.reinit = reinit;
+	}
+	public boolean isStop() {
+		return stop;
+	}
+	public void setStop(boolean stop) {
+		this.stop = stop;
+	}
+
+	public boolean isLinkButton() {
+		return linkButton;
+	}
+
+	public void setLinkButton(boolean linkButton) {
+		this.linkButton = linkButton;
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSecurity.java

@@ -0,0 +1,263 @@
+package com.bwssystems.HABridge;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.GeneralSecurityException;
+import java.util.Base64;
+import java.util.HashMap;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.PBEParameterSpec;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+
+import spark.Request;
+
+public class BridgeSecurity {
+	private static final Logger log = LoggerFactory.getLogger(BridgeSecurity.class);
+	private static final String USER_SESSION_ID = "user";
+    private static final byte[] SALT = {
+            (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
+            (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
+        };
+	private char[] habridgeKey;
+    private BridgeSecurityDescriptor securityDescriptor;
+	private boolean settingsChanged;
+
+	public BridgeSecurity(char[] theKey) {
+		habridgeKey = theKey;
+		securityDescriptor = null;
+		settingsChanged = false;
+	}
+
+	public void setSecurityData(String theData) {
+		String anError = null;
+		if(theData != null && !theData.isEmpty()) {
+			try {
+				securityDescriptor = new Gson().fromJson(decrypt(theData), BridgeSecurityDescriptor.class);
+			} catch (JsonSyntaxException e) {
+				anError = e.getMessage();
+			} catch (GeneralSecurityException e) {
+				anError = e.getMessage();
+			} catch (IOException e) {
+				anError = e.getMessage();
+			}
+			log.warn("Cound not get security data, using default security (none): " + anError);
+		}
+		
+		if(theData == null || anError != null) {
+			securityDescriptor = new BridgeSecurityDescriptor();
+		}
+	}
+
+	public String getSecurityDescriptorData() throws UnsupportedEncodingException, GeneralSecurityException {
+		return encrypt(new Gson().toJson(securityDescriptor));
+	}
+	
+	public boolean isUseLinkButton() {
+		return securityDescriptor.isUseLinkButton();
+	}
+
+	public String setPassword(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+			error = aUser.validate();
+			if(error == null) {
+				if(securityDescriptor.getUsers() != null) {
+					User theUser = securityDescriptor.getUsers().get(aUser.getUsername());
+					if(theUser != null) {
+						theUser.setPassword(aUser.getPassword());
+						theUser.setPassword2(null);
+						settingsChanged = true;
+					}
+					else
+						error = "User not found";
+				}
+				else
+					error = "User not found";
+			}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public String addUser(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+			error = aUser.validate();
+			if(error == null) {
+				if(securityDescriptor.getUsers() == null)
+					securityDescriptor.setUsers(new HashMap<String, User>());
+				if(securityDescriptor.getUsers().get(aUser.getUsername()) == null) {
+					securityDescriptor.getUsers().put(aUser.getUsername(), aUser);
+					settingsChanged = true;
+				}
+				else
+					error = "Invalid request";
+			}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public String delUser(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+				if(securityDescriptor.getUsers() != null) {
+				if(securityDescriptor.getUsers().get(aUser.getUsername()) != null) {
+					securityDescriptor.getUsers().remove(aUser.getUsername());
+					settingsChanged = true;
+				}
+				else
+					error = "User not found";
+				}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public void setExecGarden(String theGarden) {
+		securityDescriptor.setExecGarden(theGarden);
+		settingsChanged = true;
+	}
+
+	public String getExecGarden() {
+		return securityDescriptor.getExecGarden();
+	}
+	public void setUseLinkButton(boolean useThis) {
+		securityDescriptor.setUseLinkButton(useThis);
+		settingsChanged = true;
+	}
+
+	public boolean isSecureHueApi() {
+		return securityDescriptor.isSecureHueApi();
+	}
+	
+	public void setSecureHueApi(boolean theState) {
+		securityDescriptor.setSecureHueApi(theState);
+	}
+	public SecurityInfo getSecurityInfo() {
+		SecurityInfo theInfo = new SecurityInfo();
+		theInfo.setExecGarden(getExecGarden());
+		theInfo.setUseLinkButton(isUseLinkButton());
+		theInfo.setSecureHueApi(isSecureHueApi());
+		theInfo.setSecure(isSecure());
+		return theInfo;
+	}
+	public LoginResult validatePassword(User targetUser) throws IOException {
+		LoginResult result = new LoginResult();
+		if(targetUser != null && targetUser.getUsername() != null) {
+			if(securityDescriptor.getUsers() != null && securityDescriptor.getUsers().get(targetUser.getUsername()) != null) {
+				User theUser = securityDescriptor.getUsers().get(targetUser.getUsername());
+				if(theUser.getPassword() != null) {
+					theUser.setPassword2(targetUser.getPassword());
+					if(theUser.validatePassword()) {
+						theUser.setPassword2(null);
+						result.setUser(targetUser);
+					}
+					else
+						result.setError("user or password not correct");
+				} else {
+					result.setError("input password is not set....");
+				}
+			}
+			else
+				result.setError("user or password not correct");
+		}
+		else
+			result.setError("input user not given");
+		return result;
+	}
+	
+	public boolean isSecure() {
+		return securityDescriptor.isSecure();
+	}
+
+	public boolean isSettingsChanged() {
+		return settingsChanged;
+	}
+
+	public void setSettingsChanged(boolean settingsChanged) {
+		this.settingsChanged = settingsChanged;
+	}
+
+	private String encrypt(String property) throws GeneralSecurityException, UnsupportedEncodingException {
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
+        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(habridgeKey));
+        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
+        pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
+        return base64Encode(pbeCipher.doFinal(property.getBytes("UTF-8")));
+    }
+
+    private static String base64Encode(byte[] bytes) {
+        return Base64.getEncoder().encodeToString(bytes);
+    }
+
+    private String decrypt(String property) throws GeneralSecurityException, IOException {
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
+        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(habridgeKey));
+        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
+        pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
+        return new String(pbeCipher.doFinal(base64Decode(property)), "UTF-8");
+    }
+
+    private static byte[] base64Decode(String property) throws IOException {
+        return Base64.getDecoder().decode(property);
+    }
+
+    public void addAuthenticatedUser(Request request, User u) {
+		request.session().attribute(USER_SESSION_ID, u);
+		
+	}
+
+	public void removeAuthenticatedUser(Request request) {
+		request.session().removeAttribute(USER_SESSION_ID);
+		
+	}
+
+	public User getAuthenticatedUser(Request request) {
+		User theUser = request.session().attribute(USER_SESSION_ID);
+		if(theUser == null) {
+			String authHeader = request.headers("Authorization");
+			if(authHeader != null) {
+			    byte[] authData;
+				try {
+					authData = base64Decode(authHeader.substring(6));
+				} catch (IOException e1) {
+					// TODO Auto-generated catch block
+					return theUser;
+				}
+			    String[] credentials = new String(authData).split(":");
+			    String username = credentials[0];
+			    String password = credentials[1];
+			    theUser = new User();
+			    theUser.setUsername(username);
+			    theUser.setPassword(password);
+			    LoginResult theResult = null;
+				try {
+					theResult = validatePassword(theUser);
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					return null;
+				}
+				if(theResult != null && theResult.getError() == null) {
+					addAuthenticatedUser(request, theUser);
+				}
+			}
+		}
+		return theUser;
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSecurityDescriptor.java

@@ -0,0 +1,62 @@
+package com.bwssystems.HABridge;
+
+import java.util.Map;
+
+public class BridgeSecurityDescriptor {
+	private Map<String, User> users;
+	private boolean useLinkButton;
+	private String execGarden;
+	private boolean secureHueApi;
+
+	public BridgeSecurityDescriptor() {
+		super();
+		this.setUseLinkButton(false);
+	}
+
+	public Map<String, User> getUsers() {
+		return users;
+	}
+
+	public void setUsers(Map<String, User> users) {
+		this.users = users;
+	}
+
+	public boolean isUseLinkButton() {
+		return useLinkButton;
+	}
+
+	public void setUseLinkButton(boolean useLinkButton) {
+		this.useLinkButton = useLinkButton;
+	}
+
+	public String getExecGarden() {
+		return execGarden;
+	}
+
+	public void setExecGarden(String execGarden) {
+		this.execGarden = execGarden;
+	}
+
+	public boolean isSecureHueApi() {
+		return secureHueApi;
+	}
+
+	public void setSecureHueApi(boolean secureHueApi) {
+		this.secureHueApi = secureHueApi;
+	}
+
+	public boolean isSecure() {
+		boolean secureFlag = false;
+		if(users != null && !users.isEmpty()) {
+			for (Map.Entry<String, User> entry : users.entrySet())
+			{
+				if(entry.getValue().getPassword() != null && !entry.getValue().getPassword().isEmpty()) {
+					secureFlag = true;
+					break;
+				}
+			}
+		}
+		return secureFlag;
+		
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSettings.java

@@ -0,0 +1,345 @@
+package com.bwssystems.HABridge;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.PosixFilePermission;
+import java.security.GeneralSecurityException;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.http.conn.util.InetAddressUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.util.BackupHandler;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.google.gson.Gson;
+
+public class BridgeSettings extends BackupHandler {
+	private static final Logger log = LoggerFactory.getLogger(BridgeSettings.class);
+	private BridgeSettingsDescriptor theBridgeSettings;
+	private BridgeControlDescriptor bridgeControl;
+	private BridgeSecurity bridgeSecurity;
+	
+	public BridgeSettings() {
+		super();
+		bridgeControl = new BridgeControlDescriptor();
+		theBridgeSettings = new BridgeSettingsDescriptor();
+		bridgeSecurity = null;
+		String theKey = System.getProperty("security.key");
+		if(theKey == null)
+			theKey = "IWantMyPasswordsToBeAbleToBeDecodedPleaseSeeTheReadme";
+		bridgeSecurity = new BridgeSecurity(theKey.toCharArray());
+		String ipV6Stack = System.getProperty("ipV6Stack");
+        if(ipV6Stack == null || !ipV6Stack.equalsIgnoreCase("true")) {
+        	System.setProperty("java.net.preferIPv4Stack" , "true");
+        }
+
+	}
+	public BridgeControlDescriptor getBridgeControl() {
+		return bridgeControl;
+	}
+	public BridgeSettingsDescriptor getBridgeSettingsDescriptor() {
+		return theBridgeSettings;
+	}
+	public BridgeSecurity getBridgeSecurity() {
+		return bridgeSecurity;
+	}
+	public void buildSettings() {
+        String addressString = null;
+        String theVeraAddress = null;
+        String theSomfyAddress = null;
+        String theHarmonyAddress = null;
+        String configFileProperty = System.getProperty("config.file");
+        if(configFileProperty == null) {
+        	Path filePath = Paths.get(Configuration.CONFIG_FILE);
+        	if(Files.exists(filePath) && Files.isReadable(filePath))
+        		configFileProperty = Configuration.CONFIG_FILE;
+        }
+        String serverPortOverride = System.getProperty("server.port");
+        String serverIpOverride = System.getProperty("server.ip");
+        if(configFileProperty != null)
+        {
+        	log.info("reading from config file: " + configFileProperty);
+        	theBridgeSettings.setConfigfile(configFileProperty);
+        	_loadConfig();
+        }
+        else
+        {
+        	log.info("reading from system properties");
+        	theBridgeSettings.setNumberoflogmessages(Configuration.NUMBER_OF_LOG_MESSAGES);
+        	theBridgeSettings.setFarenheit(true);
+        	theBridgeSettings.setConfigfile(Configuration.CONFIG_FILE);
+        	theBridgeSettings.setServerPort(System.getProperty("server.port", Configuration.DEFAULT_WEB_PORT));
+        	theBridgeSettings.setUpnpConfigAddress(System.getProperty("upnp.config.address"));
+        	theBridgeSettings.setUpnpDeviceDb(System.getProperty("upnp.device.db"));
+        	theBridgeSettings.setUpnpResponsePort(System.getProperty("upnp.response.port", Configuration.UPNP_RESPONSE_PORT));
+	        
+	        theVeraAddress = System.getProperty("vera.address");
+        	IpList theVeraList = null;	
+	        if(theVeraAddress != null) {
+		        try {
+		        	theVeraList = new Gson().fromJson(theVeraAddress, IpList.class);
+		        } catch (Exception e) {
+		        	try {
+		        		theVeraList = new Gson().fromJson("{devices:[{name:default,ip:" + theVeraAddress + "}]}", IpList.class);
+		        	} catch (Exception et) {
+		    	        log.error("Cannot parse vera.address, not set with message: " + e.getMessage(), e);
+		    	        theVeraList = null;
+		        	}
+		        }
+	        }
+	        theBridgeSettings.setVeraAddress(theVeraList);
+
+	        theHarmonyAddress = System.getProperty("harmony.address");
+	        IpList theHarmonyList = null;	
+	        if(theHarmonyAddress != null) {
+		        try {
+		        	theHarmonyList = new Gson().fromJson(theHarmonyAddress, IpList.class);
+		        } catch (Exception e) {
+		        	try {
+		        		theHarmonyList = new Gson().fromJson("{devices:[{name:default,ip:" + theHarmonyAddress + "}]}", IpList.class);
+		        	} catch (Exception et) {
+		    	        log.error("Cannot parse harmony.address, not set with message: " + e.getMessage(), e);
+		    	        theHarmonyList = null;
+		        	}
+		        }
+	        }
+	        theBridgeSettings.setHarmonyAddress(theHarmonyList);
+
+			theSomfyAddress = System.getProperty("somfy.address");
+			IpList theSomfyList = null;
+			if(theSomfyAddress != null) {
+				try {
+					theSomfyList = new Gson().fromJson(theSomfyAddress, IpList.class);
+				} catch (Exception e) {
+					try {
+						theSomfyList = new Gson().fromJson("{devices:[{name:default,ip:" + theSomfyAddress + "}]}", IpList.class);
+					} catch (Exception et) {
+						log.error("Cannot parse somfy.address, not set with message: " + e.getMessage(), e);
+						theSomfyList = null;
+					}
+				}
+			}
+			theBridgeSettings.setSomfyAddress(theSomfyList);
+
+	        theBridgeSettings.setUpnpStrict(Boolean.parseBoolean(System.getProperty("upnp.strict", "true")));
+	        theBridgeSettings.setTraceupnp(Boolean.parseBoolean(System.getProperty("trace.upnp", "false")));
+	        theBridgeSettings.setButtonsleep(Integer.parseInt(System.getProperty("button.sleep", Configuration.DEFAULT_BUTTON_SLEEP)));
+	        theBridgeSettings.setNestuser(System.getProperty("nest.user"));
+	        theBridgeSettings.setNestpwd(System.getProperty("nest.pwd"));
+        }
+
+        if(theBridgeSettings.getUpnpConfigAddress() == null || theBridgeSettings.getUpnpConfigAddress().equals("")) {
+        	addressString = checkIpAddress(null, true);
+        	if(addressString != null) {
+        		theBridgeSettings.setUpnpConfigAddress(addressString);
+        		log.info("Adding " + addressString + " as our default upnp config address.");
+        	}
+        	else
+		        log.error("Cannot get ip address of this host.");
+        }
+        else {
+        	addressString = checkIpAddress(theBridgeSettings.getUpnpConfigAddress(), false);
+        	if(addressString == null)
+        		log.warn("The upnp config address, " + theBridgeSettings.getUpnpConfigAddress() + ", does not match any known IP's on this host.");
+        }
+        
+        if(theBridgeSettings.getUpnpResponsePort() == null)
+        	theBridgeSettings.setUpnpResponsePort(Configuration.UPNP_RESPONSE_PORT);
+        
+        if(theBridgeSettings.getServerPort() == null)
+        	theBridgeSettings.setServerPort(Configuration.DEFAULT_WEB_PORT);
+        
+        if(theBridgeSettings.getUpnpDeviceDb() == null)
+        	theBridgeSettings.setUpnpDeviceDb(Configuration.DEVICE_DB_DIRECTORY);
+        
+        if(theBridgeSettings.getNumberoflogmessages() == null || theBridgeSettings.getNumberoflogmessages() <= 0)
+        	theBridgeSettings.setNumberoflogmessages(new Integer(Configuration.NUMBER_OF_LOG_MESSAGES));
+
+        if(theBridgeSettings.getButtonsleep() == null || theBridgeSettings.getButtonsleep() < 0)
+        	theBridgeSettings.setButtonsleep(Integer.parseInt(Configuration.DEFAULT_BUTTON_SLEEP));
+
+        theBridgeSettings.setVeraconfigured(theBridgeSettings.isValidVera());
+        theBridgeSettings.setHarmonyconfigured(theBridgeSettings.isValidHarmony());
+        theBridgeSettings.setNestConfigured(theBridgeSettings.isValidNest());
+        theBridgeSettings.setHueconfigured(theBridgeSettings.isValidHue());
+        theBridgeSettings.setHalconfigured(theBridgeSettings.isValidHal());
+        theBridgeSettings.setMqttconfigured(theBridgeSettings.isValidMQTT());
+        theBridgeSettings.setHassconfigured(theBridgeSettings.isValidHass());
+        theBridgeSettings.setDomoticzconfigured(theBridgeSettings.isValidDomoticz());
+		theBridgeSettings.setSomfyconfigured(theBridgeSettings.isValidSomfy());
+        // Lifx is either configured or not, so it does not need an update.
+       if(serverPortOverride != null)
+        	theBridgeSettings.setServerPort(serverPortOverride);
+        if(serverIpOverride != null)
+        	theBridgeSettings.setWebaddress(serverIpOverride);
+		setupParams(Paths.get(theBridgeSettings.getConfigfile()), ".cfgbk", "habridge.config-");
+		
+		setupInternalTestUser();
+		
+		bridgeSecurity.setSecurityData(theBridgeSettings.getSecurityData());
+	}
+
+	public void loadConfig() {
+		if(theBridgeSettings.getConfigfile() != null)
+			_loadConfig();
+	}
+	private void _loadConfig() {
+		Path configPath = Paths.get(theBridgeSettings.getConfigfile());
+		_loadConfig(configPath);
+    }
+
+	private void _loadConfig(Path aPath) {
+		String jsonContent = configReader(aPath);
+		if(jsonContent == null)
+			return;
+		try {
+			theBridgeSettings = new Gson().fromJson(jsonContent, BridgeSettingsDescriptor.class);
+		} catch (Exception e) {
+			log.warn("Issue loading values from file: " + aPath.toUri().toString() + ", Gson convert failed.");
+			theBridgeSettings = new BridgeSettingsDescriptor();
+			theBridgeSettings.setConfigfile(aPath.toString());
+		}
+    }
+
+	public void save(BridgeSettingsDescriptor newBridgeSettings) {
+        log.debug("Save HA Bridge settings.");
+		Path configPath = Paths.get(theBridgeSettings.getConfigfile());
+    	JsonTransformer aRenderer = new JsonTransformer();
+    	if(bridgeSecurity.isSettingsChanged()) {
+    		try {
+				newBridgeSettings.setSecurityData(bridgeSecurity.getSecurityDescriptorData());
+			} catch (UnsupportedEncodingException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (GeneralSecurityException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+    		bridgeSecurity.setSettingsChanged(false);
+    	}
+    	String  jsonValue = aRenderer.render(newBridgeSettings);
+    	configWriter(jsonValue, configPath);
+    	_loadConfig(configPath);
+    }
+    
+
+	public void updateConfigFile() {
+        log.debug("Save HA Bridge settings.");
+		Path configPath = Paths.get(theBridgeSettings.getConfigfile());
+    	JsonTransformer aRenderer = new JsonTransformer();
+    	String  jsonValue = aRenderer.render(theBridgeSettings);
+    	configWriter(jsonValue, configPath);
+    	_loadConfig(configPath);
+    }
+    
+
+	private synchronized void configWriter(String content, Path filePath) {
+		if(Files.exists(filePath) && !Files.isWritable(filePath)){
+			log.error("Error file is not writable: " + filePath);
+			return;
+		}
+		
+		if(Files.notExists(filePath.getParent())) {
+			try {
+				Files.createDirectories(filePath.getParent());
+			} catch (IOException e) {
+				log.error("Error creating the directory: " + filePath + " message: " + e.getMessage(), e);
+			}
+		}
+
+		try {
+			Path target = null;
+			if(Files.exists(filePath)) {
+				target = FileSystems.getDefault().getPath(filePath.getParent().toString(), "habridge.config.old");
+				Files.move(filePath, target);
+			}
+			Files.write(filePath, content.getBytes(), StandardOpenOption.CREATE);
+
+			// set attributes to be for user only
+	        // using PosixFilePermission to set file permissions
+	        Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
+	        // add owners permission 
+	        perms.add(PosixFilePermission.OWNER_READ);
+	        perms.add(PosixFilePermission.OWNER_WRITE);
+	        
+	        try {
+	        	String osName = System.getProperty("os.name");
+	        	if(osName.toLowerCase().indexOf("win") < 0)
+	        		Files.setPosixFilePermissions(filePath, perms);
+	        } catch(UnsupportedOperationException e) {
+	        	log.info("Cannot set permissions for config file on this system as it is not supported. Continuing");
+	        }
+			if(target != null)
+				Files.delete(target);
+		} catch (IOException e) {
+			log.error("Error writing the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+	}
+	
+	private String configReader(Path filePath) {
+		String content = null;
+		if(Files.notExists(filePath) || !Files.isReadable(filePath)){
+			log.warn("Error reading the file: " + filePath + " - Does not exist or is not readable. continuing...");
+			return null;
+		}
+
+		try {
+			content = new String(Files.readAllBytes(filePath));
+		} catch (IOException e) {
+			log.error("Error reading the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+		
+		return content;
+	}
+	
+	private String checkIpAddress(String ipAddress, boolean checkForLocalhost) {
+		Enumeration<NetworkInterface> ifs =	null;
+		try {
+			ifs =	NetworkInterface.getNetworkInterfaces();
+		} catch(SocketException e) {
+	        log.error("checkIpAddress cannot get ip address of this host, Exiting with message: " + e.getMessage(), e);
+	        return null;			
+		}
+		String addressString = null;
+        InetAddress address = null;
+		while (ifs.hasMoreElements() && addressString == null) {
+			NetworkInterface xface = ifs.nextElement();
+			Enumeration<InetAddress> addrs = xface.getInetAddresses();
+			String name = xface.getName();
+			int IPsPerNic = 0;
+
+			while (addrs.hasMoreElements() && IPsPerNic == 0) {
+				address = addrs.nextElement();
+				if (InetAddressUtils.isIPv4Address(address.getHostAddress())) {
+					log.debug(name + " ... has IPV4 addr " + address);
+					if(checkForLocalhost && (!name.equalsIgnoreCase(Configuration.LOOP_BACK_INTERFACE) || !address.getHostAddress().equalsIgnoreCase(Configuration.LOOP_BACK_ADDRESS))) {
+						IPsPerNic++;
+						addressString = address.getHostAddress();
+						log.debug("checkIpAddress found " + addressString + " from interface " + name);
+					}
+					else if(ipAddress != null && ipAddress.equalsIgnoreCase(address.getHostAddress())){
+						addressString = ipAddress;
+						IPsPerNic++;
+					}
+				}
+			}
+		}
+		return addressString;
+	}
+	private void setupInternalTestUser() {
+		theBridgeSettings.setupInternalTestUser();
+		if(theBridgeSettings.isSettingsChanged())
+			this.updateConfigFile();
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSettingsDescriptor.java

@@ -0,0 +1,456 @@
+package com.bwssystems.HABridge;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.UUID;
+
+import com.bwssystems.HABridge.api.hue.HueConstants;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.api.hue.WhitelistEntry;
+
+public class BridgeSettingsDescriptor {
+	private static final String DEFAULT_INTERNAL_USER = "thehabridgeuser";
+	private static final String DEFAULT_USER_DESCRIPTION = "default_test_user";
+	private String upnpconfigaddress;
+	private Integer serverport;
+	private Integer upnpresponseport;
+	private String upnpdevicedb;
+	private IpList veraaddress;
+	private IpList harmonyaddress;
+	private Integer buttonsleep;
+	private boolean upnpstrict;
+	private boolean traceupnp;
+	private String nestuser;
+	private String nestpwd;
+	private boolean veraconfigured;
+	private boolean harmonyconfigured;
+	private boolean nestconfigured;
+	private boolean farenheit;
+	private String configfile;
+	private Integer numberoflogmessages;
+	private IpList hueaddress;
+	private boolean hueconfigured;
+	private IpList haladdress;
+	private String haltoken;
+	private boolean halconfigured;
+	private Map<String, WhitelistEntry> whitelist;
+	private boolean settingsChanged;
+	private String myechourl;
+	private String webaddress;
+	private IpList mqttaddress;
+	private boolean mqttconfigured;
+	private IpList hassaddress;
+	private boolean hassconfigured;
+	private String hubversion;
+	private IpList domoticzaddress;
+	private boolean domoticzconfigured;
+	private IpList somfyaddress;
+	private boolean somfyconfigured;
+	private boolean lifxconfigured;
+	private String securityData;
+	
+	public BridgeSettingsDescriptor() {
+		super();
+		this.upnpstrict = true;
+		this.traceupnp = false;
+		this.nestconfigured = false;
+		this.veraconfigured = false;
+		this.somfyconfigured = false;
+		this.harmonyconfigured = false;
+		this.hueconfigured = false;
+		this.halconfigured = false;
+		this.mqttconfigured = false;
+		this.hassconfigured = false;
+		this.farenheit = true;
+		this.whitelist = null;
+		this.settingsChanged = false;
+		this.myechourl = "echo.amazon.com/#cards";
+		this.webaddress = "0.0.0.0";
+		this.hubversion = HueConstants.HUB_VERSION;
+	}
+	public String getUpnpConfigAddress() {
+		return upnpconfigaddress;
+	}
+	public void setUpnpConfigAddress(String upnpConfigAddress) {
+		this.upnpconfigaddress = upnpConfigAddress;
+	}
+	public Integer  getServerPort() {
+		return serverport;
+	}
+	public void setServerPort(Integer serverPort) {
+		this.serverport = serverPort;
+	}
+	public void setServerPort(String serverPort) {
+		this.serverport = Integer.valueOf(serverPort);
+	}
+	public Integer getUpnpResponsePort() {
+		return upnpresponseport;
+	}
+	public void setUpnpResponsePort(Integer upnpResponsePort) {
+		this.upnpresponseport = upnpResponsePort;
+	}
+	public void setUpnpResponsePort(String upnpResponsePort) {
+		this.upnpresponseport = Integer.valueOf(upnpResponsePort);
+	}
+	public String getUpnpDeviceDb() {
+		return upnpdevicedb;
+	}
+	public void setUpnpDeviceDb(String upnpDeviceDb) {
+		this.upnpdevicedb = upnpDeviceDb;
+	}
+	public IpList getVeraAddress() {
+		return veraaddress;
+	}
+	public IpList getSomfyAddress() {
+		return somfyaddress;
+	}
+	public void setVeraAddress(IpList veraAddress) {
+		this.veraaddress = veraAddress;
+	}
+	public void setSomfyAddress(IpList somfyAddress) {
+		this.somfyaddress = somfyAddress;
+	}
+	public IpList getHarmonyAddress() {
+		return harmonyaddress;
+	}
+	public void setHarmonyAddress(IpList harmonyaddress) {
+		this.harmonyaddress = harmonyaddress;
+	}
+	public boolean isUpnpStrict() {
+		return upnpstrict;
+	}
+	public void setUpnpStrict(boolean upnpStrict) {
+		this.upnpstrict = upnpStrict;
+	}
+	public boolean isTraceupnp() {
+		return traceupnp;
+	}
+	public void setTraceupnp(boolean traceupnp) {
+		this.traceupnp = traceupnp;
+	}
+	public String getNestuser() {
+		return nestuser;
+	}
+	public void setNestuser(String nestuser) {
+		this.nestuser = nestuser;
+	}
+	public String getNestpwd() {
+		return nestpwd;
+	}
+	public void setNestpwd(String nestpwd) {
+		this.nestpwd = nestpwd;
+	}
+	public boolean isVeraconfigured() {
+		return veraconfigured;
+	}
+	public boolean isSomfyconfigured() {
+		return somfyconfigured;
+	}
+	public void setVeraconfigured(boolean veraconfigured) {
+		this.veraconfigured = veraconfigured;
+	}
+	public void setSomfyconfigured(boolean somfyconfigured) {
+		this.somfyconfigured = somfyconfigured;
+	}
+	public boolean isHarmonyconfigured() {
+		return harmonyconfigured;
+	}
+	public void setHarmonyconfigured(boolean harmonyconfigured) {
+		this.harmonyconfigured = harmonyconfigured;
+	}
+	public boolean isNestConfigured() {
+		return nestconfigured;
+	}
+	public void setNestConfigured(boolean isNestConfigured) {
+		this.nestconfigured = isNestConfigured;
+	}
+	public Integer getButtonsleep() {
+		return buttonsleep;
+	}
+	public void setButtonsleep(Integer buttonsleep) {
+		this.buttonsleep = buttonsleep;
+	}
+	public String getConfigfile() {
+		return configfile;
+	}
+	public void setConfigfile(String configfile) {
+		this.configfile = configfile;
+	}
+	public Integer getNumberoflogmessages() {
+		return numberoflogmessages;
+	}
+	public void setNumberoflogmessages(Integer numberoflogmessages) {
+		this.numberoflogmessages = numberoflogmessages;
+	}
+	public boolean isFarenheit() {
+		return farenheit;
+	}
+	public void setFarenheit(boolean farenheit) {
+		this.farenheit = farenheit;
+	}
+	public IpList getHueaddress() {
+		return hueaddress;
+	}
+	public void setHueaddress(IpList hueaddress) {
+		this.hueaddress = hueaddress;
+	}
+	public boolean isHueconfigured() {
+		return hueconfigured;
+	}
+	public void setHueconfigured(boolean hueconfigured) {
+		this.hueconfigured = hueconfigured;
+	}
+	public IpList getHaladdress() {
+		return haladdress;
+	}
+	public void setHaladdress(IpList haladdress) {
+		this.haladdress = haladdress;
+	}
+	public String getHaltoken() {
+		return haltoken;
+	}
+	public void setHaltoken(String haltoken) {
+		this.haltoken = haltoken;
+	}
+	public boolean isHalconfigured() {
+		return halconfigured;
+	}
+	public void setHalconfigured(boolean halconfigured) {
+		this.halconfigured = halconfigured;
+	}
+	public Map<String, WhitelistEntry> getWhitelist() {
+		return whitelist;
+	}
+	public void setWhitelist(Map<String, WhitelistEntry> whitelist) {
+		this.whitelist = whitelist;
+	}
+	public boolean isSettingsChanged() {
+		return settingsChanged;
+	}
+	public void setSettingsChanged(boolean settingsChanged) {
+		this.settingsChanged = settingsChanged;
+	}
+	public String getMyechourl() {
+		return myechourl;
+	}
+	public void setMyechourl(String myechourl) {
+		this.myechourl = myechourl;
+	}
+	public String getWebaddress() {
+		return webaddress;
+	}
+	public void setWebaddress(String webaddress) {
+		this.webaddress = webaddress;
+	}
+	public IpList getMqttaddress() {
+		return mqttaddress;
+	}
+	public void setMqttaddress(IpList mqttaddress) {
+		this.mqttaddress = mqttaddress;
+	}
+	public boolean isMqttconfigured() {
+		return mqttconfigured;
+	}
+	public void setMqttconfigured(boolean mqttconfigured) {
+		this.mqttconfigured = mqttconfigured;
+	}
+	public IpList getHassaddress() {
+		return hassaddress;
+	}
+	public void setHassaddress(IpList hassaddress) {
+		this.hassaddress = hassaddress;
+	}
+	public boolean isHassconfigured() {
+		return hassconfigured;
+	}
+	public void setHassconfigured(boolean hassconfigured) {
+		this.hassconfigured = hassconfigured;
+	}
+	public String getHubversion() {
+		return hubversion;
+	}
+	public void setHubversion(String hubversion) {
+		this.hubversion = hubversion;
+	}
+	public IpList getDomoticzaddress() {
+		return domoticzaddress;
+	}
+	public void setDomoticzaddress(IpList domoticzaddress) {
+		this.domoticzaddress = domoticzaddress;
+	}
+	public boolean isDomoticzconfigured() {
+		return domoticzconfigured;
+	}
+	public void setDomoticzconfigured(boolean domoticzconfigured) {
+		this.domoticzconfigured = domoticzconfigured;
+	}
+	public boolean isLifxconfigured() {
+		return lifxconfigured;
+	}
+	public void setLifxconfigured(boolean lifxconfigured) {
+		this.lifxconfigured = lifxconfigured;
+	}
+	public String getSecurityData() {
+		return securityData;
+	}
+	public void setSecurityData(String securityData) {
+		this.securityData = securityData;
+	}
+	public Boolean isValidVera() {
+		if(this.getVeraAddress() == null || this.getVeraAddress().getDevices().size() <= 0)
+			return false;
+		List<NamedIP> devicesList = this.getVeraAddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidHarmony() {
+		if(this.getHarmonyAddress() == null || this.getHarmonyAddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getHarmonyAddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidNest() {
+		if(this.getNestpwd() == null || this.getNestpwd().equals(""))
+			return false;
+		if(this.getNestuser() == null || this.getNestuser().equals(""))
+			return false;
+		return true;
+	}
+	public Boolean isValidHue() {
+		if(this.getHueaddress() == null || this.getHueaddress().getDevices().size() <= 0)
+			return false;
+		List<NamedIP> devicesList = this.getHueaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidHal() {
+		if(this.getHaladdress() == null || this.getHaladdress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getHaladdress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		if(this.getHaltoken() == null || this.getHaltoken().equals(""))
+			return false;
+		return true;
+	}
+	public Boolean isValidMQTT() {
+		if(this.getMqttaddress() == null || this.getMqttaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getMqttaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidHass() {
+		if(this.getHassaddress() == null || this.getHassaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getHassaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidDomoticz() {
+		if(this.getDomoticzaddress() == null || this.getDomoticzaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getDomoticzaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidSomfy() {
+		if(this.getSomfyAddress() == null || this.getSomfyAddress().getDevices().size() <= 0)
+			return false;
+		List<NamedIP> devicesList = this.getSomfyAddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidLifx() {
+		return this.isLifxconfigured();
+	}
+
+	public HueError[] validateWhitelistUser(String aUser, String userDescription, boolean strict) {
+		String validUser = null;
+		boolean found = false;
+		if (aUser != null && !aUser.equalsIgnoreCase("undefined") && !aUser.equalsIgnoreCase("null")
+				&& !aUser.equalsIgnoreCase("")) {
+			if (whitelist != null) {
+				Set<String> theUserIds = whitelist.keySet();
+				Iterator<String> userIterator = theUserIds.iterator();
+				while (userIterator.hasNext()) {
+					validUser = userIterator.next();
+					if (validUser.equals(aUser))
+						found = true;
+				}
+			}
+		}
+
+		if(!found && !strict) {
+			newWhitelistUser(aUser, userDescription);
+			
+			found = true;
+		}
+		
+		if (!found) {
+			return HueErrorResponse.createResponse("1", "/api/" + aUser, "unauthorized user", null, null, null).getTheErrors();
+		}
+		
+		return null;
+	}
+	
+	public void newWhitelistUser(String aUser, String userDescription) {
+		if (whitelist == null) {
+			whitelist  = new HashMap<>();
+		}
+		if(userDescription == null)
+			userDescription = "auto insert user";
+		
+		whitelist.put(aUser, WhitelistEntry.createEntry(userDescription));
+		setSettingsChanged(true);
+	}
+
+	public String createWhitelistUser(String userDescription) {
+		String aUser = getNewUserID();
+		newWhitelistUser(aUser, userDescription);
+		return aUser;
+	}
+
+	private String getNewUserID() {
+		UUID uid = UUID.randomUUID();
+		StringTokenizer st = new StringTokenizer(uid.toString(), "-");
+		String newUser = "";
+		while (st.hasMoreTokens()) {
+			newUser = newUser + st.nextToken();
+		}
+
+		return newUser;
+	}
+
+	public String getInternalTestUser() {
+		return DEFAULT_INTERNAL_USER;
+	}
+
+	public void setupInternalTestUser() {
+		boolean found = false;
+		if(whitelist != null) {
+			for (String key : whitelist.keySet()) {
+				if(key.equals(DEFAULT_INTERNAL_USER)) {
+					found = true;
+					break;
+				}
+			}
+		}
+		if(!found) {
+			newWhitelistUser(DEFAULT_INTERNAL_USER, DEFAULT_USER_DESCRIPTION);
+		}
+	}
+}

src/main/java/com/bwssystems/HABridge/Configuration.java

@@ -0,0 +1,16 @@
+package com.bwssystems.HABridge;
+
+public class Configuration {
+	public final static String DEVICE_DB_DIRECTORY = "data/device.db"; 
+	public final static String UPNP_RESPONSE_PORT = "50000";
+	public final static String DEFAULT_ADDRESS = "1.1.1.1";
+	public final static String LOOP_BACK_ADDRESS = "127.0.0.1";
+	public final static String LOOP_BACK_INTERFACE = "lo";
+	public final static String DEFAULT_WEB_PORT = "80";
+	public final static String DEFAULT_BUTTON_SLEEP = "100";
+	public static final int UPNP_DISCOVERY_PORT = 1900;
+	public static final String UPNP_MULTICAST_ADDRESS = "239.255.255.250";
+	public static final String CONFIG_FILE = "data/habridge.config";
+	public static final int NUMBER_OF_LOG_MESSAGES = 512;
+	public static final long UPNP_NOTIFY_TIMEOUT = 20000;
+}

src/main/java/com/bwssystems/HABridge/DeviceMapTypes.java

@@ -0,0 +1,87 @@
+package com.bwssystems.HABridge;
+
+import java.util.ArrayList;
+
+public class DeviceMapTypes {
+
+	public final static String[] CUSTOM_DEVICE = { "custom", "Custom"};
+	public final static String[] VERA_DEVICE = { "veraDevice", "Vera Device"};
+	public final static String[] VERA_SCENE = { "veraScene", "Vera Scene"};
+	public final static String[] HARMONY_ACTIVITY = { "harmonyActivity", "Harmony Activity"};
+	public final static String[] HARMONY_BUTTON = { "harmonyButton", "Harmony Button"};
+	public final static String[] NEST_HOMEAWAY = { "nestHomeAway", "Nest Home Status"};
+	public final static String[] NEST_THERMO_SET = { "nestThermoSet", "Nest Thermostat"};
+	public final static String[] HUE_DEVICE = { "hueDevice", "Hue Device"};
+	public final static String[] HAL_DEVICE = { "halDevice", "HAL Device"};
+	public final static String[] HAL_BUTTON = { "halButton", "HAL Button"};
+	public final static String[] HAL_HOME = { "halHome", "HAL Home Status"};
+	public final static String[] HAL_THERMO_SET = { "halThermoSet", "HAL Thermostat"};
+	public final static String[] MQTT_MESSAGE = { "mqttMessage", "MQTT Message"};
+	public final static String[] EXEC_DEVICE_COMPAT = { "exec", "Execute Script/Program"};
+	public final static String[] CMD_DEVICE = { "cmdDevice", "Execute Command/Script/Program"};
+	public final static String[] HASS_DEVICE = { "hassDevice", "HomeAssistant Device"};
+	public final static String[] TCP_DEVICE = { "tcpDevice", "TCP Device"};
+	public final static String[] TCP_DEVICE_COMPAT = { "TCP", "TCP Device"};
+	public final static String[] UDP_DEVICE = { "udpDevice", "UDP Device"};
+	public final static String[] UDP_DEVICE_COMPAT = { "UDP", "UDP Device"};
+	public final static String[] HTTP_DEVICE = { "httpDevice", "HTTP Device"};
+	public final static String[] DOMOTICZ_DEVICE = { "domoticzDevice", "Domoticz Device"};
+	public final static String[] SOMFY_DEVICE = { "somfyDevice", "Somfy Device"};
+	public final static String[] LIFX_DEVICE = { "lifxDevice", "LIFX Device"};
+
+	public final static int typeIndex = 0;
+	public final static int displayIndex = 1;
+
+	ArrayList<String[]> deviceMapTypes;
+	
+	public DeviceMapTypes() {
+		super();
+		deviceMapTypes = new ArrayList<String[]>();
+		deviceMapTypes.add(CMD_DEVICE);
+		deviceMapTypes.add(DOMOTICZ_DEVICE);
+		deviceMapTypes.add(HAL_DEVICE);
+		deviceMapTypes.add(HAL_HOME);
+		deviceMapTypes.add(HAL_THERMO_SET);
+		deviceMapTypes.add(HAL_BUTTON);
+		deviceMapTypes.add(HARMONY_ACTIVITY);
+		deviceMapTypes.add(HARMONY_BUTTON);
+		deviceMapTypes.add(HASS_DEVICE);
+		deviceMapTypes.add(HTTP_DEVICE);
+		deviceMapTypes.add(HUE_DEVICE);
+		deviceMapTypes.add(LIFX_DEVICE);
+		deviceMapTypes.add(MQTT_MESSAGE);
+		deviceMapTypes.add(NEST_HOMEAWAY);
+		deviceMapTypes.add(NEST_THERMO_SET);
+		deviceMapTypes.add(SOMFY_DEVICE);
+		deviceMapTypes.add(TCP_DEVICE);
+		deviceMapTypes.add(UDP_DEVICE);
+		deviceMapTypes.add(VERA_DEVICE);
+		deviceMapTypes.add(VERA_SCENE);
+		deviceMapTypes.add(SOMFY_DEVICE);
+	}
+	public static int getTypeIndex() {
+		return typeIndex;
+	}
+	public static int getDisplayIndex() {
+		return displayIndex;
+	}
+	public ArrayList<String[]> getDeviceMapTypes() {
+		return deviceMapTypes;
+	}
+	
+	public Boolean validateType(String type) {
+		if(type == null || type.trim().isEmpty())
+			return false;
+		for(String[] mapType : deviceMapTypes) {
+			if(type.trim().contentEquals(mapType[typeIndex]))
+				return true;
+		}
+		if(type.trim().contentEquals(EXEC_DEVICE_COMPAT[typeIndex]))
+			return true;
+		if(type.trim().contentEquals(TCP_DEVICE_COMPAT[typeIndex]))
+			return true;
+		if(type.trim().contentEquals(UDP_DEVICE_COMPAT[typeIndex]))
+			return true;
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/HABridge.java

@@ -0,0 +1,108 @@
+package com.bwssystems.HABridge;
+
+import static spark.Spark.*;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.devicemanagmeent.*;
+import com.bwssystems.HABridge.hue.HueMulator;
+import com.bwssystems.HABridge.upnp.UpnpListener;
+import com.bwssystems.HABridge.upnp.UpnpSettingsResource;
+import com.bwssystems.HABridge.util.UDPDatagramSender;
+
+public class HABridge {
+	
+	/*
+	 * This program is based on the work of armzilla from this github repository:
+	 * https://github.com/armzilla/amazon-echo-ha-bridge
+	 * 
+	 * This is the main entry point to start the amazon echo bridge.
+	 * 
+	 * This program is using sparkjava rest server to build all the http calls. 
+	 * Sparkjava is a microframework that uses Jetty webserver module to host 
+	 * its' calls. This is a very compact system than using the spring frameworks
+	 * that was previously used.
+	 * 
+	 * There is a custom upnp listener that is started to handle discovery.
+	 * 
+	 * 
+	 */
+    public static void main(String[] args) {
+        Logger log = LoggerFactory.getLogger(HABridge.class);
+        DeviceResource theResources;
+        HomeManager homeManager;
+        HueMulator theHueMulator;
+        UDPDatagramSender udpSender;
+        UpnpSettingsResource theSettingResponder;
+        UpnpListener theUpnpListener;
+        SystemControl theSystem;
+        BridgeSettings bridgeSettings;
+        Version theVersion;
+        
+        theVersion = new Version();
+
+        log.info("HA Bridge (v" + theVersion.getVersion() + ") starting....");
+        
+        bridgeSettings = new BridgeSettings();
+    	// sparkjava config directive to set html static file location for Jetty
+    	staticFileLocation("/public");
+        while(!bridgeSettings.getBridgeControl().isStop()) {
+        	bridgeSettings.buildSettings();
+            log.info("HA Bridge initializing....");
+	        // sparkjava config directive to set ip address for the web server to listen on
+	        ipAddress(bridgeSettings.getBridgeSettingsDescriptor().getWebaddress());
+	        // sparkjava config directive to set port for the web server to listen on
+	        port(bridgeSettings.getBridgeSettingsDescriptor().getServerPort());
+	        if(!bridgeSettings.getBridgeControl().isReinit())
+	        	init();
+	        bridgeSettings.getBridgeControl().setReinit(false);
+	        // setup system control api first
+	        theSystem = new SystemControl(bridgeSettings, theVersion);
+	        theSystem.setupServer();
+	        // setup the UDP Datagram socket to be used by the HueMulator and the upnpListener
+	        udpSender = UDPDatagramSender.createUDPDatagramSender(bridgeSettings.getBridgeSettingsDescriptor().getUpnpResponsePort());
+	        if(udpSender == null) {
+	        	bridgeSettings.getBridgeControl().setStop(true);	        	
+	        }
+	        else {
+		        //Setup the device connection homes through the manager
+		        homeManager = new HomeManager();
+		        homeManager.buildHomes(bridgeSettings, udpSender);
+		        // setup the class to handle the resource setup rest api
+		        theResources = new DeviceResource(bridgeSettings, homeManager);
+		        // setup the class to handle the upnp response rest api
+		        theSettingResponder = new UpnpSettingsResource(bridgeSettings.getBridgeSettingsDescriptor());
+		        theSettingResponder.setupServer();
+		        // setup the class to handle the hue emulator rest api
+		        theHueMulator = new HueMulator(bridgeSettings, theResources.getDeviceRepository(), homeManager);
+		        theHueMulator.setupServer();
+		        // wait for the sparkjava initialization of the rest api classes to be complete
+		        awaitInitialization();
+		
+		        // start the upnp ssdp discovery listener
+		        theUpnpListener = new UpnpListener(bridgeSettings.getBridgeSettingsDescriptor(), bridgeSettings.getBridgeControl(), udpSender);
+		        if(theUpnpListener.startListening())
+		        	log.info("HA Bridge (v" + theVersion.getVersion() + ") reinitialization requessted....");
+		        else
+		        	bridgeSettings.getBridgeControl().setStop(true);
+		        if(bridgeSettings.getBridgeSettingsDescriptor().isSettingsChanged())
+		        	bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+		        homeManager.closeHomes();
+		        udpSender.closeResponseSocket();
+		        udpSender = null;
+	        }
+	        stop();
+	        if(!bridgeSettings.getBridgeControl().isStop()) {
+	        	try {
+					Thread.sleep(5000);
+				} catch (InterruptedException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+	        }
+        }
+        log.info("HA Bridge (v" + theVersion.getVersion() + ") exiting....");
+        System.exit(0);
+    }
+}

src/main/java/com/bwssystems/HABridge/Home.java

@@ -0,0 +1,9 @@
+package com.bwssystems.HABridge;
+
+import com.bwssystems.HABridge.devicemanagmeent.ResourceHandler;
+import com.bwssystems.HABridge.hue.HueMulatorHandler;
+
+public interface Home extends HueMulatorHandler, ResourceHandler {
+	public Home createHome(BridgeSettings bridgeSettings);
+	public void closeHome();
+}

src/main/java/com/bwssystems/HABridge/HomeManager.java

@@ -0,0 +1,117 @@
+package com.bwssystems.HABridge;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.bwssystems.HABridge.devicemanagmeent.ResourceHandler;
+import com.bwssystems.HABridge.plugins.NestBridge.NestHome;
+import com.bwssystems.HABridge.plugins.domoticz.DomoticzHome;
+import com.bwssystems.HABridge.plugins.exec.CommandHome;
+import com.bwssystems.HABridge.plugins.hal.HalHome;
+import com.bwssystems.HABridge.plugins.harmony.HarmonyHome;
+import com.bwssystems.HABridge.plugins.hass.HassHome;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+import com.bwssystems.HABridge.plugins.hue.HueHome;
+import com.bwssystems.HABridge.plugins.lifx.LifxHome;
+import com.bwssystems.HABridge.plugins.mqtt.MQTTHome;
+import com.bwssystems.HABridge.plugins.somfy.SomfyHome;
+import com.bwssystems.HABridge.plugins.tcp.TCPHome;
+import com.bwssystems.HABridge.plugins.udp.UDPHome;
+import com.bwssystems.HABridge.plugins.vera.VeraHome;
+import com.bwssystems.HABridge.util.UDPDatagramSender;
+
+public class HomeManager {
+	Map<String, Home> homeList;
+	Map<String, Home> resourceList;
+	
+	public HomeManager() {
+		homeList = new HashMap<String, Home>();
+		resourceList = new HashMap<String, Home>();
+	}
+
+	// factory method
+	public void buildHomes(BridgeSettings bridgeSettings, UDPDatagramSender aUdpDatagramSender) {
+		Home aHome = null;
+        //setup the harmony connection if available
+		aHome = new HarmonyHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex], aHome);
+        //setup the nest connection if available
+		aHome = new NestHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.NEST_THERMO_SET[DeviceMapTypes.typeIndex], aHome);
+        //setup the hue passtrhu configuration if available
+		aHome = new HueHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex], aHome);
+        //setup the hal configuration if available
+		aHome = new HalHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_BUTTON[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_HOME[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_THERMO_SET[DeviceMapTypes.typeIndex], aHome);
+        //setup the mqtt handlers if available
+		aHome = new MQTTHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex], aHome);
+        //setup the HomeAssistant configuration if available
+		aHome = new HassHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the command execution Home
+		aHome = new CommandHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.EXEC_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.CMD_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the http handler Home
+		aHome = new HTTPHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.HTTP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.CUSTOM_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex], aHome);
+		//setup the tcp handler Home
+		aHome = new TCPHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.TCP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.TCP_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		//setup the udp handler Home
+		aHome = new UDPHome(bridgeSettings, aUdpDatagramSender);
+		homeList.put(DeviceMapTypes.UDP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.UDP_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		// Setup Vera Home if available
+		aHome = new VeraHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex], aHome);
+        //setup the Domoticz configuration if available
+		aHome = new DomoticzHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the Somfy configuration if available
+		aHome = new SomfyHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex], aHome);
+        //setup the Lifx configuration if available
+		aHome = new LifxHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex], aHome);
+	}
+	
+	public Home findHome(String type) {
+		return homeList.get(type);
+	}
+	public ResourceHandler findResource(String type) {
+		return resourceList.get(type);
+	}
+
+	public void closeHomes() {
+		Collection<Home> theHomes = homeList.values();
+		for(Home aHome : theHomes) {
+			aHome.closeHome();
+		}
+		homeList.clear();
+		homeList = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/IpList.java

@@ -0,0 +1,16 @@
+package com.bwssystems.HABridge;
+
+import java.util.List;
+
+public class IpList {
+	private List<NamedIP> devices;
+
+	public List<NamedIP> getDevices() {
+		return devices;
+	}
+
+	public void setDevices(List<NamedIP> devices) {
+		this.devices = devices;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/LinkButtonPressed.java

@@ -0,0 +1,26 @@
+package com.bwssystems.HABridge;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LinkButtonPressed extends TimerTask {
+    private static final Logger log = LoggerFactory.getLogger(LinkButtonPressed.class);
+	private BridgeControlDescriptor linkDescriptor;
+	private Timer myTimer;
+
+	public LinkButtonPressed(BridgeControlDescriptor theDescriptor, Timer aTimer) {
+		linkDescriptor = theDescriptor;
+		myTimer = aTimer;
+	}
+
+	@Override
+	public void run() {
+		log.info("Link button time ended....");
+		linkDescriptor.setLinkButton(false);
+		myTimer.cancel();
+	}
+
+}

src/main/java/com/bwssystems/HABridge/LoginResult.java

@@ -0,0 +1,22 @@
+package com.bwssystems.HABridge;
+
+public class LoginResult {
+	
+	private String error;
+	
+	private User user;
+	
+	public String getError() {
+		return error;
+	}
+	public void setError(String error) {
+		this.error = error;
+	}
+	public User getUser() {
+		return user;
+	}
+	public void setUser(User user) {
+		this.user = user;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/NamedIP.java

@@ -0,0 +1,54 @@
+package com.bwssystems.HABridge;
+
+public class NamedIP {
+	private String name;
+        private String ip;
+        private String webhook;
+	private String port;
+	private String username;
+	private String password;
+	private Boolean secure;
+	
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getIp() {
+		return ip;
+	}
+	public void setIp(String ip) {
+		this.ip = ip;
+	}
+        public String getWebhook() {
+            return webhook;
+        }
+        public void setWebhook(final String webhook) {
+            this.webhook = webhook;
+        }
+        public String getPort() {
+		return port;
+	}
+	public void setPort(String port) {
+		this.port = port;
+	}
+	public String getUsername() {
+		return username;
+	}
+	public void setUsername(String username) {
+		this.username = username;
+	}
+	public String getPassword() {
+		return password;
+	}
+	public void setPassword(String password) {
+		this.password = password;
+	}
+	public Boolean getSecure() {
+		return secure;
+	}
+	public void setSecure(Boolean secure) {
+		this.secure = secure;
+	}
+}

src/main/java/com/bwssystems/HABridge/SecurityInfo.java

@@ -0,0 +1,33 @@
+package com.bwssystems.HABridge;
+
+public class SecurityInfo {
+	private boolean useLinkButton;
+	private String execGarden;
+	private boolean secureHueApi;
+	private boolean isSecure;
+	
+	public boolean isUseLinkButton() {
+		return useLinkButton;
+	}
+	public void setUseLinkButton(boolean useLinkButton) {
+		this.useLinkButton = useLinkButton;
+	}
+	public String getExecGarden() {
+		return execGarden;
+	}
+	public void setExecGarden(String execGarden) {
+		this.execGarden = execGarden;
+	}
+	public boolean isSecureHueApi() {
+		return secureHueApi;
+	}
+	public void setSecureHueApi(boolean secureHueApi) {
+		this.secureHueApi = secureHueApi;
+	}
+	public boolean isSecure() {
+		return isSecure;
+	}
+	public void setSecure(boolean isSecure) {
+		this.isSecure = isSecure;
+	}
+}

src/main/java/com/bwssystems/HABridge/SystemControl.java

@@ -0,0 +1,485 @@
+package com.bwssystems.HABridge;
+
+import static spark.Spark.get;
+import static spark.Spark.options;
+import static spark.Spark.post;
+import static spark.Spark.put;
+import static spark.Spark.before;
+import static spark.Spark.halt;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Timer;
+import java.util.Base64;
+
+import org.apache.http.HttpStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.dao.BackupFilename;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.bwssystems.HABridge.util.TextStringFormatter;
+import com.bwssystems.logservices.LoggerInfo;
+import com.bwssystems.logservices.LoggingForm;
+import com.bwssystems.logservices.LoggingManager;
+import com.google.gson.Gson;
+
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.classic.spi.LoggingEvent;
+import ch.qos.logback.core.read.CyclicBufferAppender;
+
+public class SystemControl {
+    private static final Logger log = LoggerFactory.getLogger(SystemControl.class);
+    public static final String CYCLIC_BUFFER_APPENDER_NAME = "CYCLIC";
+    private LoggerContext lc; 
+    private static final String SYSTEM_CONTEXT = "/system";
+    private BridgeSettings bridgeSettings;
+    private Version version;
+    private CyclicBufferAppender<ILoggingEvent> cyclicBufferAppender;
+    private DateFormat dateFormat;
+    private LoggingManager theLogServiceMgr;
+
+
+	public SystemControl(BridgeSettings theBridgeSettings, Version theVersion) {
+        this.bridgeSettings = theBridgeSettings;
+		this.version = theVersion;
+		this.lc = (LoggerContext) LoggerFactory.getILoggerFactory(); 
+		this.dateFormat = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss.SSS");
+		reacquireCBA();
+		theLogServiceMgr = new LoggingManager();
+		theLogServiceMgr.init();
+	}
+
+//	This function sets up the sparkjava rest calls for the hue api
+    public void setupServer() {
+    	log.info("System control service started....");
+		before(SYSTEM_CONTEXT + "/*", (request, response) -> {
+			if(bridgeSettings.getBridgeSecurity().isSecure()) {
+				String pathInfo = request.pathInfo();
+				if(pathInfo == null || (!pathInfo.equals(SYSTEM_CONTEXT + "/login") && !pathInfo.equals(SYSTEM_CONTEXT + "/habridge/version"))) {
+					User authUser = bridgeSettings.getBridgeSecurity().getAuthenticatedUser(request);
+					if(authUser == null) {
+						halt(401, "{\"message\":\"User not authenticated\"}");
+					}
+				}
+			}
+		});
+	    // http://ip_address:port/system/habridge/version gets the version of this bridge instance
+    	get (SYSTEM_CONTEXT + "/habridge/version", (request, response) -> {
+	    	log.debug("Get HA Bridge version: v" + version.getVersion());
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return "{\"version\":\"" + version.getVersion() + "\",\"isSecure\":" + bridgeSettings.getBridgeSecurity().isSecure() + "}";
+	    });
+
+	    // http://ip_address:port/system/habridge/testuser gets the valid test user for calling the api
+    	get (SYSTEM_CONTEXT + "/habridge/testuser", (request, response) -> {
+	    	log.debug("Get HA Bridge testuser: " + bridgeSettings.getBridgeSettingsDescriptor().getInternalTestUser());
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return "{\"user\":\"" + bridgeSettings.getBridgeSettingsDescriptor().getInternalTestUser() + "\"}";
+	    });
+
+	    // http://ip_address:port/system/logmsgs gets the log messages for the bridge
+    	get (SYSTEM_CONTEXT + "/logmsgs", (request, response) -> {
+			log.debug("Get logmsgs.");
+			String logMsgs;
+		    int count = -1;
+		    if(cyclicBufferAppender == null)
+		    	reacquireCBA();
+		    if (cyclicBufferAppender != null) {
+		      count = cyclicBufferAppender.getLength();
+		    }
+		    logMsgs = "[";
+		    if (count == -1) {
+		      logMsgs = logMsgs + "{\"message\":\"Failed to locate CyclicBuffer\"}";
+		    } else if (count == 0) {
+		    	logMsgs = logMsgs + "{\"message\":\"No logging events to display\"}";
+		    } else {
+				LoggingEvent le;
+				for (int i = 0; i < count; i++) {
+					le = (LoggingEvent) cyclicBufferAppender.get(i);
+					logMsgs = logMsgs + ( i > 0?",{":"{") + "\"time\":\"" + dateFormat.format(le.getTimeStamp()) + "\",\"level\":\"" + le.getLevel().levelStr + "\",\"component\":\"" + le.getLoggerName() + "\",\"message\":\"" + TextStringFormatter.forJSON(le.getFormattedMessage()) + "\"}";
+				}
+		    }
+		    logMsgs = logMsgs + "]";
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+			return logMsgs;
+	    });
+
+	    // http://ip_address:port/system/logmgmt/loggers gets the logger info for the bridge
+    	get (SYSTEM_CONTEXT + "/logmgmt/loggers/:all", (request, response) -> {
+			log.debug("Get loggers info with showAll argument: " + request.params(":all"));
+			Boolean showAll = false;
+			if(request.params(":all").equals("true"))
+				showAll = true;
+			theLogServiceMgr.setShowAll(showAll);
+			theLogServiceMgr.init();
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+			return theLogServiceMgr.getConfiguredLoggers();
+	    }, new JsonTransformer());
+
+//      http://ip_address:port/system/setpassword CORS request
+	    options(SYSTEM_CONTEXT + "/setpassword", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/setpassword which sets a password for a given user
+		post(SYSTEM_CONTEXT + "/setpassword", (request, response) -> {
+			log.debug("setpassword....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			String errorMessage = bridgeSettings.getBridgeSecurity().setPassword(theUser);
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        response.status(HttpStatus.SC_OK);
+		        bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/adduser CORS request
+	    options(SYSTEM_CONTEXT + "/adduser", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/adduser which adds a new user
+		put(SYSTEM_CONTEXT + "/adduser", (request, response) -> {
+			log.debug("adduser....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			String errorMessage = theUser.validate();
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        errorMessage = bridgeSettings.getBridgeSecurity().addUser(theUser);
+				if(errorMessage == null) {
+			        response.status(HttpStatus.SC_OK);
+			        bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+				} else {
+			        response.status(HttpStatus.SC_BAD_REQUEST);
+			        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+				}
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/deluser CORS request
+	    options(SYSTEM_CONTEXT + "/deluser", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/deluser which dels a user
+		put(SYSTEM_CONTEXT + "/deluser", (request, response) -> {
+			log.debug("deluser....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+	        String errorMessage = bridgeSettings.getBridgeSecurity().delUser(theUser);
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        response.status(HttpStatus.SC_OK);
+				bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/login CORS request
+	    options(SYSTEM_CONTEXT + "/login", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/login validates the login
+		post(SYSTEM_CONTEXT + "/login", (request, response) -> {
+			log.debug("login....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			LoginResult result = bridgeSettings.getBridgeSecurity().validatePassword(theUser);
+			if(result.getUser() != null)
+				bridgeSettings.getBridgeSecurity().addAuthenticatedUser(request, theUser);
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return result;
+        }, new JsonTransformer());
+
+//      http://ip_address:port/system/presslinkbutton CORS request
+	    options(SYSTEM_CONTEXT + "/presslinkbutton", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/presslinkbutton which sets the link button for device registration
+		put(SYSTEM_CONTEXT + "/presslinkbutton", (request, response) -> {
+			log.info("Link button pressed....");
+			bridgeSettings.getBridgeControl().setLinkButton(true);
+			Timer theTimer = new Timer();
+			theTimer.schedule(new LinkButtonPressed(bridgeSettings.getBridgeControl(), theTimer), 30000);
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return "";
+        }, new JsonTransformer());
+
+	    // http://ip_address:port/system/securityinfo gets the security info for the bridge
+    	get (SYSTEM_CONTEXT + "/securityinfo", (request, response) -> {
+			log.debug("Get security info");
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+			return bridgeSettings.getBridgeSecurity().getSecurityInfo();
+	    }, new JsonTransformer());
+
+//      http://ip_address:port/system/changesecurityinfo CORS request
+	    options(SYSTEM_CONTEXT + "/changesecurityinfo", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/changesecurityinfo which sets the security settings other than passwords and users
+		post(SYSTEM_CONTEXT + "/changesecurityinfo", (request, response) -> {
+			log.debug("changesecurityinfo....");
+			SecurityInfo theInfo = new Gson().fromJson(request.body(), SecurityInfo.class);
+			if(theInfo.getExecGarden() != null)
+				bridgeSettings.getBridgeSecurity().setExecGarden(theInfo.getExecGarden());
+			bridgeSettings.getBridgeSecurity().setUseLinkButton(theInfo.isUseLinkButton());
+			bridgeSettings.getBridgeSecurity().setSecureHueApi(theInfo.isSecureHueApi());
+			bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return bridgeSettings.getBridgeSecurity().getSecurityInfo();
+        }, new JsonTransformer());
+
+//      http://ip_address:port/system/logmgmt/update CORS request
+	    options(SYSTEM_CONTEXT + "/logmgmt/update", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/logmgmt/update which changes logging parameters for the process
+		put(SYSTEM_CONTEXT + "/logmgmt/update", (request, response) -> {
+			log.debug("update loggers: " + request.body());
+			LoggerInfo updateLoggers[];
+			updateLoggers = new Gson().fromJson(request.body(), LoggerInfo[].class);
+			LoggingForm theModel = theLogServiceMgr.getModel();
+			theModel.setUpdatedLoggers(Arrays.asList(updateLoggers));
+			theLogServiceMgr.updateLogLevels();
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return theLogServiceMgr.getConfiguredLoggers();
+        }, new JsonTransformer());
+
+    	//      http://ip_address:port/system/settings which returns the bridge configuration settings
+		get(SYSTEM_CONTEXT + "/settings", (request, response) -> {
+			log.debug("bridge settings requested from " + request.ip());
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return bridgeSettings.getBridgeSettingsDescriptor();
+        }, new JsonTransformer());
+		
+//      http://ip_address:port/system/settings CORS request
+	    options(SYSTEM_CONTEXT + "/settings", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/settings which returns the bridge configuration settings
+		put(SYSTEM_CONTEXT + "/settings", (request, response) -> {
+			log.debug("save bridge settings requested from " + request.ip() + " with body: " + request.body());
+			BridgeSettingsDescriptor newBridgeSettings = new Gson().fromJson(request.body(), BridgeSettingsDescriptor.class);
+			bridgeSettings.save(newBridgeSettings);
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return bridgeSettings.getBridgeSettingsDescriptor();
+        }, new JsonTransformer());
+		
+	    // http://ip_address:port/system/control/reinit CORS request
+	    options(SYSTEM_CONTEXT + "/control/reinit", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+	    // http://ip_address:port/system/control/reinit sets the parameter reinit the server
+	    put(SYSTEM_CONTEXT + "/control/reinit", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	    	return reinit();
+	    });
+
+	    // http://ip_address:port/system/control/stop CORS request
+	    options(SYSTEM_CONTEXT + "/control/stop", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+	    // http://ip_address:port/system/control/stop sets the parameter stop the server
+	    put(SYSTEM_CONTEXT + "/control/stop", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	    	return stop();
+	    });
+
+	    // http://ip_address:port/system/backup/available returns a list of config backup filenames
+	    get (SYSTEM_CONTEXT + "/backup/available", (request, response) -> {
+        	log.debug("Get backup filenames");
+          	response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+          	return bridgeSettings.getBackups();
+        }, new JsonTransformer());
+
+	    // http://ip_address:port/system/backup/create CORS request
+	    options(SYSTEM_CONTEXT + "/backup/create", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	put (SYSTEM_CONTEXT + "/backup/create", (request, response) -> {
+	    	log.debug("Create backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	BackupFilename returnFilename = new BackupFilename();
+        	returnFilename.setFilename(bridgeSettings.backup(aFilename.getFilename()));
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return returnFilename;
+    	}, new JsonTransformer());
+
+	    // http://ip_address:port/system/backup/delete CORS request
+	    options(SYSTEM_CONTEXT + "/backup/delete", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (SYSTEM_CONTEXT + "/backup/delete", (request, response) -> {
+	    	log.debug("Delete backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	if(aFilename != null)
+        		bridgeSettings.deleteBackup(aFilename.getFilename());
+        	else
+        		log.warn("No filename given for delete backup.");
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return "";
+	    }, new JsonTransformer());
+
+	    // http://ip_address:port/system/backup/restore CORS request
+	    options(SYSTEM_CONTEXT + "/backup/restore", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (SYSTEM_CONTEXT + "/backup/restore", (request, response) -> {
+	    	log.debug("Restore backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	if(aFilename != null) {
+        		bridgeSettings.restoreBackup(aFilename.getFilename());
+        		bridgeSettings.loadConfig();
+        	}
+        	else
+        		log.warn("No filename given for restore backup.");
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return bridgeSettings.getBridgeSettingsDescriptor();
+	    }, new JsonTransformer());
+    }
+    
+    void reacquireCBA() {
+        cyclicBufferAppender = (CyclicBufferAppender<ILoggingEvent>) lc.getLogger(
+            Logger.ROOT_LOGGER_NAME).getAppender(CYCLIC_BUFFER_APPENDER_NAME);
+        cyclicBufferAppender.setMaxSize(bridgeSettings.getBridgeSettingsDescriptor().getNumberoflogmessages());
+      }
+
+    protected void pingListener() {
+        try {
+            byte[] buf = new byte[256];
+            String testData = "M-SEARCH * HTTP/1.1\nHOST: " + Configuration.UPNP_MULTICAST_ADDRESS + ":" + Configuration.UPNP_DISCOVERY_PORT + "ST: urn:schemas-upnp-org:device:CloudProxy:1\nMAN: \"ssdp:discover\"\nMX: 3";
+            buf = testData.getBytes();
+            MulticastSocket socket = new MulticastSocket(Configuration.UPNP_DISCOVERY_PORT);
+
+            InetAddress group = InetAddress.getByName(Configuration.UPNP_MULTICAST_ADDRESS);
+            DatagramPacket packet;
+            packet = new DatagramPacket(buf, buf.length, group, Configuration.UPNP_DISCOVERY_PORT);
+            socket.send(packet);
+
+            socket.close();
+        }
+        catch (IOException e) {
+        	log.warn("Error pinging listener. " + e.getMessage());
+        }
+    }
+    
+    public String reinit() {
+    	bridgeSettings.getBridgeControl().setReinit(true);
+    	pingListener();
+    	return "{\"control\":\"reiniting\"}";
+    }
+    
+    public String stop() {
+    	bridgeSettings.getBridgeControl().setStop(true);
+    	pingListener();
+    	return "{\"control\":\"stopping\"}";    	
+    }
+}

src/main/java/com/bwssystems/HABridge/User.java

@@ -0,0 +1,65 @@
+package com.bwssystems.HABridge;
+
+import spark.utils.StringUtils;
+
+public class User {
+	private int id;
+	
+	private String username;
+	
+	private String password;
+	
+	private String password2;
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public String getPassword2() {
+		return password2;
+	}
+
+	public void setPassword2(String password2) {
+		this.password2 = password2;
+	}
+	
+	public String validate() {
+		String error = null;
+		
+		if(StringUtils.isEmpty(username)) {
+			error = "You have to enter a username";
+		} else if(StringUtils.isEmpty(password)) {
+			error = "You have to enter a password";
+		} else if(!password.equals(password2)) {
+			error = "The two passwords do not match";
+		}
+		
+		return error;
+	}
+
+	public boolean validatePassword() {
+		if(password != null && password2 != null)
+			return password.equals(password2);
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/Version.java

@@ -0,0 +1,50 @@
+package com.bwssystems.HABridge;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+
+public final class Version {
+
+    private String version;
+    private String groupId;
+    private String artifactId;
+    private Properties prop;
+    
+    public Version()
+    {
+        InputStream resourceAsStream =
+          (InputStream) this.getClass().getResourceAsStream(
+            "/version.properties"
+          );
+        this.prop = new Properties();
+
+        try
+        {
+            this.prop.load( resourceAsStream );
+        	this.version = this.prop.getProperty("version");
+        	this.groupId = this.prop.getProperty("groupId");
+        	this.artifactId = this.prop.getProperty("artifactId");
+        }
+        catch (Exception e)
+        {
+        	this.version = "0.0.0";
+        	this.groupId = "no group";
+        	this.artifactId = "no artifact";
+        }
+
+    }
+
+	public String getVersion() {
+		return version;
+	}
+
+	public String getGroupId() {
+		return groupId;
+	}
+
+	public String getArtifactId() {
+		return artifactId;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/api/CallItem.java

@@ -0,0 +1,87 @@
+package com.bwssystems.HABridge.api;
+
+import com.google.gson.JsonElement;
+
+public class CallItem {
+	private JsonElement item;
+	private Integer count;
+	private Integer delay;
+	private String type;
+	private String filterIPs;
+	private String httpVerb;
+	private String httpBody;
+	private String httpHeaders;
+	private String contentType;
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	public String getFilterIPs() {
+		return filterIPs;
+	}
+
+	public void setFilterIPs(String filterIPs) {
+		this.filterIPs = filterIPs;
+	}
+
+	public JsonElement getItem() {
+		return item;
+	}
+
+	public void setItem(JsonElement item) {
+		this.item = item;
+	}
+
+	public Integer getCount() {
+		return count;
+	}
+
+	public void setCount(Integer count) {
+		this.count = count;
+	}
+
+	public Integer getDelay() {
+		return delay;
+	}
+
+	public void setDelay(Integer delay) {
+		this.delay = delay;
+	}
+
+	public String getHttpVerb() {
+		return httpVerb;
+	}
+
+	public void setHttpVerb(String httpVerb) {
+		this.httpVerb = httpVerb;
+	}
+
+	public String getHttpBody() {
+		return httpBody;
+	}
+
+	public void setHttpBody(String httpBody) {
+		this.httpBody = httpBody;
+	}
+
+	public String getHttpHeaders() {
+		return httpHeaders;
+	}
+
+	public void setHttpHeaders(String httpHeaders) {
+		this.httpHeaders = httpHeaders;
+	}
+
+	public String getContentType() {
+		return contentType;
+	}
+
+	public void setContentType(String contentType) {
+		this.contentType = contentType;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/CallItemDeserializer.java

@@ -0,0 +1,30 @@
+package com.bwssystems.HABridge.api;
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class CallItemDeserializer implements JsonDeserializer<CallItem> {
+    @Override
+    public CallItem deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+    	CallItem aCallItem = new CallItem();
+        JsonObject jsonObj = json.getAsJsonObject();
+        JsonElement jsonElem;
+        jsonElem = jsonObj.get("item");
+        aCallItem.setItem(jsonElem);
+        jsonElem = jsonObj.get("delay");
+        aCallItem.setDelay(jsonElem.getAsInt());
+        jsonElem = jsonObj.get("count");
+        aCallItem.setCount(jsonElem.getAsInt());
+        jsonElem = jsonObj.get("type");
+        aCallItem.setType(jsonElem.getAsString());
+        jsonElem = jsonObj.get("filterIPs");
+        aCallItem.setFilterIPs(jsonElem.getAsString());
+        
+        return aCallItem;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/api/NameValue.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.api;
+
+public class NameValue {
+	private String name;
+	private String value;
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getValue() {
+		return value;
+	}
+	public void setValue(String value) {
+		this.value = value;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/SuccessUserResponse.java

@@ -0,0 +1,13 @@
+package com.bwssystems.HABridge.api;
+
+public class SuccessUserResponse {
+	private UserCreateResponse success;
+
+	public UserCreateResponse getSuccess() {
+		return success;
+	}
+
+	public void setSuccess(UserCreateResponse success) {
+		this.success = success;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/UserCreateRequest.java

@@ -0,0 +1,19 @@
+package com.bwssystems.HABridge.api;
+
+public class UserCreateRequest {
+    private String devicetype;
+	private String username;
+
+    public String getDevicetype() {
+		return devicetype;
+	}
+	public void setDevicetype(String devicetype) {
+		this.devicetype = devicetype;
+	}
+	public String getUsername() {
+		return username;
+	}
+	public void setUsername(String username) {
+		this.username = username;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/UserCreateResponse.java

@@ -0,0 +1,13 @@
+package com.bwssystems.HABridge.api;
+
+public class UserCreateResponse {
+	private String username;
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/DeviceResponse.java

@@ -0,0 +1,96 @@
+package com.bwssystems.HABridge.api.hue;
+
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+
+/**
+ * Created by arm on 4/14/15.
+ */
+public class DeviceResponse {
+    private DeviceState state;
+    private String type;
+    private String name;
+    private String modelid;
+    private String manufacturername;
+    private String luminaireuniqueid;
+    private String uniqueid;
+    private String swversion;
+
+    public DeviceState getState() {
+        return state;
+    }
+
+    public void setState(DeviceState state) {
+        this.state = state;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getModelid() {
+        return modelid;
+    }
+
+    public void setModelid(String modelid) {
+        this.modelid = modelid;
+    }
+
+    public String getManufacturername() {
+        return manufacturername;
+    }
+
+    public void setManufacturername(String manufacturername) {
+        this.manufacturername = manufacturername;
+    }
+
+    public String getUniqueid() {
+        return uniqueid;
+    }
+
+    public void setUniqueid(String uniqueid) {
+        this.uniqueid = uniqueid;
+    }
+
+    public String getSwversion() {
+        return swversion;
+    }
+
+    public void setSwversion(String swversion) {
+        this.swversion = swversion;
+    }
+
+    public String getLuminaireuniqueid() {
+		return luminaireuniqueid;
+	}
+
+	public void setLuminaireuniqueid(String luminaireuniqueid) {
+		this.luminaireuniqueid = luminaireuniqueid;
+	}
+
+	public static DeviceResponse createResponse(DeviceDescriptor device){
+        DeviceResponse response = new DeviceResponse();
+        response.setState(device.getDeviceState());
+
+        response.setName(device.getName());
+        response.setUniqueid(device.getUniqueid());
+        response.setManufacturername("Philips");
+        response.setType("Dimmable light");
+        response.setModelid("LWB004");
+        response.setSwversion("66012040");
+        response.setLuminaireuniqueid(null);
+
+        return response;
+    }
+}

src/main/java/com/bwssystems/HABridge/api/hue/DeviceState.java

@@ -1,5 +1,6 @@
-package com.bwssytems.HABridge.api.hue;
+package com.bwssystems.HABridge.api.hue;
 
+// import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -7,7 +8,7 @@ import java.util.List;
  */
 public class DeviceState {
     private boolean on;
-    private int bri = 255;
+    private int bri;
     private int hue;
     private int sat;
     private String effect;
@@ -16,6 +17,7 @@ public class DeviceState {
     private String colormode;
     private boolean reachable;
     private List<Double> xy;
+//    private int transitiontime;
 
     public boolean isOn() {
         return on;
@@ -96,7 +98,32 @@ public class DeviceState {
     public void setXy(List<Double> xy) {
         this.xy = xy;
     }
+//    public int getTransitiontime() {
+//		return transitiontime;
+//	}
 
+//	public void setTransitiontime(int transitiontime) {
+//		this.transitiontime = transitiontime;
+//	}
+
+	public static DeviceState createDeviceState() {
+    	DeviceState newDeviceState = new DeviceState();
+    	newDeviceState.fillIn();
+//    	newDeviceState.setColormode("none");
+//    	ArrayList<Double> doubleArray = new ArrayList<Double>();
+//    	doubleArray.add(new Double(0));
+//    	doubleArray.add(new Double(0));
+//    	newDeviceState.setXy(doubleArray);
+    	
+    	return newDeviceState;
+    }
+    public void fillIn() {
+    	if(this.getAlert() == null)
+    		this.setAlert("none");
+    	if(this.getEffect() == null)
+    		this.setEffect("none");
+    	this.setReachable(true);
+    }
     @Override
     public String toString() {
         return "DeviceState{" +

src/main/java/com/bwssystems/HABridge/api/hue/DeviceTypes.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class DeviceTypes {
+	private Boolean bridge;
+	private String[] lights;
+	public Boolean getBridge() {
+		return bridge;
+	}
+	public void setBridge(Boolean bridge) {
+		this.bridge = bridge;
+	}
+	public String[] getLights() {
+		return lights;
+	}
+	public void setLights(String[] lights) {
+		this.lights = lights;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/GroupResponse.java

@@ -0,0 +1,81 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.List;
+
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.google.gson.annotations.SerializedName;
+
+public class GroupResponse {
+    @SerializedName("action")
+	private DeviceState action;
+    @SerializedName("lights")
+	private String[] lights;
+    @SerializedName("name")
+	private String name;
+    @SerializedName("type")
+	private String type;
+    @SerializedName("class")
+    String class_name;
+
+	public DeviceState getAction() {
+		return action;
+	}
+	public void setAction(DeviceState action) {
+		this.action = action;
+	}
+	public String[] getLights() {
+		return lights;
+	}
+	public void setLights(String[] lights) {
+		this.lights = lights;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	 public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public String getClass_name() {
+		return class_name;
+	}
+	public void setClass_name(String class_name) {
+		this.class_name = class_name;
+	}
+	public static GroupResponse createDefaultGroupResponse(List<DeviceDescriptor> deviceList) {
+	        String[] theList = new String[deviceList.size()];
+	        int i = 0;
+	        for (DeviceDescriptor device : deviceList) {
+             theList[i] = device.getId();
+             i++;
+	        }
+		 GroupResponse theResponse = new GroupResponse();
+		 theResponse.setAction(DeviceState.createDeviceState());
+		 theResponse.setName("Lightset 0");
+		 theResponse.setLights(theList);
+		 theResponse.setType("LightGroup");
+		 return theResponse;
+	 }
+	public static GroupResponse createOtherGroupResponse(List<DeviceDescriptor> deviceList) {
+        String[] theList = new String[deviceList.size()];
+        int i = 0;
+        for (DeviceDescriptor device : deviceList) {
+         theList[i] = device.getId();
+         i++;
+        }
+	 GroupResponse theResponse = new GroupResponse();
+	 theResponse.setAction(DeviceState.createDeviceState());
+	 theResponse.setName("AGroup");
+	 theResponse.setLights(theList);
+	 theResponse.setType("Room");
+	 theResponse.setClass_name("Other");
+
+	 return theResponse;
+ }
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueApiResponse.java

@@ -0,0 +1,86 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.bwssystems.HABridge.api.hue.DeviceResponse;
+import com.google.gson.JsonObject;
+
+/**
+ * Created by arm on 4/14/15.
+ */
+public class HueApiResponse {
+    private Map<String, DeviceResponse> lights;
+    private Map<String, JsonObject> scenes;
+    private Map<String, GroupResponse> groups;
+    private Map<String, JsonObject> schedules;
+    private Map<String, JsonObject> sensors;
+    private Map<String, JsonObject> rules;
+    private HueConfig config;
+
+    public HueApiResponse(String name, String ipaddress, Map<String, WhitelistEntry> awhitelist, String emulateHubVersion) {
+		super();
+		this.setConfig(HueConfig.createConfig(name, ipaddress, awhitelist, emulateHubVersion));
+		this.setRules(new HashMap<>());
+		this.setSensors(new HashMap<>());
+		this.setSchedules(new HashMap<>());
+		this.setGroups(new HashMap<>());
+		this.setScenes(new HashMap<>());
+	}
+
+	public Map<String, DeviceResponse> getLights() {
+        return lights;
+    }
+
+    public void setLights(Map<String, DeviceResponse> lights) {
+        this.lights = lights;
+    }
+
+	public Map<String, JsonObject> getScenes() {
+		return scenes;
+	}
+
+	public void setScenes(Map<String, JsonObject> scenes) {
+		this.scenes = scenes;
+	}
+
+	public Map<String, GroupResponse> getGroups() {
+		return groups;
+	}
+
+	public void setGroups(Map<String, GroupResponse> groups) {
+		this.groups = groups;
+	}
+
+	public Map<String, JsonObject> getSchedules() {
+		return schedules;
+	}
+
+	public void setSchedules(Map<String, JsonObject> schedules) {
+		this.schedules = schedules;
+	}
+
+	public Map<String, JsonObject> getSensors() {
+		return sensors;
+	}
+
+	public void setSensors(Map<String, JsonObject> sensors) {
+		this.sensors = sensors;
+	}
+
+	public Map<String, JsonObject> getRules() {
+		return rules;
+	}
+
+	public void setRules(Map<String, JsonObject> rules) {
+		this.rules = rules;
+	}
+
+	public HueConfig getConfig() {
+		return config;
+	}
+
+	public void setConfig(HueConfig config) {
+		this.config = config;
+	}    
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueConfig.java

@@ -0,0 +1,275 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Map;
+import java.util.TimeZone;
+
+public class HueConfig
+{
+	private Boolean portalservices;
+	private String gateway;
+	private String mac;
+	private String swversion;
+	private String apiversion;
+	private Boolean linkbutton;
+	private String ipaddress;
+	private Integer proxyport;
+	private Swupdate swupdate;
+	private String netmask;
+	private String name;
+	private Boolean dhcp;
+	private String UTC;
+	private String proxyaddress;
+	private String localtime;
+	private String timezone;
+	private String zigbeechannel;
+	private String modelid;
+	private String bridgeid;
+	private Boolean factorynew;
+	private String replacesbridgeid;
+	private Map<String, WhitelistEntry> whitelist;
+
+	public static HueConfig createConfig(String name, String ipaddress, Map<String, WhitelistEntry> awhitelist, String emulateHubVersion) {
+		HueConfig aConfig = new HueConfig();
+	    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+	    SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+		dateFormatGmt.setTimeZone(TimeZone.getTimeZone("UTC"));
+		aConfig.setMac(HueConfig.getMacAddress(ipaddress));
+		aConfig.setApiversion(HueConstants.API_VERSION);
+		aConfig.setPortalservices(false);
+		aConfig.setGateway(ipaddress);
+		aConfig.setSwversion(emulateHubVersion);
+		aConfig.setLinkbutton(true);
+		aConfig.setIpaddress(ipaddress);
+		aConfig.setProxyport(0);
+		aConfig.setSwupdate(Swupdate.createSwupdate());
+		aConfig.setNetmask("255.255.255.0");
+		aConfig.setName(name);
+		aConfig.setDhcp(true);
+		aConfig.setUtc(dateFormatGmt.format(new Date()));
+		aConfig.setProxyaddress("none");
+		aConfig.setLocaltime(dateFormat.format(new Date()));
+		aConfig.setTimezone(TimeZone.getDefault().getID());
+		aConfig.setZigbeechannel("6");
+		aConfig.setBridgeid(HuePublicConfig.createConfig(name, ipaddress, emulateHubVersion).getHueBridgeIdFromMac());
+		aConfig.setModelid(HueConstants.MODEL_ID);
+		aConfig.setFactorynew(false);
+		aConfig.setReplacesbridgeid(null);
+		aConfig.setWhitelist(awhitelist);
+
+		return aConfig;
+	}
+
+	private static String getMacAddress(String addr)
+	{
+		InetAddress ip;
+		StringBuilder sb = new StringBuilder();
+		try {
+				
+			ip = InetAddress.getByName(addr);
+			
+			NetworkInterface network = NetworkInterface.getByInetAddress(ip);
+				
+			byte[] mac = network.getHardwareAddress();
+				
+			for (int i = 0; i < mac.length; i++) {
+				sb.append(String.format("%02X%s", mac[i], (i < mac.length - 1) ? ":" : ""));		
+			}
+				
+		} catch (UnknownHostException e) {
+			
+			sb.append("00:00:88:00:bb:ee");
+			
+		} catch (SocketException e){
+				
+			sb.append("00:00:88:00:bb:ee");
+				
+		} catch (Exception e){
+			
+			sb.append("00:00:88:00:bb:ee");
+			
+		}
+		    
+		return sb.toString();
+	}
+	public Boolean getPortalservices() {
+		return portalservices;
+	}
+
+	public void setPortalservices(Boolean portalservices) {
+		this.portalservices = portalservices;
+	}
+
+	public String getGateway() {
+		return gateway;
+	}
+
+	public void setGateway(String gateway) {
+		this.gateway = gateway;
+	}
+
+	public String getMac() {
+		return mac;
+	}
+
+	public void setMac(String mac) {
+		this.mac = mac;
+	}
+
+	public String getSwversion() {
+		return swversion;
+	}
+
+	public void setSwversion(String swversion) {
+		this.swversion = swversion;
+	}
+
+	public Boolean getLinkbutton() {
+		return linkbutton;
+	}
+
+	public void setLinkbutton(Boolean linkbutton) {
+		this.linkbutton = linkbutton;
+	}
+
+	public String getIpaddress() {
+		return ipaddress;
+	}
+
+	public void setIpaddress(String ipaddress) {
+		this.ipaddress = ipaddress;
+	}
+
+	public Integer getProxyport() {
+		return proxyport;
+	}
+
+	public void setProxyport(Integer proxyport) {
+		this.proxyport = proxyport;
+	}
+
+	public Swupdate getSwupdate() {
+		return swupdate;
+	}
+
+	public void setSwupdate(Swupdate swupdate) {
+		this.swupdate = swupdate;
+	}
+
+	public String getNetmask() {
+		return netmask;
+	}
+
+	public void setNetmask(String netmask) {
+		this.netmask = netmask;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public Boolean getDhcp() {
+		return dhcp;
+	}
+
+	public void setDhcp(Boolean dhcp) {
+		this.dhcp = dhcp;
+	}
+
+	public String getUtc() {
+		return UTC;
+	}
+
+	public void setUtc(String utc) {
+		this.UTC = utc;
+	}
+
+	public String getProxyaddress() {
+		return proxyaddress;
+	}
+
+	public void setProxyaddress(String proxyaddress) {
+		this.proxyaddress = proxyaddress;
+	}
+
+	public Map<String, WhitelistEntry> getWhitelist() {
+		return whitelist;
+	}
+
+	public void setWhitelist(Map<String, WhitelistEntry> whitelist) {
+		this.whitelist = whitelist;
+	}
+
+	public String getApiversion() {
+		return apiversion;
+	}
+
+	public void setApiversion(String apiversion) {
+		this.apiversion = apiversion;
+	}
+
+	public String getLocaltime() {
+		return localtime;
+	}
+
+	public void setLocaltime(String localtime) {
+		this.localtime = localtime;
+	}
+
+	public String getTimezone() {
+		return timezone;
+	}
+
+	public void setTimezone(String timezone) {
+		this.timezone = timezone;
+	}
+
+	public String getZigbeechannel() {
+		return zigbeechannel;
+	}
+
+	public void setZigbeechannel(String zigbeechannel) {
+		this.zigbeechannel = zigbeechannel;
+	}
+
+	public String getModelid() {
+		return modelid;
+	}
+
+	public void setModelid(String modelid) {
+		this.modelid = modelid;
+	}
+
+	public String getBridgeid() {
+		return bridgeid;
+	}
+
+	public void setBridgeid(String bridgeid) {
+		this.bridgeid = bridgeid;
+	}
+
+	public Boolean getFactorynew() {
+		return factorynew;
+	}
+
+	public void setFactorynew(Boolean factorynew) {
+		this.factorynew = factorynew;
+	}
+
+	public String getReplacesbridgeid() {
+		return replacesbridgeid;
+	}
+
+	public void setReplacesbridgeid(String replacesbridgeid) {
+		this.replacesbridgeid = replacesbridgeid;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueConstants.java

@@ -0,0 +1,8 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueConstants {
+	public final static String HUB_VERSION = "01036659";
+	public final static String API_VERSION = "1.15.0";
+	public final static String MODEL_ID = "BSB002";
+	public final static String UUID_PREFIX = "2f402f80-da50-11e1-9b23-";
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueError.java

@@ -0,0 +1,19 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueError {
+	
+	private HueErrorDetails error;
+
+	public HueError(HueErrorDetails error) {
+		super();
+		this.error = error;
+	}
+
+	public HueErrorDetails getError() {
+		return error;
+	}
+
+	public void setError(HueErrorDetails error) {
+		this.error = error;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueErrorDetails.java

@@ -0,0 +1,56 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueErrorDetails {
+	private String type;
+	private String address;
+	private String description;
+	private String method_name;
+	private String resource_name;
+	private String value;
+	public HueErrorDetails(String type, String address, String description, String method_name, String resource_name,
+			String value) {
+		super();
+		this.type = type;
+		this.address = address;
+		this.description = description;
+		this.method_name = method_name;
+		this.resource_name = resource_name;
+		this.value = value;
+	}
+	public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public String getAddress() {
+		return address;
+	}
+	public void setAddress(String address) {
+		this.address = address;
+	}
+	public String getDescription() {
+		return description;
+	}
+	public void setDescription(String description) {
+		this.description = description;
+	}
+	public String getMethod_name() {
+		return method_name;
+	}
+	public void setMethod_name(String method_name) {
+		this.method_name = method_name;
+	}
+	public String getResource_name() {
+		return resource_name;
+	}
+	public void setResource_name(String resource_name) {
+		this.resource_name = resource_name;
+	}
+	public String getValue() {
+		return value;
+	}
+	public void setValue(String value) {
+		this.value = value;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueErrorResponse.java

@@ -0,0 +1,32 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.ArrayList;
+
+public class HueErrorResponse {
+	private ArrayList<HueError> theErrors;
+
+	public static HueErrorResponse createResponse(String type, String address, String description, String method_name, String resource_name, String value) {
+		HueErrorResponse theErrorResp = new HueErrorResponse();
+		theErrorResp.addError(new HueError(new HueErrorDetails(type, address, description, method_name, resource_name, value)));
+		return theErrorResp;
+	}
+	public HueErrorResponse() {
+		super();
+		theErrors = new ArrayList<HueError>();
+	}
+
+	public void addError(HueError anError) {
+		theErrors.add(anError);
+	}
+	
+	public HueError[] getTheErrors() {
+		HueError theList[] = new HueError[theErrors.size()];
+		theList = theErrors.toArray(theList);
+		return theList;
+	}
+
+	public void setTheErrors(ArrayList<HueError> theErrors) {
+		this.theErrors = theErrors;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/api/hue/HuePublicConfig.java

@@ -0,0 +1,151 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.StringTokenizer;
+
+
+public class HuePublicConfig
+{
+	private String name;
+	private String apiversion;
+	private String swversion;
+	private String mac;
+	private String bridgeid;
+	private String replacesbridgeid;
+	private Boolean factorynew;
+	private String modelid;
+
+	public static HuePublicConfig createConfig(String name, String ipaddress, String emulateHubVersion) {
+		HuePublicConfig aConfig = new HuePublicConfig();
+		aConfig.setMac(HuePublicConfig.getMacAddress(ipaddress));
+		aConfig.setApiversion(HueConstants.API_VERSION);
+		aConfig.setSwversion(emulateHubVersion);
+		aConfig.setName(name);
+		aConfig.setBridgeid(aConfig.getHueBridgeIdFromMac());
+		aConfig.setModelid(HueConstants.MODEL_ID);
+		aConfig.setFactorynew(false);
+		aConfig.setReplacesbridgeid(null);
+
+		return aConfig;
+	}
+
+	private static String getMacAddress(String addr)
+	{
+		InetAddress ip;
+		StringBuilder sb = new StringBuilder();
+		try {
+				
+			ip = InetAddress.getByName(addr);
+			
+			NetworkInterface network = NetworkInterface.getByInetAddress(ip);
+				
+			byte[] mac = network.getHardwareAddress();
+				
+			for (int i = 0; i < mac.length; i++) {
+				sb.append(String.format("%02X%s", mac[i], (i < mac.length - 1) ? ":" : ""));		
+			}
+				
+		} catch (UnknownHostException e) {
+			
+			sb.append("00:00:88:00:bb:ee");
+			
+		} catch (SocketException e){
+				
+			sb.append("00:00:88:00:bb:ee");
+				
+		} catch (Exception e){
+			
+			sb.append("00:00:88:00:bb:ee");
+			
+		}
+		    
+		return sb.toString();
+	}
+
+	public String getSNUUIDFromMac()
+	{
+    	StringTokenizer st = new StringTokenizer(this.getMac(), ":");
+    	String bridgeUUID = "";
+    	while(st.hasMoreTokens()) {
+    		bridgeUUID = bridgeUUID + st.nextToken();
+    	}
+    	bridgeUUID = bridgeUUID.toLowerCase();
+		return bridgeUUID.toLowerCase();
+	}
+
+	protected String getHueBridgeIdFromMac()
+	{
+		String cleanMac = this.getSNUUIDFromMac();
+    	String bridgeId = cleanMac.substring(0, 6) + "FFFE" + cleanMac.substring(6);
+		return bridgeId.toUpperCase();
+	}
+	
+	public String getMac() {
+		return mac;
+	}
+
+	public void setMac(String mac) {
+		this.mac = mac;
+	}
+
+	public String getSwversion() {
+		return swversion;
+	}
+
+	public void setSwversion(String swversion) {
+		this.swversion = swversion;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+
+	public String getApiversion() {
+		return apiversion;
+	}
+
+	public void setApiversion(String apiversion) {
+		this.apiversion = apiversion;
+	}
+
+
+	public String getModelid() {
+		return modelid;
+	}
+
+	public void setModelid(String modelid) {
+		this.modelid = modelid;
+	}
+
+	public String getBridgeid() {
+		return bridgeid;
+	}
+
+	public void setBridgeid(String bridgeid) {
+		this.bridgeid = bridgeid;
+	}
+
+	public Boolean getFactorynew() {
+		return factorynew;
+	}
+
+	public void setFactorynew(Boolean factorynew) {
+		this.factorynew = factorynew;
+	}
+
+	public String getReplacesbridgeid() {
+		return replacesbridgeid;
+	}
+
+	public void setReplacesbridgeid(String replacesbridgeid) {
+		this.replacesbridgeid = replacesbridgeid;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/StateChangeBody.java

@@ -0,0 +1,136 @@
+package com.bwssystems.HABridge.api.hue;
+
+// import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by arm on 4/14/15.
+ */
+public class StateChangeBody {
+    private boolean on;
+    private int bri;
+    private int hue;
+    private int sat;
+    private String effect;
+    private int ct;
+    private String alert;
+    private List<Double> xy;
+    private int transitiontime;
+    private int bri_inc;
+    private int hue_inc;
+    private int sat_inc;
+    private List<Double> xy_inc;
+    private int ct_inc;
+
+    public boolean isOn() {
+        return on;
+    }
+
+    public void setOn(boolean on) {
+        this.on = on;
+    }
+
+    public int getBri() {
+        return bri;
+    }
+
+    public void setBri(int bri) {
+        this.bri = bri;
+    }
+
+    public int getHue() {
+        return hue;
+    }
+
+    public void setHue(int hue) {
+        this.hue = hue;
+    }
+
+    public int getSat() {
+        return sat;
+    }
+
+    public void setSat(int sat) {
+        this.sat = sat;
+    }
+
+    public String getEffect() {
+        return effect;
+    }
+
+    public void setEffect(String effect) {
+        this.effect = effect;
+    }
+
+    public int getCt() {
+        return ct;
+    }
+
+    public void setCt(int ct) {
+        this.ct = ct;
+    }
+
+    public String getAlert() {
+        return alert;
+    }
+
+    public void setAlert(String alert) {
+        this.alert = alert;
+    }
+
+    public List<Double> getXy() {
+        return xy;
+    }
+
+    public void setXy(List<Double> xy) {
+        this.xy = xy;
+    }
+
+	public int getTransitiontime() {
+		return transitiontime;
+	}
+
+	public void setTransitiontime(int transitiontime) {
+		this.transitiontime = transitiontime;
+	}
+
+	public int getBri_inc() {
+		return bri_inc;
+	}
+
+	public void setBri_inc(int bri_inc) {
+		this.bri_inc = bri_inc;
+	}
+
+	public int getHue_inc() {
+		return hue_inc;
+	}
+
+	public void setHue_inc(int hue_inc) {
+		this.hue_inc = hue_inc;
+	}
+
+	public int getSat_inc() {
+		return sat_inc;
+	}
+
+	public void setSat_inc(int sat_inc) {
+		this.sat_inc = sat_inc;
+	}
+
+	public List<Double> getXy_inc() {
+		return xy_inc;
+	}
+
+	public void setXy_inc(List<Double> xy_inc) {
+		this.xy_inc = xy_inc;
+	}
+
+	public int getCt_inc() {
+		return ct_inc;
+	}
+
+	public void setCt_inc(int ct_inc) {
+		this.ct_inc = ct_inc;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/Swupdate.java

@@ -0,0 +1,68 @@
+package com.bwssystems.HABridge.api.hue;
+
+
+public class Swupdate
+{
+	private Integer updatestate;
+	private Boolean checkforupdate;
+	private DeviceTypes devicetypes;
+	private String text;
+	private Boolean notify;
+	private String url;
+
+	public static Swupdate createSwupdate() {
+		Swupdate aSwupdate = new Swupdate();
+		aSwupdate.setUpdatestate(0);
+		aSwupdate.setCheckforupdate(false);
+		aSwupdate.setDevicetypes(new DeviceTypes());
+		aSwupdate.setNotify(false);
+		aSwupdate.setText("");
+		aSwupdate.setUrl("");
+		return aSwupdate;
+	}
+	
+	public Boolean getCheckforupdate() {
+		return checkforupdate;
+	}
+	public void setCheckforupdate(Boolean checkforupdate) {
+		this.checkforupdate = checkforupdate;
+	}
+	public DeviceTypes getDevicetypes() {
+		return devicetypes;
+	}
+	public void setDevicetypes(DeviceTypes devicetypes) {
+		this.devicetypes = devicetypes;
+	}
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public Boolean getNotify() {
+		return notify;
+	}
+
+	public void setNotify(Boolean notify) {
+		this.notify = notify;
+	}
+
+	public Integer getUpdatestate() {
+		return updatestate;
+	}
+
+	public void setUpdatestate(Integer updatestate) {
+		this.updatestate = updatestate;
+	}
+
+	public String getUrl() {
+		return url;
+	}
+
+	public void setUrl(String url) {
+		this.url = url;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/api/hue/WhitelistEntry.java

@@ -0,0 +1,49 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class WhitelistEntry
+{
+	private String lastUseDate;
+	private String createDate;
+	private String name;
+    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+
+	public static WhitelistEntry createEntry(String devicetype) {
+		WhitelistEntry anEntry = new WhitelistEntry();
+		anEntry.setName(devicetype);
+		anEntry.setCreateDate(getCurrentDate());
+		anEntry.setLastUseDate(getCurrentDate());
+		return anEntry;
+	}
+	
+	 public static String getCurrentDate() {
+		 return dateFormat.format(new Date());
+	 }
+	
+	public String getLastUseDate() {
+		return lastUseDate;
+	}
+
+	public void setLastUseDate(String lastUseDate) {
+		this.lastUseDate = lastUseDate;
+	}
+
+	public String getCreateDate() {
+		return createDate;
+	}
+
+	public void setCreateDate(String createDate) {
+		this.createDate = createDate;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/dao/BackupFilename.java

@@ -0,0 +1,13 @@
+package com.bwssystems.HABridge.dao;
+
+public class BackupFilename {
+	private String filename;
+
+	public String getFilename() {
+		return filename;
+	}
+
+	public void setFilename(String filename) {
+		this.filename = filename;
+	}
+}

src/main/java/com/bwssystems/HABridge/dao/DeviceDescriptor.java

@@ -0,0 +1,287 @@
+package com.bwssystems.HABridge.dao;
+
+import com.bwssystems.HABridge.api.hue.DeviceState;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/*
+ * Object to handle the device configuration
+ */
+public class DeviceDescriptor{
+	@SerializedName("id")
+	@Expose
+	private String id;
+	@SerializedName("uniqueid")
+	@Expose
+	private String uniqueid;
+	@SerializedName("name")
+	@Expose
+    private String name;
+	@SerializedName("mapId")
+	@Expose
+    private String mapId;
+	@SerializedName("mapType")
+	@Expose
+    private String mapType;
+	@SerializedName("deviceType")
+	@Expose
+    private String deviceType;
+	@SerializedName("targetDevice")
+	@Expose
+    private String targetDevice;
+	@SerializedName("offUrl")
+	@Expose
+    private String offUrl;
+	@SerializedName("dimUrl")
+	@Expose
+    private String dimUrl;
+    @SerializedName("onUrl")
+    @Expose
+    private String onUrl;
+    @SerializedName("headers")
+    @Expose
+    private String headers;
+    @SerializedName("httpVerb")
+    @Expose
+    private String httpVerb;
+    @SerializedName("contentType")
+    @Expose
+    private String contentType;
+    @SerializedName("contentBody")
+    @Expose
+    private String contentBody;
+    @SerializedName("contentBodyOff")
+    @Expose
+    private String contentBodyOff;
+    @SerializedName("contentBodyDim")
+    @Expose
+    private String contentBodyDim;
+    @SerializedName("inactive")
+    @Expose
+    private boolean inactive;
+    @SerializedName("noState")
+    @Expose
+    private boolean noState;
+    @SerializedName("offState")
+    @Expose
+    private boolean offState;
+    @SerializedName("requesterAddress")
+    @Expose
+    private String requesterAddress;
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("comments")
+    @Expose
+    private String comments;
+
+    private DeviceState deviceState;
+    
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getMapId() {
+		return mapId;
+	}
+
+	public void setMapId(String mapId) {
+		this.mapId = mapId;
+	}
+
+	public String getMapType() {
+		return mapType;
+	}
+
+	public void setMapType(String mapType) {
+		this.mapType = mapType;
+	}
+
+	public String getDeviceType() {
+        return deviceType;
+    }
+
+    public void setDeviceType(String deviceType) {
+        this.deviceType = deviceType;
+    }
+
+    public String getTargetDevice() {
+		return targetDevice;
+	}
+
+	public void setTargetDevice(String targetDevice) {
+		this.targetDevice = targetDevice;
+	}
+
+	public String getOffUrl() {
+        return offUrl;
+    }
+
+    public void setOffUrl(String offUrl) {
+        this.offUrl = offUrl;
+    }
+
+    public String getDimUrl() {
+		return dimUrl;
+	}
+
+	public void setDimUrl(String dimUrl) {
+		this.dimUrl = dimUrl;
+	}
+
+	public String getOnUrl() {
+        return onUrl;
+    }
+
+    public void setOnUrl(String onUrl) {
+        this.onUrl = onUrl;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+	public String getUniqueid() {
+		return uniqueid;
+	}
+
+	public void setUniqueid(String uniqueid) {
+		this.uniqueid = uniqueid;
+	}
+
+	public String getHeaders() {
+		return headers;
+	}
+
+	public void setHeaders(String headers) {
+		this.headers = headers;
+	}
+
+	public String getHttpVerb() {
+		return httpVerb;
+	}
+
+	public void setHttpVerb(String httpVerb) {
+		this.httpVerb = httpVerb;
+	}
+
+	public String getContentType() {
+		return contentType;
+	}
+
+	public void setContentType(String contentType) {
+		this.contentType = contentType;
+	}
+
+	public String getContentBody() {
+		return contentBody;
+	}
+
+	public void setContentBody(String contentBody) {
+		this.contentBody = contentBody;
+	}
+
+	public String getContentBodyOff() {
+		return contentBodyOff;
+	}
+
+	public void setContentBodyOff(String contentBodyOff) {
+		this.contentBodyOff = contentBodyOff;
+	}
+
+	public String getContentBodyDim() {
+		return contentBodyDim;
+	}
+
+	public void setContentBodyDim(String contentBodyDim) {
+		this.contentBodyDim = contentBodyDim;
+	}
+
+	public DeviceState getDeviceState() {
+		if(deviceState == null)
+			deviceState = DeviceState.createDeviceState();
+		return deviceState;
+	}
+
+	public void setDeviceState(DeviceState deviceState) {
+		this.deviceState = deviceState;
+	}
+
+	public boolean isInactive() {
+		return inactive;
+	}
+
+	public void setInactive(boolean inactive) {
+		this.inactive = inactive;
+	}
+
+	public boolean isNoState() {
+		return noState;
+	}
+
+	public void setNoState(boolean noState) {
+		this.noState = noState;
+	}
+
+	public boolean isOffState() {
+		return offState;
+	}
+
+	public void setOffState(boolean offState) {
+		this.offState = offState;
+	}
+
+	public String getRequesterAddress() {
+		return requesterAddress;
+	}
+
+	public void setRequesterAddress(String requesterAddress) {
+		this.requesterAddress = requesterAddress;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	public String getComments() {
+		return comments;
+	}
+
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	public boolean containsType(String aType) {
+		if(aType == null)
+			return false;
+		
+		if(this.mapType != null && this.mapType.contains(aType))
+			return true;
+		
+		if(this.deviceType != null && this.deviceType.contains(aType))
+			return true;
+		
+		if(this.onUrl != null && this.onUrl.contains(aType))
+			return true;
+		
+		if(this.dimUrl != null && this.dimUrl.contains(aType))
+			return true;
+		
+		if(this.offUrl != null && this.offUrl.contains(aType))
+			return true;
+		
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/dao/DeviceRepository.java

@@ -0,0 +1,225 @@
+package com.bwssystems.HABridge.dao;
+
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.util.BackupHandler;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import java.util.List;
+/*
+ * This is an in memory list to manage the configured devices and saves the list as a JSON string to a file for later  
+ * loading.
+ */
+public class DeviceRepository extends BackupHandler {
+	private Map<String, DeviceDescriptor> devices;
+    private Path repositoryPath;
+	private Gson gson;
+    private Integer nextId;
+    private Logger log = LoggerFactory.getLogger(DeviceRepository.class);
+	
+    public DeviceRepository(String deviceDb) {
+		super();
+		gson =
+                new GsonBuilder()
+                .excludeFieldsWithoutExposeAnnotation()
+                .create();
+		repositoryPath = null;
+		repositoryPath = Paths.get(deviceDb);
+		setupParams(repositoryPath, ".bk", "device.db-");
+		nextId = 0;
+		_loadRepository(repositoryPath);
+	}
+    
+    public void loadRepository() {
+    	if(repositoryPath != null)
+    		_loadRepository(repositoryPath);
+    }
+	private void _loadRepository(Path aPath){
+		String jsonContent = repositoryReader(aPath);
+		devices = new HashMap<String, DeviceDescriptor>();
+		
+		if(jsonContent != null)
+		{
+			DeviceDescriptor list[] = gson.fromJson(jsonContent, DeviceDescriptor[].class);
+			for(int i = 0; i < list.length; i++) {
+				put(list[i].getId(), list[i]);
+				if(Integer.decode(list[i].getId()) > nextId) {
+					nextId = Integer.decode(list[i].getId());
+				}
+			}
+		}    	
+    }
+    
+	public List<DeviceDescriptor> findAll() {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+		return list;
+	}
+
+	public List<DeviceDescriptor> findActive() {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>();
+		for(DeviceDescriptor aDevice : new ArrayList<DeviceDescriptor>(devices.values())) {
+			if(!aDevice.isInactive())
+				list.add(aDevice);
+		}
+		return list;
+	}
+
+	public List<DeviceDescriptor> findAllByRequester(String anAddress) {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+		List<DeviceDescriptor> theReturnList = new ArrayList<DeviceDescriptor>();
+		Iterator<DeviceDescriptor> anIterator = list.iterator();
+		DeviceDescriptor theDevice;
+		String theRequesterAddress;
+
+		HashMap<String,String > addressMap;
+		while (anIterator.hasNext()) {
+			theDevice = anIterator.next();
+			theRequesterAddress = theDevice.getRequesterAddress();
+			addressMap = new HashMap<String, String>();
+			if(theRequesterAddress != null) {
+				if (theRequesterAddress.contains(",")) {
+					String[] theArray = theRequesterAddress.split(",");
+					for (String v : theArray) {
+						addressMap.put(v.trim(), v.trim());
+					}
+				} else
+					addressMap.put(theRequesterAddress, theRequesterAddress);
+			}
+			if (theRequesterAddress == null || theRequesterAddress.length() == 0 || addressMap.containsKey(anAddress))
+				theReturnList.add(theDevice);
+		}
+		return theReturnList;
+	}
+
+	public DeviceDescriptor findOne(String id) {
+    	return devices.get(id);	
+    }
+    
+	private void put(String id, DeviceDescriptor aDescriptor) {
+        devices.put(id, aDescriptor);
+    }
+    
+	public void save(DeviceDescriptor[] descriptors) {
+		String theNames = "";
+		for(int i = 0; i < descriptors.length; i++) {
+	        if(descriptors[i].getId() != null && descriptors[i].getId().length() > 0)
+	        	devices.remove(descriptors[i].getId());
+	        else {
+	        	nextId++;
+	        	descriptors[i].setId(String.valueOf(nextId));
+	        }
+	        if(descriptors[i].getUniqueid() == null || descriptors[i].getUniqueid().length() == 0) {
+	        	BigInteger bigInt = BigInteger.valueOf(Integer.decode(descriptors[i].getId()));
+	        	byte[] theBytes = bigInt.toByteArray();
+	        	String hexValue = DatatypeConverter.printHexBinary(theBytes);
+
+	        	descriptors[i].setUniqueid("00:17:88:5E:D3:" + hexValue + "-" + hexValue);
+	        }
+	        put(descriptors[i].getId(), descriptors[i]);
+	        theNames = theNames + " " + descriptors[i].getName() + ", ";
+		}
+    	String  jsonValue = gson.toJson(findAll());
+        repositoryWriter(jsonValue, repositoryPath);
+        log.debug("Save device(s): " + theNames);
+    }
+    
+	public void renumber() {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+		Iterator<DeviceDescriptor> deviceIterator = list.iterator();
+		Map<String, DeviceDescriptor> newdevices = new HashMap<String, DeviceDescriptor>();;
+		nextId = 0;
+        log.debug("Renumber devices.");
+		while(deviceIterator.hasNext()) {
+        	nextId++;
+			DeviceDescriptor theDevice = deviceIterator.next();
+        	theDevice.setId(String.valueOf(nextId));
+        	BigInteger bigInt = BigInteger.valueOf(nextId);
+        	byte[] theBytes = bigInt.toByteArray();
+        	String hexValue = DatatypeConverter.printHexBinary(theBytes);
+       	
+        	theDevice.setUniqueid("00:17:88:5E:D3:" + hexValue + "-" + hexValue);
+	        newdevices.put(theDevice.getId(), theDevice);
+		}
+        devices = newdevices;
+    	String  jsonValue = gson.toJson(findAll());
+        repositoryWriter(jsonValue, repositoryPath);
+    }
+    
+	public String delete(DeviceDescriptor aDescriptor) {
+        if (aDescriptor != null) {
+        	devices.remove(aDescriptor.getId());
+        	JsonTransformer aRenderer = new JsonTransformer();
+        	String  jsonValue = aRenderer.render(findAll());
+            repositoryWriter(jsonValue, repositoryPath);
+            return "Device with id '" + aDescriptor.getId() + "' deleted";
+        } else {
+            return "Device not found";
+        }
+
+    }
+	
+	private void repositoryWriter(String content, Path filePath) {
+		if(Files.exists(filePath) && !Files.isWritable(filePath)){
+			log.error("Error file is not writable: " + filePath);
+			return;
+		}
+		
+		if(Files.notExists(filePath.getParent())) {
+			try {
+				Files.createDirectories(filePath.getParent());
+			} catch (IOException e) {
+				log.error("Error creating the directory: " + filePath + " message: " + e.getMessage(), e);
+			}
+		}
+
+		try {
+			Path target = null;
+			if(Files.exists(filePath)) {
+				target = FileSystems.getDefault().getPath(filePath.getParent().toString(), "device.db.old");
+				Files.move(filePath, target);
+			}
+			Files.write(filePath, content.getBytes(), StandardOpenOption.CREATE);
+			if(target != null)
+				Files.delete(target);
+		} catch (IOException e) {
+			log.error("Error writing the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+	}
+	
+	private String repositoryReader(Path filePath) {
+
+		String content = null;
+		if(Files.notExists(filePath) || !Files.isReadable(filePath)){
+			log.warn("Error reading the file: " + filePath + " - Does not exist or is not readable. continuing...");
+			return null;
+		}
+
+		
+		try {
+			content = new String(Files.readAllBytes(filePath));
+		} catch (IOException e) {
+			log.error("Error reading the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+		
+		return content;
+	}
+}

src/main/java/com/bwssystems/HABridge/dao/ErrorMessage.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.dao;
+
+public class ErrorMessage {
+	private String message;
+
+	public ErrorMessage(String message) {
+		super();
+		this.message = message;
+	}
+
+	public String getMessage() {
+		return message;
+	}
+
+	public void setMessage(String message) {
+		this.message = message;
+	}
+}

src/main/java/com/bwssystems/HABridge/devicemanagmeent/DeviceResource.java

@@ -0,0 +1,366 @@
+package com.bwssystems.HABridge.devicemanagmeent;
+
+import static spark.Spark.get;
+import static spark.Spark.halt;
+import static spark.Spark.options;
+import static spark.Spark.post;
+import static spark.Spark.put;
+import static spark.Spark.before;
+import static spark.Spark.delete;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.http.HttpStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.HomeManager;
+import com.bwssystems.HABridge.User;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.BackupFilename;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.dao.DeviceRepository;
+import com.bwssystems.HABridge.dao.ErrorMessage;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
+
+/**
+	spark core server for bridge configuration
+ */
+public class DeviceResource {
+    private static final String API_CONTEXT = "/api/devices";
+    private static final Logger log = LoggerFactory.getLogger(DeviceResource.class);
+    private DeviceRepository deviceRepository;
+    private HomeManager homeManager;
+    private BridgeSettings bridgeSettings;
+	private Gson aGsonHandler;
+    private static final Set<String> supportedVerbs = new HashSet<>(Arrays.asList("get", "put", "post"));
+
+	public DeviceResource(BridgeSettings theSettings, HomeManager aHomeManager) {
+		bridgeSettings = theSettings;
+		this.deviceRepository = new DeviceRepository(bridgeSettings.getBridgeSettingsDescriptor().getUpnpDeviceDb());
+		homeManager = aHomeManager;
+		aGsonHandler = new GsonBuilder().create();
+		setupEndpoints();
+	}
+
+	public DeviceRepository getDeviceRepository() {
+		return deviceRepository;
+	}
+
+    private void setupEndpoints() {
+    	log.info("HABridge device management service started.... ");
+		before(API_CONTEXT + "/*", (request, response) -> {
+			// This never gets called as the HueMulator class covers this path. This is here for backup
+			if(bridgeSettings.getBridgeSecurity().isSecure()) {
+					User authUser = bridgeSettings.getBridgeSecurity().getAuthenticatedUser(request);
+					if(authUser == null) {
+						halt(401, "{\"message\":\"User not authenticated\"}");
+					}
+			}
+		});
+	    // http://ip_address:port/api/devices CORS request
+	    options(API_CONTEXT, "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post(API_CONTEXT, "application/json", (request, response) -> {
+	    	log.debug("Create a Device(s) - request body: " + request.body());
+	    	DeviceDescriptor devices[];
+	    	if(request.body().substring(0,1).equalsIgnoreCase("[") == true) {
+	    		devices = new Gson().fromJson(request.body(), DeviceDescriptor[].class);
+	    	}
+	    	else {
+	    		devices = new Gson().fromJson("[" + request.body() + "]", DeviceDescriptor[].class);
+	    	}
+			CallItem[] callItems = null;
+			String errorMessage = null;
+	    	for(int i = 0; i < devices.length; i++) {
+		    	if(devices[i].getContentBody() != null ) {
+		            if (devices[i].getContentType() == null || devices[i].getHttpVerb() == null || !supportedVerbs.contains(devices[i].getHttpVerb().toLowerCase())) {
+		            	response.status(HttpStatus.SC_BAD_REQUEST);
+		            	errorMessage = "Bad http verb in create device(s) for name: " + devices[i].getName() + " with verb: " + devices[i].getHttpVerb();
+						log.debug(errorMessage);
+						return new ErrorMessage(errorMessage);
+		            }
+		        }
+				try {
+					if(devices[i].getOnUrl() != null && !devices[i].getOnUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getOnUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad on URL JSON in create device(s) for name: " + devices[i].getName() + " with on URL: " + devices[i].getOnUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+				try {
+					if(devices[i].getDimUrl() != null && !devices[i].getDimUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getDimUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad dim URL JSON in create device(s) for name: " + devices[i].getName() + " with dim URL: " + devices[i].getDimUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+				try {
+					if(devices[i].getOffUrl() != null && !devices[i].getOffUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getOffUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad off URL JSON in create device(s) for name: " + devices[i].getName() + " with off URL: " + devices[i].getOffUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+	    	}
+
+	    	deviceRepository.save(devices);
+			log.debug("Created a Device(s): " + request.body());
+
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+			response.status(HttpStatus.SC_CREATED);
+
+            return devices;
+	    }, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/:id CORS request
+	    options(API_CONTEXT + "/:id", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	put (API_CONTEXT + "/:id", "application/json", (request, response) -> {
+	    	log.debug("Edit a Device - request body: " + request.body());
+        	DeviceDescriptor device = new Gson().fromJson(request.body(), DeviceDescriptor.class);
+	        if(deviceRepository.findOne(request.params(":id")) == null){
+		    	log.debug("Could not save an edited device, Device Id not found: " + request.params(":id"));
+		    	response.status(HttpStatus.SC_BAD_REQUEST);
+		    	return new ErrorMessage("Could not save an edited device, Device Id not found: " + request.params(":id") + " ");
+	        }
+	        else
+	        {
+				log.debug("Saving an edited Device: " + device.getName());
+
+				if (device.getDeviceType() != null)
+					device.setDeviceType(device.getDeviceType());
+
+				DeviceDescriptor[] theDevices = new DeviceDescriptor[1];
+				theDevices[0] = device;
+				deviceRepository.save(theDevices);
+				response.status(HttpStatus.SC_OK);
+	        }
+	        return device;
+    	}, new JsonTransformer());
+
+    	get (API_CONTEXT, "application/json", (request, response) -> {
+    		List<DeviceDescriptor> deviceList = deviceRepository.findAll();
+	    	log.debug("Get all devices");
+	    	JsonTransformer aRenderer = new JsonTransformer();
+	    	String theStream = aRenderer.render(deviceList);
+	    	log.debug("The Device List: " + theStream);
+			response.status(HttpStatus.SC_OK);
+    		return deviceList;
+    	}, new JsonTransformer());
+
+    	get (API_CONTEXT + "/:id", "application/json", (request, response) -> {
+	    	log.debug("Get a device");
+	        DeviceDescriptor descriptor = deviceRepository.findOne(request.params(":id"));
+	        if(descriptor == null) {
+				response.status(HttpStatus.SC_NOT_FOUND);
+				return new ErrorMessage("Could not find, id: " + request.params(":id") + " ");
+	        }
+	        else
+	        	response.status(HttpStatus.SC_OK);
+	        return descriptor;
+	    }, new JsonTransformer());
+
+    	delete (API_CONTEXT + "/:id", "application/json", (request, response) -> {
+    		String anId = request.params(":id");
+	    	log.debug("Delete a device: " + anId);
+	        DeviceDescriptor deleted = deviceRepository.findOne(anId);
+	        if(deleted == null) {
+				response.status(HttpStatus.SC_NOT_FOUND);
+				return new ErrorMessage("Could not delete, id: " + anId + " not found. ");
+	        }
+	        else
+	        {
+	        	deviceRepository.delete(deleted);
+				response.status(HttpStatus.SC_OK);
+	        }
+	        return null;
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/vera/devices", "application/json", (request, response) -> {
+	    	log.debug("Get vera devices");
+        	response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/vera/scenes", "application/json", (request, response) -> {
+	    	log.debug("Get vera scenes");
+	        response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/harmony/activities", "application/json", (request, response) -> {
+	    	log.debug("Get harmony activities");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/harmony/show", "application/json", (request, response) -> {
+	    	log.debug("Get harmony current activity");
+      		return homeManager.findResource(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]).getItems("current_activity");
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/harmony/devices", "application/json", (request, response) -> {
+	    	log.debug("Get harmony devices");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/nest/items", "application/json", (request, response) -> {
+	    	log.debug("Get nest items");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/hue/devices", "application/json", (request, response) -> {
+	    	log.debug("Get hue items");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/hal/devices", "application/json", (request, response) -> {
+	    	log.debug("Get hal items");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/mqtt/devices", "application/json", (request, response) -> {
+	    	log.debug("Get MQTT brokers");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/hass/devices", "application/json", (request, response) -> {
+	    	log.debug("Get HomeAssistant Clients");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/domoticz/devices", "application/json", (request, response) -> {
+	    	log.debug("Get Domoticz Clients");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/lifx/devices", "application/json", (request, response) -> {
+	    	log.debug("Get LIFX devices");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+		get (API_CONTEXT + "/somfy/devices", "application/json", (request, response) -> {
+			log.debug("Get somfy devices");
+			response.status(HttpStatus.SC_OK);
+			return homeManager.findResource(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex]);
+		}, new JsonTransformer());
+
+		get (API_CONTEXT + "/map/types", "application/json", (request, response) -> {
+	    	log.debug("Get map types");
+	      	return new DeviceMapTypes().getDeviceMapTypes();
+	    }, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/exec/renumber CORS request
+	    options(API_CONTEXT + "/exec/renumber", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (API_CONTEXT + "/exec/renumber", "application/json", (request, response) -> {
+	    	log.debug("Renumber devices.");
+	    	deviceRepository.renumber();
+	        return null;
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/backup/available", "application/json", (request, response) -> {
+        	log.debug("Get backup filenames");
+          	response.status(HttpStatus.SC_OK);
+          	return deviceRepository.getBackups();
+        }, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/backup/create CORS request
+	    options(API_CONTEXT + "/backup/create", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	put (API_CONTEXT + "/backup/create", "application/json", (request, response) -> {
+	    	log.debug("Create backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	BackupFilename returnFilename = new BackupFilename();
+        	returnFilename.setFilename(deviceRepository.backup(aFilename.getFilename()));
+	        return returnFilename;
+    	}, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/backup/delete CORS request
+	    options(API_CONTEXT + "/backup/delete", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (API_CONTEXT + "/backup/delete", "application/json", (request, response) -> {
+	    	log.debug("Delete backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	if(aFilename != null)
+        		deviceRepository.deleteBackup(aFilename.getFilename());
+        	else
+        		log.warn("No filename given for delete backup.");
+	        return null;
+	    }, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/backup/restore CORS request
+	    options(API_CONTEXT + "/backup/restore", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (API_CONTEXT + "/backup/restore", "application/json", (request, response) -> {
+	    	log.debug("Restore backup: " + request.body());
+        	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
+        	if(aFilename != null) {
+        		deviceRepository.restoreBackup(aFilename.getFilename());
+        		deviceRepository.loadRepository();
+        	}
+        	else
+        		log.warn("No filename given for restore backup.");
+	        return null;
+	    }, new JsonTransformer());
+    }
+}

src/main/java/com/bwssystems/HABridge/devicemanagmeent/ResourceHandler.java

@@ -0,0 +1,5 @@
+package com.bwssystems.HABridge.devicemanagmeent;
+
+public interface ResourceHandler {
+	public Object getItems(String type);
+}

src/main/java/com/bwssystems/HABridge/hue/BrightnessDecode.java

@@ -0,0 +1,156 @@
+package com.bwssystems.HABridge.hue;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.lang3.Conversion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import net.java.dev.eval.Expression;
+
+public class BrightnessDecode {
+	private static final Logger log = LoggerFactory.getLogger(BrightnessDecode.class);
+	private static final String INTENSITY_PERCENT = "${intensity.percent}";
+	private static final String INTENSITY_DECIMAL_PERCENT = "${intensity.decimal_percent}";
+	private static final String INTENSITY_BYTE = "${intensity.byte}";
+	private static final String INTENSITY_MATH = "${intensity.math(";
+	private static final String INTENSITY_MATH_VALUE = "X";
+	private static final String INTENSITY_MATH_CLOSE = ")}";
+	private static final String INTENSITY_MATH_CLOSE_HEX = ").hex}";
+	private static final String INTENSITY_PERCENT_HEX = "${intensity.percent.hex}";
+	private static final String INTENSITY_BYTE_HEX = "${intensity.byte.hex}";
+
+	public static int calculateIntensity(int setIntensity, Integer targetBri, Integer targetBriInc) {
+		if (targetBri != null) {
+			setIntensity = targetBri;
+		} else if (targetBriInc != null) {
+			if ((setIntensity + targetBriInc) <= 0)
+				setIntensity = targetBriInc;
+			else if ((setIntensity + targetBriInc) > 254)
+				setIntensity = targetBriInc;
+			else
+				setIntensity = setIntensity + targetBriInc;
+		}
+		return setIntensity;
+	}
+
+	/*
+	 * light weight templating here, was going to use free marker but it was a
+	 * bit too heavy for what we were trying to do.
+	 *
+	 * currently provides: intensity.byte : 0-254 brightness. this is raw from
+	 * the echo intensity.percent : 0-100, adjusted for the vera
+	 * intensity.math(X*1) : where X is the value from the interface call and
+	 * can use net.java.dev.eval math
+	 */
+	public static String replaceIntensityValue(String request, int intensity, boolean isHex) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		String replaceValue = null;
+		String replaceTarget = null;
+		int percentBrightness = (int) Math.round(intensity / 255.0 * 100);
+		float decimalBrightness = (float) (intensity / 255.0);
+		Map<String, BigDecimal> variables = new HashMap<String, BigDecimal>();
+		String mathDescriptor = null;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(INTENSITY_BYTE)) {
+				if (isHex) {
+					replaceValue = convertToHex(intensity);
+				} else {
+					replaceValue = String.valueOf(intensity);
+				}
+				replaceTarget = INTENSITY_BYTE;
+				notDone = true;
+			} else if (request.contains(INTENSITY_BYTE_HEX)) {
+				replaceValue = convertToHex(intensity);
+				replaceTarget = INTENSITY_BYTE_HEX;
+				notDone = true;
+			} else if (request.contains(INTENSITY_PERCENT)) {
+				if (isHex) {
+					replaceValue = convertToHex(percentBrightness);
+				} else {
+					replaceValue = String.valueOf(percentBrightness);
+				}
+				replaceTarget = INTENSITY_PERCENT;
+				notDone = true;
+			} else if (request.contains(INTENSITY_PERCENT_HEX)) {
+				replaceValue = convertToHex(percentBrightness);
+				replaceTarget = INTENSITY_PERCENT_HEX;
+				notDone = true;
+			} else if (request.contains(INTENSITY_DECIMAL_PERCENT)) {
+				replaceValue = String.format("%1.2f", decimalBrightness);
+				replaceTarget = INTENSITY_DECIMAL_PERCENT;
+				notDone = true;
+			} else if (request.contains(INTENSITY_MATH_CLOSE)) {
+				mathDescriptor = request.substring(request.indexOf(INTENSITY_MATH) + INTENSITY_MATH.length(),
+						request.indexOf(INTENSITY_MATH_CLOSE));
+				variables.put(INTENSITY_MATH_VALUE, new BigDecimal(intensity));
+	
+				log.debug("Math eval is: " + mathDescriptor + ", Where " + INTENSITY_MATH_VALUE + " is: "
+						+ String.valueOf(intensity));
+				Integer endResult = calculateMath(variables, mathDescriptor);
+				if(endResult != null) {
+					if (isHex) {
+						replaceValue = convertToHex(endResult);
+					} else {
+						replaceValue = endResult.toString();
+					}
+					replaceTarget = INTENSITY_MATH + mathDescriptor + INTENSITY_MATH_CLOSE;
+					notDone = true;
+				}
+			} else if (request.contains(INTENSITY_MATH_CLOSE_HEX)) {
+				mathDescriptor = request.substring(request.indexOf(INTENSITY_MATH) + INTENSITY_MATH.length(),
+						request.indexOf(INTENSITY_MATH_CLOSE_HEX));
+				variables.put(INTENSITY_MATH_VALUE, new BigDecimal(intensity));
+	
+				Integer endResult = calculateMath(variables, mathDescriptor);
+				if(endResult != null) {
+					if (isHex) {
+						replaceValue = convertToHex(endResult);
+					} else {
+						replaceValue = endResult.toString();
+					}
+					replaceTarget = INTENSITY_MATH + mathDescriptor + INTENSITY_MATH_CLOSE_HEX;
+					notDone = true;
+				}
+			}
+			if(notDone)
+				request = request.replace(replaceTarget, replaceValue);
+		}
+		return request;
+	}
+
+	// Helper Method
+	public static String calculateReplaceIntensityValue(String request, int theIntensity, Integer targetBri, Integer targetBriInc, boolean isHex) {
+		return replaceIntensityValue(request, calculateIntensity(theIntensity, targetBri, targetBriInc), isHex);
+	}
+	
+	// Apache Commons Conversion utils likes little endian too much
+	private static String convertToHex(int theValue) {
+		String destHex = "00";
+		String hexValue = Conversion.intToHex(theValue, 0, destHex, 0, 2);
+		byte[] theBytes = hexValue.getBytes();
+		byte[] newBytes = new byte[2];
+		newBytes[0] = theBytes[1];
+		newBytes[1] = theBytes[0];
+		return new String(newBytes);
+	}
+	
+	private static Integer calculateMath(Map<String, BigDecimal> variables, String mathDescriptor) {
+		Integer endResult = null;
+		try {
+			Expression exp = new Expression(mathDescriptor);
+			BigDecimal result = exp.eval(variables);
+			endResult = Math.round(result.floatValue());
+		} catch (Exception e) {
+			log.warn("Could not execute Math: " + mathDescriptor, e);
+			endResult = null;
+		}
+		return endResult;
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/ColorDecode.java

@@ -0,0 +1,21 @@
+package com.bwssystems.HABridge.hue;
+
+import java.util.List;
+
+public class ColorDecode {
+
+	public static String convertCIEtoRGB(List<Double> xy) {
+		double x;
+		double y;
+		double Y;
+		
+		x = xy.get(0) * 100;
+		y = xy.get(1) * 100;
+		Y= y;
+		double R = 3.240479*((x*Y)/y) + -1.537150*Y + -0.498535*(((1-x-y)*Y)/y);
+		double G = -0.969256*((x*Y)/y) + 1.875992*Y + 0.041556*(((1-x-y)*Y)/y);
+		double B = 0.055648*((x*Y)/y) + -0.204043*Y + 1.057311*(((1-x-y)*Y)/y);
+		
+		return null;
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/DeviceDataDecode.java

@@ -0,0 +1,66 @@
+package com.bwssystems.HABridge.hue;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+
+public class DeviceDataDecode {
+	private static final Logger log = LoggerFactory.getLogger(DeviceDataDecode.class);
+	private static final String DEVICE_ID = "${device.id}";
+	private static final String DEVICE_UNIQUEID = "${device.uniqueid}";
+	private static final String DEVICE_NAME = "${device.name}";
+	private static final String DEVICE_MAPID = "${device.mapId}";
+	private static final String DEVICE_MAPTYPE = "${device.mapType}";
+	private static final String DEVICE_DEVICETYPE = "${device.deviceType}";
+	private static final String DEVICE_TARGETDEVICE = "${device.targetDevice}";
+	
+	public static String replaceDeviceData(String request, DeviceDescriptor device) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(DEVICE_ID)) {
+				request = request.replace(DEVICE_ID, device.getId());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_UNIQUEID)) {
+				request = request.replace(DEVICE_UNIQUEID, device.getUniqueid());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_NAME)) {
+				request = request.replace(DEVICE_NAME, device.getName());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_MAPID)) {
+				request = request.replace(DEVICE_MAPID, device.getMapId());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_MAPTYPE)) {
+				request = request.replace(DEVICE_MAPTYPE, device.getMapType());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_DEVICETYPE)) {
+				request = request.replace(DEVICE_DEVICETYPE, device.getDeviceType());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_TARGETDEVICE)) {
+				request = request.replace(DEVICE_TARGETDEVICE, device.getTargetDevice());
+				notDone = true;
+			}
+			
+			log.debug("Request <<" + request + ">>, not done: " + notDone);
+		}
+		return request;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/hue/HueMulatorHandler.java

@@ -0,0 +1,8 @@
+package com.bwssystems.HABridge.hue;
+
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+
+public interface HueMulatorHandler {
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity, Integer targetBri, Integer targetBriInc, DeviceDescriptor device, String body);
+}

src/main/java/com/bwssystems/HABridge/hue/MultiCommandUtil.java

@@ -0,0 +1,31 @@
+package com.bwssystems.HABridge.hue;
+
+public class MultiCommandUtil {
+	private Integer setCount;
+	private Integer theDelay;
+	private Integer delayDefault;
+
+	public Integer getSetCount() {
+		return setCount;
+	}
+
+	public void setSetCount(Integer setCount) {
+		this.setCount = setCount;
+	}
+
+	public Integer getTheDelay() {
+		return theDelay;
+	}
+
+	public void setTheDelay(Integer theDelay) {
+		this.theDelay = theDelay;
+	}
+
+	public Integer getDelayDefault() {
+		return delayDefault;
+	}
+
+	public void setDelayDefault(Integer delayDefault) {
+		this.delayDefault = delayDefault;
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/TimeDecode.java

@@ -0,0 +1,44 @@
+package com.bwssystems.HABridge.hue;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TimeDecode {
+	private static final Logger log = LoggerFactory.getLogger(TimeDecode.class);
+	private static final String TIME_FORMAT = "${time.format(";
+	private static final String TIME_FORMAT_CLOSE = ")}";
+
+	/*
+	 * light weight templating here, was going to use free marker but it was a
+	 * bit too heavy for what we were trying to do.
+	 *
+	 * currently provides: time format using Java DateTimeFormatter options
+	 */
+	public static String replaceTimeValue(String request) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(TIME_FORMAT)) {
+				String timeFormatDescriptor = request.substring(request.indexOf(TIME_FORMAT) + TIME_FORMAT.length(),
+						request.indexOf(TIME_FORMAT_CLOSE));
+	
+				try {
+					log.debug("Time eval is: " + timeFormatDescriptor);
+				    SimpleDateFormat dateFormat = new SimpleDateFormat(timeFormatDescriptor);
+					request = request.replace(TIME_FORMAT + timeFormatDescriptor + TIME_FORMAT_CLOSE, dateFormat.format(new Date()));
+					notDone = true;
+				} catch (Exception e) {
+					log.warn("Could not format current time: " + timeFormatDescriptor, e);
+				}
+			}
+		}
+		return request;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestHome.java

@@ -0,0 +1,191 @@
+package com.bwssystems.HABridge.plugins.NestBridge;
+
+import java.util.ArrayList;
+import java.util.ListIterator;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.nest.controller.Home;
+import com.bwssystems.nest.controller.Nest;
+import com.bwssystems.nest.controller.NestSession;
+import com.bwssystems.nest.controller.Thermostat;
+import com.bwssystems.nest.protocol.error.LoginException;
+import com.bwssystems.nest.protocol.status.WhereDetail;
+import com.bwssystems.nest.protocol.status.WhereItem;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class NestHome implements com.bwssystems.HABridge.Home {
+    private static final Logger log = LoggerFactory.getLogger(NestHome.class);
+    private NestSession theSession;
+    private Nest theNest;
+    private ArrayList<NestItem> nestItems;
+	private Gson aGsonHandler;
+	private Boolean isFarenheit;
+    private Boolean validNest;
+    
+	public NestHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+	
+	@Override
+	public Object getItems(String type) {
+		if(!validNest)
+			return null;
+		
+		if(nestItems == null) {
+			nestItems = new ArrayList<NestItem>();
+			Set<String> homeNames = theNest.getHomeNames();
+			Home aHome = null;
+			NestItem anItem = null;
+			for(String name : homeNames) {
+				aHome = theNest.getHome(name);
+				anItem = new NestItem();
+				anItem.setId(name);
+				anItem.setName(aHome.getDetail().getName());
+				anItem.setType("Home");
+				anItem.setLocation(aHome.getDetail().getLocation());
+				nestItems.add(anItem);
+			}
+			Thermostat thermo = null;
+			Set<String> thermoNames = theNest.getThermostatNames();
+			for(String name : thermoNames) {
+				thermo = theNest.getThermostat(name);
+				anItem = new NestItem();
+				anItem.setId(name);
+				anItem.setType("Thermostat");
+				String where = null;
+				String homeName= null;
+				Boolean found = false;
+				for(String aHomeName : homeNames) {
+					WhereDetail aDetail = theNest.getWhere(aHomeName);
+					ListIterator<WhereItem> anIterator = aDetail.getWheres().listIterator();
+					while(anIterator.hasNext()) {
+						WhereItem aWhereItem = (WhereItem) anIterator.next();
+						if(aWhereItem.getWhereId().equals(thermo.getDeviceDetail().getWhereId())) {
+							where = aWhereItem.getName();
+							homeName = theNest.getHome(aHomeName).getDetail().getName();
+							found = true;
+							break;
+						}
+					}
+					if(found)
+						break;
+				}
+				anItem.setName(where + "(" + name.substring(name.length() - 4) + ")");
+				anItem.setLocation(where + " - " + homeName);
+				nestItems.add(anItem);
+			}
+		}
+		
+		return nestItems;
+	}
+	
+	@Override
+	public void closeHome() {
+		if(theSession != null) {
+			theNest.endNestSession();
+		}
+		theNest = null;
+		theSession = null;
+		nestItems = null;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		String responseString = null;
+		log.debug("executing HUE api request to set away for nest " + anItem.getType() + ": " + anItem.getItem().toString());
+		if(!validNest) {
+			log.warn("Should not get here, no Nest available");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no Nest available\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";
+		} else if (anItem.getType() != null && anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex])) {
+			NestInstruction homeAway = null;
+			if(anItem.getItem().isJsonObject())
+				homeAway = aGsonHandler.fromJson(anItem.getItem(), NestInstruction.class);
+			else
+				homeAway = aGsonHandler.fromJson(anItem.getItem().getAsString(), NestInstruction.class);
+			theNest.getHome(homeAway.getName()).setAway(homeAway.getAway());
+		} else if (anItem.getType() != null && anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.NEST_THERMO_SET[DeviceMapTypes.typeIndex])) {
+			NestInstruction thermoSetting = null;
+			if(anItem.getItem().isJsonObject())
+				thermoSetting = aGsonHandler.fromJson(anItem.getItem(), NestInstruction.class);
+			else
+				thermoSetting = aGsonHandler.fromJson(anItem.getItem().getAsString(), NestInstruction.class);
+			if (thermoSetting.getControl().equalsIgnoreCase("temp")) {
+				if (targetBri != null) {
+					if (isFarenheit)
+						thermoSetting
+								.setTemp(
+										String.valueOf((Double
+												.parseDouble(BrightnessDecode.calculateReplaceIntensityValue(thermoSetting.getTemp(),
+													intensity, targetBri, targetBriInc, false)) - 32.0) / 1.8));
+					else
+						thermoSetting
+								.setTemp(
+										String.valueOf(Double.parseDouble(BrightnessDecode.calculateReplaceIntensityValue(thermoSetting.getTemp(),
+												intensity, targetBri, targetBriInc, false))));
+					log.debug("Setting thermostat: " + thermoSetting.getName() + " to "
+							+ thermoSetting.getTemp() + "C");
+					theNest.getThermostat(thermoSetting.getName())
+							.setTargetTemperature(Float.parseFloat(thermoSetting.getTemp()));
+				}
+			} else if (thermoSetting.getControl().contains("range")
+					|| thermoSetting.getControl().contains("heat")
+					|| thermoSetting.getControl().contains("cool")
+					|| thermoSetting.getControl().contains("off")) {
+				log.debug("Setting thermostat target type: " + thermoSetting.getName() + " to "
+						+ thermoSetting.getControl());
+				theNest.getThermostat(thermoSetting.getName()).setTargetType(thermoSetting.getControl());
+			} else if (thermoSetting.getControl().contains("fan")) {
+				log.debug("Setting thermostat fan mode: " + thermoSetting.getName() + " to "
+						+ thermoSetting.getControl().substring(4));
+				theNest.getThermostat(thermoSetting.getName())
+						.setFanMode(thermoSetting.getControl().substring(4));
+			} else {
+				log.warn("no valid Nest control info: " + thermoSetting.getControl());
+				responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"no valid Nest control info\", \"parameter\": \"/lights/"
+						+ lightId + "state\"}}]";
+			}
+		}
+		return responseString;
+	}
+
+	@Override
+	public com.bwssystems.HABridge.Home createHome(BridgeSettings bridgeSettings) {
+        theSession = null;
+        theNest = null;
+        nestItems = null;
+        validNest = bridgeSettings.getBridgeSettingsDescriptor().isValidNest();
+		aGsonHandler = null;
+		log.info("Nest Home created." + (validNest ? "" : " No Nest configured."));
+        
+        if(validNest) {
+    		aGsonHandler = new GsonBuilder().create();
+	
+    		isFarenheit = bridgeSettings.getBridgeSettingsDescriptor().isFarenheit();
+	       try {
+	            theSession = new NestSession(bridgeSettings.getBridgeSettingsDescriptor().getNestuser(), bridgeSettings.getBridgeSettingsDescriptor().getNestpwd());
+	        	theNest = new Nest(theSession);
+	        } catch (LoginException e) {
+	            log.error("Caught Login Exception, setting Nest to invalid....");
+	            validNest = false;
+	            theSession = null;
+	        }
+        }
+		return this;
+	}
+}
+

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestInstruction.java

@@ -0,0 +1,33 @@
+package com.bwssystems.HABridge.plugins.NestBridge;
+
+public class NestInstruction {
+	private String name;
+	private Boolean away;
+	private String control;
+	private String temp;
+	
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public Boolean getAway() {
+		return away;
+	}
+	public void setAway(Boolean away) {
+		this.away = away;
+	}
+	public String getControl() {
+		return control;
+	}
+	public void setControl(String control) {
+		this.control = control;
+	}
+	public String getTemp() {
+		return temp;
+	}
+	public void setTemp(String temp) {
+		this.temp = temp;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestItem.java

@@ -0,0 +1,41 @@
+package com.bwssystems.HABridge.plugins.NestBridge;
+
+import java.io.UnsupportedEncodingException;
+
+public class NestItem {
+	private String name;
+	private String id;
+	private String type;
+	private String location;
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		byte ptext[];
+		String theLabel = new String(name);
+		try {
+			ptext = theLabel.getBytes("ISO-8859-1");
+			this.name = new String(ptext, "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			this.name = theLabel;
+		}
+	}
+	public String getId() {
+		return id;
+	}
+	public void setId(String anid) {
+		id = anid;
+	}
+	public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public String getLocation() {
+		return location;
+	}
+	public void setLocation(String location) {
+		this.location = location;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DeviceResult.java

@@ -0,0 +1,55 @@
+
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceResult {
+    @SerializedName("Description")
+    @Expose
+    private String description;
+    @SerializedName("Name")
+    @Expose
+    private String name;
+    @SerializedName("Type")
+    @Expose
+    private String type;
+    @SerializedName("idx")
+    @Expose
+    private String idx;
+
+
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getIdx() {
+        return idx;
+    }
+
+    public void setIdx(String idx) {
+        this.idx = idx;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/Devices.java

@@ -0,0 +1,99 @@
+
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.List;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Devices {
+
+    @SerializedName("ActTime")
+    @Expose
+    private Integer actTime;
+    @SerializedName("AllowWidgetOrdering")
+    @Expose
+    private Boolean allowWidgetOrdering;
+    @SerializedName("ServerTime")
+    @Expose
+    private String serverTime;
+    @SerializedName("Sunrise")
+    @Expose
+    private String sunrise;
+    @SerializedName("Sunset")
+    @Expose
+    private String sunset;
+    @SerializedName("result")
+    @Expose
+    private List<DeviceResult> result = null;
+    @SerializedName("status")
+    @Expose
+    private String status;
+    @SerializedName("title")
+    @Expose
+    private String title;
+
+    public Integer getActTime() {
+        return actTime;
+    }
+
+    public void setActTime(Integer actTime) {
+        this.actTime = actTime;
+    }
+
+    public Boolean getAllowWidgetOrdering() {
+        return allowWidgetOrdering;
+    }
+
+    public void setAllowWidgetOrdering(Boolean allowWidgetOrdering) {
+        this.allowWidgetOrdering = allowWidgetOrdering;
+    }
+
+    public String getServerTime() {
+        return serverTime;
+    }
+
+    public void setServerTime(String serverTime) {
+        this.serverTime = serverTime;
+    }
+
+    public String getSunrise() {
+        return sunrise;
+    }
+
+    public void setSunrise(String sunrise) {
+        this.sunrise = sunrise;
+    }
+
+    public String getSunset() {
+        return sunset;
+    }
+
+    public void setSunset(String sunset) {
+        this.sunset = sunset;
+    }
+
+    public List<DeviceResult> getResult() {
+        return result;
+    }
+
+    public void setResult(List<DeviceResult> result) {
+        this.result = result;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzDevice.java

@@ -0,0 +1,39 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+public class DomoticzDevice {
+	private String devicetype;
+	private String devicename;
+	private String idx;
+	private String domoticzaddress;
+	private String domoticzname;
+	public String getDevicetype() {
+		return devicetype;
+	}
+	public void setDevicetype(String devicetype) {
+		this.devicetype = devicetype;
+	}
+	public String getDevicename() {
+		return devicename;
+	}
+	public void setDevicename(String devicename) {
+		this.devicename = devicename;
+	}
+	public String getIdx() {
+		return idx;
+	}
+	public void setIdx(String idx) {
+		this.idx = idx;
+	}
+	public String getDomoticzaddress() {
+		return domoticzaddress;
+	}
+	public void setDomoticzaddress(String domoticzaddress) {
+		this.domoticzaddress = domoticzaddress;
+	}
+	public String getDomoticzname() {
+		return domoticzname;
+	}
+	public void setDomoticzname(String domoticzname) {
+		this.domoticzname = domoticzname;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzHandler.java

@@ -0,0 +1,121 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Base64;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+public class DomoticzHandler {
+    private static final Logger log = LoggerFactory.getLogger(DomoticzHandler.class);
+    private static final String GET_REQUEST = "/json.htm?type=";
+    private static final String DEVICES_TYPE = "devices";
+    private static final String SCENES_TYPE = "scenes";
+    private static final String FILTER_USED = "&used=true";
+    private NamedIP domoticzAddress;
+
+    public DomoticzHandler(NamedIP addressName) {
+		super();
+        domoticzAddress = addressName;
+	}
+
+	public List<DomoticzDevice> getDevices(HTTPHandler httpClient) {
+    	return getDomoticzDevices(GET_REQUEST, DEVICES_TYPE, FILTER_USED, httpClient);
+    }
+
+	public List<DomoticzDevice> getScenes(HTTPHandler httpClient) {
+    	return getDomoticzDevices(GET_REQUEST, SCENES_TYPE, null, httpClient);
+    }
+
+	private List<DomoticzDevice> getDomoticzDevices(String rootRequest, String type, String postpend, HTTPHandler httpClient) {
+		Devices theDomoticzApiResponse = null;
+		List<DomoticzDevice> deviceList = null;
+
+		String theUrl = null;
+    	String theData;
+    	if(postpend != null && !postpend.isEmpty())
+    		theUrl = buildUrl(rootRequest + type + postpend);
+    	else
+    		theUrl = buildUrl(rootRequest + type);
+   		theData = httpClient.doHttpRequest(theUrl, null, null, null, buildHeaders());
+    	if(theData != null) {
+    		log.debug("GET " + type + " DomoticzApiResponse - data: " + theData);
+	    	theDomoticzApiResponse = new Gson().fromJson(theData, Devices.class);
+	    	if(theDomoticzApiResponse.getResult() == null) {
+    			log.warn("Cannot get any devices for type " + type + " for Domoticz " + domoticzAddress.getName() + " as response is not parsable.");
+	        	return deviceList;
+	    	}
+	    	deviceList = new ArrayList<DomoticzDevice>();
+	    	
+	    	Iterator<DeviceResult> theDeviceNames = theDomoticzApiResponse.getResult().iterator();
+	    	while(theDeviceNames.hasNext()) {
+	    		DeviceResult theDevice = theDeviceNames.next();
+				DomoticzDevice aNewDomoticzDevice = new DomoticzDevice();
+				aNewDomoticzDevice.setDevicetype(theDevice.getType());
+				aNewDomoticzDevice.setDevicename(theDevice.getName());
+				aNewDomoticzDevice.setIdx(theDevice.getIdx());
+				aNewDomoticzDevice.setDomoticzaddress(domoticzAddress.getIp() + ":" + domoticzAddress.getPort());
+				aNewDomoticzDevice.setDomoticzname(domoticzAddress.getName());
+				deviceList.add(aNewDomoticzDevice);
+	    		
+	    	}
+    	}
+    	else {
+    		log.warn("Get Domoticz device types " + type + " for " + domoticzAddress.getName() + " - returned null, no data.");
+    	}
+    	return deviceList;
+    }
+
+	public String buildUrl(String thePayload) {
+		String newUrl = null;
+		
+		if(thePayload != null && !thePayload.isEmpty()) {
+			if(domoticzAddress.getSecure() != null && domoticzAddress.getSecure())
+				newUrl = "https://";
+			else
+				newUrl = "http://";
+			
+			newUrl = newUrl + domoticzAddress.getIp();
+			
+			if(domoticzAddress.getPort() != null && !domoticzAddress.getPort().isEmpty())
+				newUrl = newUrl + ":" + domoticzAddress.getPort();
+
+			if(thePayload.startsWith("/"))
+				newUrl = newUrl + thePayload;
+			else
+				newUrl = newUrl + "/" + thePayload;
+		}
+		
+		return newUrl;
+	}
+	
+	public NameValue[] buildHeaders() {
+		NameValue[] headers = null;
+		
+		if(domoticzAddress.getUsername() != null && !domoticzAddress.getUsername().isEmpty()
+				&& domoticzAddress.getPassword() != null && !domoticzAddress.getPassword().isEmpty()) {
+			NameValue theAuth = new NameValue();
+			theAuth.setName("Authorization");
+			String encoding = Base64.getEncoder().encodeToString((domoticzAddress.getUsername() + ":" + domoticzAddress.getPassword()).getBytes());
+			theAuth.setValue("Basic " + encoding);
+			headers = new NameValue[1];
+			headers[0] = theAuth;
+		}
+		
+		return headers;
+	}
+	public NamedIP getDomoticzAddress() {
+		return domoticzAddress;
+	}
+
+	public void setDomoticzAddress(NamedIP DomoticzAddress) {
+		this.domoticzAddress = DomoticzAddress;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzHome.java

@@ -0,0 +1,168 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+public class DomoticzHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(DomoticzHome.class);
+	private Map<String, DomoticzHandler> domoticzs;
+	private Boolean validDomoticz;
+    private HTTPHandler httpClient;
+
+	public DomoticzHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(!validDomoticz)
+			return null;
+		log.debug("consolidating devices for hues");
+		List<DomoticzDevice> theResponse = null;
+		Iterator<String> keys = domoticzs.keySet().iterator();
+		List<DomoticzDevice> deviceList = new ArrayList<DomoticzDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = domoticzs.get(key).getDevices(httpClient);
+			if(theResponse != null)
+				addDomoticzDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get lights for Domoticz with name: " + key + ", skipping this Domoticz.");
+				continue;
+			}
+			theResponse = domoticzs.get(key).getScenes(httpClient);
+			if(theResponse != null)
+				addDomoticzDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Scenes for Domoticz with name: " + key);
+		}
+		return deviceList;
+	}
+	
+	private Boolean addDomoticzDevices(List<DomoticzDevice> theDeviceList, List<DomoticzDevice> theSourceList, String theKey) {
+		if(!validDomoticz)
+			return null;
+		Iterator<DomoticzDevice> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			DomoticzDevice theDevice = devices.next();
+			theDeviceList.add(theDevice);
+		}
+		return true;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		Devices theDomoticzApiResponse = null;
+		String responseString = null;
+		
+		String theUrl = anItem.getItem().getAsString();
+		if(theUrl != null && !theUrl.isEmpty () && (theUrl.startsWith("http://") || theUrl.startsWith("https://"))) {
+			String intermediate = theUrl.substring(theUrl.indexOf("://") + 3);
+			String hostPortion = intermediate.substring(0, intermediate.indexOf('/'));
+			String theUrlBody = intermediate.substring(intermediate.indexOf('/') + 1);
+			String hostAddr = null;
+			if (hostPortion.contains(":")) {
+				hostAddr = hostPortion.substring(0, intermediate.indexOf(':'));
+			} else
+				hostAddr = hostPortion;
+			DomoticzHandler theHandler = findHandlerByAddress(hostAddr);
+			if(theHandler != null){
+		    	String theData;
+				String anUrl = BrightnessDecode.calculateReplaceIntensityValue(theUrlBody,
+						intensity, targetBri, targetBriInc, false);
+		   		theData = httpClient.doHttpRequest(theHandler.buildUrl(anUrl), null, null, null, theHandler.buildHeaders());
+		   		try {
+		   			theDomoticzApiResponse = new Gson().fromJson(theData, Devices.class);
+		   			if(theDomoticzApiResponse.getStatus().equals("OK"))
+		   				responseString = null;
+		   			else {
+		    			log.warn("Call failed for Domoticz " + theHandler.getDomoticzAddress().getName() + " with status " + theDomoticzApiResponse.getStatus() + " for item " + theDomoticzApiResponse.getTitle());
+						responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+								"Error on calling url to change device state", "/lights/"
+								+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		   			}
+		   		} catch (Exception e) {
+	    			log.warn("Cannot interrpret result from call for Domoticz " + theHandler.getDomoticzAddress().getName() + " as response is not parsable.");
+					responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+							"Error on calling url to change device state", "/lights/"
+							+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		    	}
+			} else {
+				log.warn("Domoticz Call could not complete, no address found: " + theUrl);
+				responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+						"Error on calling url to change device state", "/lights/"
+						+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+			}
+		} else {
+			log.warn("Domoticz Call to be presented as http(s)://<ip_address>(:<port>)/payload, format of request unknown: " + theUrl);
+			responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+					"Error on calling url to change device state", "/lights/"
+					+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		}
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		validDomoticz = bridgeSettings.getBridgeSettingsDescriptor().isValidDomoticz();
+		log.info("Domoticz Home created." + (validDomoticz ? "" : " No Domoticz devices configured."));
+		if(!validDomoticz)
+			return null;
+        httpClient = new HTTPHandler();
+		domoticzs = new HashMap<String, DomoticzHandler>();
+		Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getDomoticzaddress().getDevices().iterator();
+		while(theList.hasNext()) {
+			NamedIP aDomoticz = theList.next();
+	      	try {
+	      		domoticzs.put(aDomoticz.getName(), new DomoticzHandler(aDomoticz));
+			} catch (Exception e) {
+		        log.error("Cannot get Domoticz client (" + aDomoticz.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+		        return null;
+			}
+		}
+		return this;
+	}
+
+	private DomoticzHandler findHandlerByAddress(String hostAddress) {
+		DomoticzHandler aHandler = null;
+		boolean found = false;
+		Iterator<String> keys = domoticzs.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			aHandler = domoticzs.get(key);
+			if(aHandler != null && aHandler.getDomoticzAddress().getIp().equals(hostAddress)) {
+				found = true;
+				break;
+			}	
+		}
+		if(!found)
+			aHandler = null;
+		return aHandler;
+	}
+	@Override
+	public void closeHome() {
+		if(httpClient != null)
+			httpClient.closeHandler();
+		
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/exec/CommandHome.java

@@ -0,0 +1,96 @@
+package com.bwssystems.HABridge.plugins.exec;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.DeviceDataDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.hue.TimeDecode;
+
+public class CommandHome implements Home {
+	private static final Logger log = LoggerFactory.getLogger(CommandHome.class);
+	private BridgeSettings theSettings;
+
+	public CommandHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int itensity, Integer targetBri, Integer targetBriInc, DeviceDescriptor device, String body) {
+		log.debug("Exec Request called with url: " +  anItem.getItem().getAsString() + " and exec Garden: "  + (theSettings.getBridgeSecurity().getExecGarden() == null ? "not given" : theSettings.getBridgeSecurity().getExecGarden()));
+		String responseString = null;
+		String intermediate;
+		if (anItem.getItem().getAsString().contains("exec://"))
+			intermediate = anItem.getItem().getAsString().substring(anItem.getItem().getAsString().indexOf("://") + 3);
+		else
+			intermediate = anItem.getItem().getAsString();
+		intermediate = BrightnessDecode.calculateReplaceIntensityValue(intermediate, itensity, targetBri, targetBriInc, false);
+		intermediate = DeviceDataDecode.replaceDeviceData(intermediate, device);
+		intermediate = TimeDecode.replaceTimeValue(intermediate);
+		String execGarden = theSettings.getBridgeSecurity().getExecGarden();
+		execGarden = execGarden.trim();
+		if(execGarden != null && !execGarden.isEmpty()) {
+			if(System.getProperty("os.name").toLowerCase().indexOf("win") >= 0)
+				intermediate = execGarden + "\\" + intermediate;
+			else
+				intermediate = execGarden + "/" + intermediate;
+		}
+
+		String anError = doExecRequest(intermediate, lightId);
+		if (anError != null) {
+			responseString = anError;
+		}
+		return responseString;
+	}
+
+	private String doExecRequest(String anItem, String lightId) {
+		log.debug("Executing request: " + anItem);
+		String responseString = null;
+		if (anItem != null && !anItem.equalsIgnoreCase("")) {
+			try {
+				Process p = Runtime.getRuntime().exec(anItem);
+				log.debug("Process running: " + p.isAlive());
+			} catch (IOException e) {
+				log.warn("Could not execute request: " + anItem + " with message: " + e.getMessage());
+				responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"Error on calling out to device\", \"parameter\": \"/lights/" + lightId
+						+ "state\"}}]";
+			}
+		} else {
+			log.warn("Could not execute request. Request is empty.");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Error on calling out to device\", \"parameter\": \"/lights/" + lightId
+					+ "state\"}}]";
+		}
+
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		log.info("Command Home for system program execution created.");
+		this.theSettings = bridgeSettings; 
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		// noop
+		return null;
+	}
+
+	@Override
+	public void closeHome() {
+		// noop
+		
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/DeviceElements.java

@@ -0,0 +1,17 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.List;
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceElements {
+	@SerializedName(value="DeviceElements", alternate={"SceneElements", "GroupElements", "HVACElements", "MacroElements", "IrElements", "IrButtons"})
+	private List<DeviceName> DeviceElements;
+
+	public List<DeviceName> getDeviceElements() {
+		return DeviceElements;
+	}
+
+	public void setDeviceElements(List<DeviceName> deviceElements) {
+		DeviceElements = deviceElements;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/DeviceName.java

@@ -0,0 +1,17 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceName {
+	@SerializedName(value="DeviceName", alternate={"SceneName", "GroupName", "HVACName", "MacroName", "IrName", "IrButton"})
+	private String DeviceName;
+
+	public String getDeviceName() {
+		return DeviceName;
+	}
+
+	public void setDeviceName(String deviceName) {
+		DeviceName = deviceName;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalDevice.java

@@ -0,0 +1,39 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+public class HalDevice {
+	private String haldevicetype;
+	private String haldevicename;
+	private String haladdress;
+	private String halname;
+	private DeviceElements buttons;
+	public String getHaldevicetype() {
+		return haldevicetype;
+	}
+	public void setHaldevicetype(String haldevicetype) {
+		this.haldevicetype = haldevicetype;
+	}
+	public String getHaldevicename() {
+		return haldevicename;
+	}
+	public void setHaldevicename(String haldevicename) {
+		this.haldevicename = haldevicename;
+	}
+	public String getHaladdress() {
+		return haladdress;
+	}
+	public void setHaladdress(String haladdress) {
+		this.haladdress = haladdress;
+	}
+	public String getHalname() {
+		return halname;
+	}
+	public void setHalname(String halname) {
+		this.halname = halname;
+	}
+	public DeviceElements getButtons() {
+		return buttons;
+	}
+	public void setButtons(DeviceElements buttons) {
+		this.buttons = buttons;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalHome.java

@@ -0,0 +1,138 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+
+public class HalHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HalHome.class);
+	private Map<String, HalInfo> hals;
+	private Boolean validHal;
+
+	public HalHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(!validHal)
+			return null;
+		log.debug("consolidating devices for hues");
+		List<HalDevice> theResponse = null;
+		Iterator<String> keys = hals.keySet().iterator();
+		List<HalDevice> deviceList = new ArrayList<HalDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = hals.get(key).getLights();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get lights for Hal with name: " + key + ", skipping this HAL.");
+				continue;
+			}
+			theResponse = hals.get(key).getAppliances();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get appliances for Hal with name: " + key);
+			theResponse = hals.get(key).getTheatre();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get theatre for Hal with name: " + key);
+			theResponse = hals.get(key).getCustom();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get custom for Hal with name: " + key);
+			theResponse = hals.get(key).getHVAC();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get HVAC for Hal with name: " + key);
+			theResponse = hals.get(key).getHome(key);
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Homes for Hal with name: " + key);
+			theResponse = hals.get(key).getGroups();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Groups for Hal with name: " + key);
+			theResponse = hals.get(key).getMacros();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Macros for Hal with name: " + key);
+			theResponse = hals.get(key).getScenes();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Scenes for Hal with name: " + key);
+			theResponse = hals.get(key).getButtons();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Buttons for Hal with name: " + key);
+		}
+		return deviceList;
+	}
+	
+	private Boolean addHalDevices(List<HalDevice> theDeviceList, List<HalDevice> theSourceList, String theKey) {
+		if(!validHal)
+			return null;
+		Iterator<HalDevice> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			HalDevice theDevice = devices.next();
+			theDeviceList.add(theDevice);
+		}
+		return true;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		// Not a device handler
+		return null;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		validHal = bridgeSettings.getBridgeSettingsDescriptor().isValidHal();
+		log.info("HAL Home created." + (validHal ? "" : " No HAL devices configured."));
+		if(!validHal)
+			return null;
+		hals = new HashMap<String, HalInfo>();
+		Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHaladdress().getDevices().iterator();
+		while(theList.hasNext()) {
+			NamedIP aHal = theList.next();
+	      	try {
+	      		hals.put(aHal.getName(), new HalInfo(aHal, bridgeSettings.getBridgeSettingsDescriptor().getHaltoken()));
+			} catch (Exception e) {
+		        log.error("Cannot get hal client (" + aHal.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+		        return null;
+			}
+		}
+		return this;
+	}
+
+	@Override
+	public void closeHome() {
+		// noop
+		
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalInfo.java

@@ -0,0 +1,195 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.bwssystems.HABridge.util.TextStringFormatter;
+import com.google.gson.Gson;
+
+public class HalInfo {
+    private static final Logger log = LoggerFactory.getLogger(HalInfo.class);
+    private static final String DEVICE_REQUEST = "/DeviceData!DeviceCmd=GetNames!DeviceType=";
+    private static final String HVAC_REQUEST = "/HVACData!HVACCmd=GetNames";
+    private static final String GROUP_REQUEST = "/GroupData!GroupCmd=GetNames";
+    private static final String MACRO_REQUEST = "/MacroData!MacroCmd=GetNames";
+    private static final String SCENE_REQUEST = "/SceneData!SceneCmd=GetNames";
+    private static final String IRDATA_REQUEST = "/IrData!IRCmd=GetNames";
+    private static final String IRBUTTON_REQUEST = "/IrData!IRCmd=GetButtons!IrDevice=";
+    private static final String TOKEN_REQUEST = "?Token=";
+    private static final String LIGHT_REQUEST = "Light";
+    private static final String APPL_REQUEST = "Appl";
+    // private static final String VIDEO_REQUEST = "Video";
+    private static final String THEATRE_REQUEST = "Theatre";
+    private static final String CUSTOM_REQUEST = "Custom";
+    private static final String HVAC_TYPE = "HVAC";
+    private static final String HOME_TYPE = "Home";
+    private static final String GROUP_TYPE = "Group";
+    private static final String MACRO_TYPE = "Macro";
+    private static final String SCENE_TYPE = "Scene";
+    private static final String IRDATA_TYPE = "IrData";
+    private HTTPHandler httpClient;
+    private NamedIP halAddress;
+	private String theToken;
+
+    public HalInfo(NamedIP addressName, String aGivenToken) {
+		super();
+        httpClient = new HTTPHandler();
+        halAddress = addressName;
+        theToken = aGivenToken;
+	}
+
+	public List<HalDevice> getLights() {
+    	return getHalDevices(DEVICE_REQUEST + LIGHT_REQUEST + TOKEN_REQUEST, LIGHT_REQUEST);
+    }
+
+	public List<HalDevice> getAppliances() {
+    	return getHalDevices(DEVICE_REQUEST + APPL_REQUEST + TOKEN_REQUEST, APPL_REQUEST);
+    }
+
+	public List<HalDevice> getTheatre() {
+    	return getHalDevices(DEVICE_REQUEST + THEATRE_REQUEST + TOKEN_REQUEST, THEATRE_REQUEST);
+    }
+
+	public List<HalDevice> getCustom() {
+    	return getHalDevices(DEVICE_REQUEST + CUSTOM_REQUEST + TOKEN_REQUEST, CUSTOM_REQUEST);
+    }
+
+	public List<HalDevice> getHVAC() {
+    	return getHalDevices(HVAC_REQUEST + TOKEN_REQUEST, HVAC_TYPE);
+    }
+
+	public List<HalDevice> getGroups() {
+    	return getHalDevices(GROUP_REQUEST + TOKEN_REQUEST, GROUP_TYPE);
+    }
+
+	public List<HalDevice> getMacros() {
+    	return getHalDevices(MACRO_REQUEST + TOKEN_REQUEST, MACRO_TYPE);
+    }
+
+	public List<HalDevice> getScenes() {
+    	return getHalDevices(SCENE_REQUEST + TOKEN_REQUEST, SCENE_TYPE);
+    }
+
+	public List<HalDevice> getButtons() {
+		 List<HalDevice> irDataDevices = getHalDevices(IRDATA_REQUEST + TOKEN_REQUEST, IRDATA_TYPE);
+		 
+		 return getDeviceButtons(irDataDevices);
+    }
+
+	public List<HalDevice> getHome(String theDeviceName) {
+		List<HalDevice> deviceList = null;
+    	deviceList = new ArrayList<HalDevice>();
+		HalDevice aNewHalDevice = new HalDevice();
+		aNewHalDevice.setHaldevicetype(HOME_TYPE);
+		aNewHalDevice.setHaldevicename(theDeviceName);
+		deviceList.add(aNewHalDevice);
+    	return deviceList;
+    }
+
+	private List<HalDevice> getHalDevices(String apiType, String deviceType) {
+		DeviceElements theHalApiResponse = null;
+		List<HalDevice> deviceList = null;
+
+		String theUrl = null;
+    	String theData;
+   		theUrl = "http://" + halAddress.getIp() + apiType + theToken;
+   		theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+    	if(theData != null) {
+    		log.debug("GET " + deviceType + " HalApiResponse - data: " + theData);
+	    	theHalApiResponse = new Gson().fromJson(theData, DeviceElements.class);
+	    	if(theHalApiResponse.getDeviceElements() == null) {
+	    		StatusDescription theStatus = new Gson().fromJson(theData, StatusDescription.class);
+	    		if(theStatus.getStatus() == null) {
+	    			log.warn("Cannot get an devices for type " + deviceType + " for hal " + halAddress.getName() + " as response is not parsable.");
+	    		}
+	    		else {
+	    			log.warn("Cannot get an devices for type " + deviceType + " for hal " + halAddress.getName() + ". Status: " + theStatus.getStatus() + ", with description: " + theStatus.getDescription());
+	    		}
+	        	return deviceList;
+	    	}
+	    	deviceList = new ArrayList<HalDevice>();
+	    	
+	    	Iterator<DeviceName> theDeviceNames = theHalApiResponse.getDeviceElements().iterator();
+	    	while(theDeviceNames.hasNext()) {
+	    		DeviceName theDevice = theDeviceNames.next();
+				HalDevice aNewHalDevice = new HalDevice();
+				aNewHalDevice.setHaldevicetype(deviceType);
+				aNewHalDevice.setHaldevicename(theDevice.getDeviceName());
+				aNewHalDevice.setHaladdress(halAddress.getIp());
+				aNewHalDevice.setHalname(halAddress.getName());
+				deviceList.add(aNewHalDevice);
+	    		
+	    	}
+    	}
+    	else {
+    		log.warn("Get Hal device types " + deviceType + " for " + halAddress.getName() + " - returned null, no data.");
+    	}
+    	return deviceList;
+    }
+
+	private List<HalDevice> getDeviceButtons(List<HalDevice> theIrDevices) {
+		DeviceElements theHalApiResponse = null;
+		List<HalDevice> deviceList = null;
+
+		String theUrl = null;
+		String theData;
+		if(theIrDevices == null)
+			return null;
+		Iterator<HalDevice> theHalDevices = theIrDevices.iterator();
+		deviceList = new ArrayList<HalDevice>();
+		while (theHalDevices.hasNext()) {
+			HalDevice theHalDevice = theHalDevices.next();
+			theUrl = "http://" + halAddress.getIp() + IRBUTTON_REQUEST + TextStringFormatter.forQuerySpaceUrl(theHalDevice.getHaldevicename()) + TOKEN_REQUEST + theToken;
+			theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+			if (theData != null) {
+				log.debug("GET IrData for IR Device " + theHalDevice.getHaldevicename() + " HalApiResponse - data: " + theData);
+				try {
+					theHalApiResponse = new Gson().fromJson(theData, DeviceElements.class);
+				} catch (Exception e) {
+					theHalApiResponse = null;
+				}
+				if (theHalApiResponse == null || theHalApiResponse.getDeviceElements() == null) {
+					StatusDescription theStatus = new Gson().fromJson(theData, StatusDescription.class);
+					if (theStatus.getStatus() == null) {
+						log.warn("Cannot get buttons for IR Device " + theHalDevice.getHaldevicename() + " for hal "
+								+ halAddress.getName() + " as response is not parsable.");
+					} else {
+						log.warn("Cannot get buttons for IR Device " + theHalDevice.getHaldevicename() + " for hal "
+								+ halAddress.getName() + ". Status: " + theStatus.getStatus() + ", with description: "
+								+ theStatus.getDescription());
+					}
+					return deviceList;
+				}
+				theHalDevice.setButtons(theHalApiResponse);
+				deviceList.add(theHalDevice);
+
+			} else {
+				log.warn("Get Hal buttons for IR Device " + theHalDevice.getHaldevicename() + " for "
+						+ halAddress.getName() + " - returned null, no data.");
+			}
+		}
+		return deviceList;
+	}
+
+	public NamedIP getHalAddress() {
+		return halAddress;
+	}
+
+	public void setHalAddress(NamedIP halAddress) {
+		this.halAddress = halAddress;
+	}
+
+	public void closeInfo() {
+		if(httpClient != null)
+			httpClient.closeHandler();
+		httpClient = null;
+		halAddress = null;
+		theToken = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/StatusDescription.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+public class StatusDescription {
+	private String Status;
+	private String Description;
+	public String getStatus() {
+		return Status;
+	}
+	public void setStatus(String status) {
+		Status = status;
+	}
+	public String getDescription() {
+		return Description;
+	}
+	public void setDescription(String description) {
+		Description = description;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/ButtonPress.java

@@ -0,0 +1,46 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+public class ButtonPress {
+	private String device;
+	private String button;
+	private Integer delay;
+	private Integer count;
+	private String hub;
+	public String getDevice() {
+		return device;
+	}
+	public void setDevice(String device) {
+		this.device = device;
+	}
+	public String getButton() {
+		return button;
+	}
+	public void setButton(String button) {
+		this.button = button;
+	}
+	public Integer getDelay() {
+		return delay;
+	}
+	public void setDelay(Integer delay) {
+		this.delay = delay;
+	}
+	public Integer getCount() {
+		return count;
+	}
+	public void setCount(Integer count) {
+		this.count = count;
+	}
+	public Boolean isValid() {
+		if (device != null && !device.isEmpty()){
+			if (button != null && !button.isEmpty())
+				return true;
+		}
+		return false;
+	}
+	public String getHub() {
+		return hub;
+	}
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/DevModeResponse.java

@@ -0,0 +1,69 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.config.Device;
+import net.whistlingfish.harmony.config.HarmonyConfig;
+
+public class DevModeResponse {
+    final Logger log = LoggerFactory.getLogger(DevModeResponse.class);
+
+	private final static String powerOff = "PowerOff";
+	private HarmonyConfig harmonyConfig;
+	private Activity currentActivity;
+
+	public DevModeResponse() {
+		super();
+		harmonyConfig = HarmonyConfig.parse(dataReader("/config.data"));
+		this.currentActivity = harmonyConfig.getActivityByName(powerOff);
+	}
+	
+	public Activity getCurrentActivity() {
+		return currentActivity;
+	}
+	
+	public void setCurrentActivity(Activity currentActivity) {
+		this.currentActivity = currentActivity;
+	}
+	
+	public List<Activity> getActivities() {
+		return harmonyConfig.getActivities();
+	}
+	
+	public List<Device> getDevices() {
+		return harmonyConfig.getDevices();
+	}
+
+	public HarmonyConfig getConfig() {
+		return harmonyConfig;
+	}
+
+	private String dataReader(String filePath) {
+
+		String content = null;
+		try {
+			InputStream input = getClass().getResourceAsStream(filePath);
+			OutputStream out = new ByteArrayOutputStream();
+			int read;
+			byte[] bytes = new byte[1024];
+
+			while ((read = input.read(bytes)) != -1) {
+				out.write(bytes, 0, read);
+			}
+			content = out.toString();
+		} catch (IOException e) {
+			log.error("Error reading the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+		return content;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyActivity.java

@@ -0,0 +1,31 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.io.UnsupportedEncodingException;
+
+import net.whistlingfish.harmony.config.Activity;
+
+public class HarmonyActivity {
+	private String hub;
+	private Activity activity;
+	public String getHub() {
+		return hub;
+	}
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
+	public Activity getActivity() {
+		return activity;
+	}
+	public void setActivity(Activity activity) {
+		byte ptext[];
+		String theLabel = activity.getLabel();
+		try {
+			ptext = theLabel.getBytes("ISO-8859-1");
+			activity.setLabel(new String(ptext, "UTF-8"));
+		} catch (UnsupportedEncodingException e) {
+			activity.setLabel(theLabel);
+		} 
+		this.activity = activity;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyDevice.java

@@ -0,0 +1,30 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.io.UnsupportedEncodingException;
+
+import net.whistlingfish.harmony.config.Device;
+
+public class HarmonyDevice {
+	private Device device;
+	private String hub;
+	public Device getDevice() {
+		return device;
+	}
+	public void setDevice(Device device) {
+		byte ptext[];
+		String theLabel = device.getLabel();
+		try {
+			ptext = theLabel.getBytes("ISO-8859-1");
+			device.setLabel(new String(ptext, "UTF-8"));
+		} catch (UnsupportedEncodingException e) {
+			device.setLabel(theLabel);
+		} 
+		this.device = device;
+	}
+	public String getHub() {
+		return hub;
+	}
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyHandler.java

@@ -0,0 +1,132 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.whistlingfish.harmony.HarmonyClient;
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.config.Device;
+import net.whistlingfish.harmony.config.HarmonyConfig;
+
+public class HarmonyHandler {
+    private static final Logger log = LoggerFactory.getLogger(HarmonyHandler.class);
+    private HarmonyClient harmonyClient;
+    private Boolean noopCalls;
+    private Boolean devMode;
+    private DevModeResponse devResponse;
+
+    public HarmonyHandler(HarmonyClient theClient, Boolean noopCallsSetting, DevModeResponse devResponseSetting) {
+		super();
+		noopCalls = noopCallsSetting;
+		devMode = Boolean.TRUE;
+		devResponse = null;
+		if(devResponseSetting == null)
+			devMode = Boolean.FALSE;
+		else
+			devResponse = devResponseSetting;
+		harmonyClient = theClient;
+	}
+
+    public List<Activity> getActivities() {
+		log.debug("Harmony api activities list requested.");
+        if(devMode)
+        	return devResponse.getActivities();
+
+       	return harmonyClient.getConfig().getActivities();
+    }
+
+	public List<Device> getDevices() {
+		log.debug("Harmony api device list requested.");
+        if(devMode)
+        	return devResponse.getDevices();
+
+       	return harmonyClient.getConfig().getDevices();
+	}
+
+	public HarmonyConfig getConfig() {
+		log.debug("Harmony api config requested.");
+        if(devMode)
+        	return devResponse.getConfig();
+
+		return harmonyClient.getConfig();
+	}
+
+	public Activity getCurrentActivity() {
+		log.debug("Harmony api current sctivity requested.");
+        if(devMode)
+        	return devResponse.getCurrentActivity();
+        
+		return harmonyClient.getCurrentActivity();
+	}
+
+	public Boolean startActivity(RunActivity anActivity) {
+		log.debug("Harmony api start activity requested for: " + anActivity.getName() + " noop mode: " + noopCalls);
+		if (anActivity.isValid()) {
+			try {
+				if (noopCalls || devMode) {
+            		if(devMode)
+            		{
+            			if(anActivity != null)
+            				devResponse.setCurrentActivity(devResponse.getConfig().getActivityByName(anActivity.getName()));
+            		}
+
+					log.info("noop mode: Harmony api start activity requested for: " + anActivity.getName());
+				}
+				else
+					harmonyClient.startActivity(Integer.parseInt(anActivity.getName()));
+			} catch (IllegalArgumentException e) {
+				try {
+					if (!noopCalls)
+						harmonyClient.startActivityByName(anActivity.getName());
+				} catch (IllegalArgumentException ei) {
+					log.error("Error in finding activity: " + anActivity.getName());
+					return false;
+				}
+			}
+		} else {
+			log.error("Error in finding activity: " + anActivity.getName());
+			return false;
+		}
+
+		return true;
+	}
+
+	public Boolean pressButton(ButtonPress aDeviceButton) {
+		log.debug("Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton() + " noop mode: " + noopCalls);
+		if (aDeviceButton.isValid()) {
+			try {
+				if (noopCalls || devMode) {
+					log.info("noop mode: Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton());
+				}
+            	else
+					harmonyClient.pressButton(Integer.parseInt(aDeviceButton.getDevice()), aDeviceButton.getButton());
+				
+			} catch (IllegalArgumentException e) {
+				try {
+					if (!noopCalls)
+						harmonyClient.pressButton(aDeviceButton.getDevice(), aDeviceButton.getButton());
+				} catch (IllegalArgumentException ei) {
+					log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton());
+					return false;
+				}
+			}
+		} else {
+			log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton());
+			return false;
+		}
+
+		return true;
+	}
+
+	public void shutdown() {
+		log.debug("Harmony api shutdown requested.");
+        if(devMode)
+        	return;
+        
+		harmonyClient.disconnect();
+		harmonyClient = null;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyHome.java

@@ -0,0 +1,262 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.IpList;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.config.Device;
+
+public class HarmonyHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HarmonyHome.class);
+	private Map<String, HarmonyServer> hubs;
+	private Boolean isDevMode;
+	private Boolean validHarmony;
+	private Gson aGsonHandler;
+
+	public HarmonyHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public void closeHome() {
+		if(!validHarmony)
+			return;
+		if(isDevMode || hubs == null)
+			return;
+		Iterator<String> keys = hubs.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			hubs.get(key).getMyHarmony().shutdown();
+		}
+		
+		hubs = null;
+	}
+
+	public HarmonyHandler getHarmonyHandler(String aName) {
+		if(!validHarmony)
+			return null;
+		HarmonyHandler aHandler = null;
+		if(aName == null || aName.equals("")) {
+			aName = "default";
+		}
+
+		if(hubs.get(aName) == null) {
+			Set<String> keys = hubs.keySet();
+			if(!keys.isEmpty()) {
+				aHandler = hubs.get(keys.toArray()[0]).getMyHarmony();
+			}
+			else
+				aHandler = null;
+		}
+		else
+			aHandler = hubs.get(aName).getMyHarmony();
+		return aHandler;
+	}
+	
+	public List<HarmonyActivity> getActivities() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyActivity> activityList = new ArrayList<HarmonyActivity>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Iterator<Activity> activities = hubs.get(key).getMyHarmony().getActivities().iterator();
+			while(activities.hasNext()) {
+				HarmonyActivity anActivity = new HarmonyActivity();
+				anActivity.setActivity(activities.next());
+				anActivity.setHub(key);
+				activityList.add(anActivity);
+			}
+		}
+		return activityList;
+	}
+	public List<HarmonyActivity> getCurrentActivities() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyActivity> activityList = new ArrayList<HarmonyActivity>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Activity theActivity = hubs.get(key).getMyHarmony().getCurrentActivity();
+			HarmonyActivity anActivity = new HarmonyActivity();
+			anActivity.setActivity(theActivity);
+			anActivity.setHub(key);
+			activityList.add(anActivity);
+		}
+		return activityList;
+	}
+	public List<HarmonyDevice> getDevices() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyDevice> deviceList = new ArrayList<HarmonyDevice>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Iterator<Device> devices = hubs.get(key).getMyHarmony().getDevices().iterator();
+			while(devices.hasNext()) {
+				HarmonyDevice aDevice = new HarmonyDevice();
+				aDevice.setDevice(devices.next());
+				aDevice.setHub(key);
+				deviceList.add(aDevice);
+			}
+		}
+		return deviceList;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		String responseString = null;
+		log.debug("executing HUE api request to change " + anItem.getType() + " to Harmony: " + device.getName());
+		if(!validHarmony) {
+			log.warn("Should not get here, no harmony configured");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no harmony configured\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";			
+		} else {
+			if(anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]))
+			{
+				RunActivity anActivity = null;
+				if(anItem.getItem().isJsonObject())
+					anActivity = aGsonHandler.fromJson(anItem.getItem(), RunActivity.class);
+				else
+					anActivity = aGsonHandler.fromJson(anItem.getItem().getAsString(), RunActivity.class);
+				if(anActivity.getHub() == null || anActivity.getHub().isEmpty())
+					anActivity.setHub(device.getTargetDevice());
+				HarmonyHandler myHarmony = getHarmonyHandler(anActivity.getHub());
+				if (myHarmony == null) {
+					log.warn("Should not get here, no harmony hub available");
+					responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+							+ "\",\"description\": \"Should not get here, no harmony hub available\", \"parameter\": \"/lights/"
+							+ lightId + "state\"}}]";
+				} else {
+					myHarmony.startActivity(anActivity);
+				}
+			} else if(anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex])) {
+				String url = null;
+				if(anItem.getItem().isJsonObject() || anItem.getItem().isJsonArray()) {
+					url = aGsonHandler.toJson(anItem.getItem());
+				} else
+					url = anItem.getItem().getAsString();
+
+				if (url.substring(0, 1).equalsIgnoreCase("{")) {
+					url = "[" + url + "]";
+				}
+				
+				url = BrightnessDecode.calculateReplaceIntensityValue(url, intensity, targetBri, targetBriInc, false);
+				ButtonPress[] deviceButtons = aGsonHandler.fromJson(url, ButtonPress[].class);
+	        	Integer theCount = 1;
+        		for(int z = 0; z < deviceButtons.length; z++) {
+	        		if(deviceButtons[z].getCount() != null && deviceButtons[z].getCount() > 0)
+	        			theCount = deviceButtons[z].getCount();
+	        		for(int y = 0; y < theCount; y++) {
+	        			if( y > 0 || z > 0) {
+								try {
+									Thread.sleep(aMultiUtil.getTheDelay());
+								} catch (InterruptedException e) {
+									// ignore
+								}
+							}
+							if (anItem.getDelay() != null && anItem.getDelay() > 0)
+								aMultiUtil.setTheDelay(anItem.getDelay());
+							else
+								aMultiUtil.setTheDelay(aMultiUtil.getDelayDefault());
+	    	        	log.debug("pressing button: " + deviceButtons[z].getDevice() + " - " + deviceButtons[z].getButton() + " - iteration: " + String.valueOf(z) + " - count: " + String.valueOf(y));
+	    				if(deviceButtons[z].getHub() == null || deviceButtons[z].getHub().isEmpty())
+	    					deviceButtons[z].setHub(device.getTargetDevice());
+	    				HarmonyHandler myHarmony = getHarmonyHandler(deviceButtons[z].getHub());
+	    				if (myHarmony == null)
+	    					log.warn("Button Press - Should not get here, no harmony hub available");
+	    				else
+	    					myHarmony.pressButton(deviceButtons[z]);
+	        		}
+        		}
+			}
+		}
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+        isDevMode = Boolean.parseBoolean(System.getProperty("dev.mode", "false"));
+        validHarmony = bridgeSettings.getBridgeSettingsDescriptor().isValidHarmony();
+		log.info("Harmony Home created." + (validHarmony ? "" : " No Harmony devices configured.") + (isDevMode ? " DevMode is set." : ""));
+		if(validHarmony || isDevMode) {
+			hubs = new HashMap<String, HarmonyServer>();
+			aGsonHandler =
+					new GsonBuilder()
+					.create();
+			if(isDevMode) {
+				NamedIP devModeIp = new NamedIP();
+				devModeIp.setIp("10.10.10.10");
+				devModeIp.setName("devMode");
+				List<NamedIP> theList = new ArrayList<NamedIP>();
+				theList.add(devModeIp);
+				IpList thedevList = new IpList();
+				thedevList.setDevices(theList);
+				bridgeSettings.getBridgeSettingsDescriptor().setHarmonyAddress(thedevList);
+			}
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHarmonyAddress().getDevices().iterator();
+			while(theList.hasNext() && validHarmony) {
+				NamedIP aHub = theList.next();
+				boolean loopControl = true;
+				int retryCount = 0;
+				while(loopControl) {
+					try {
+			      		hubs.put(aHub.getName(), HarmonyServer.setup(bridgeSettings.getBridgeSettingsDescriptor(), isDevMode, aHub));
+			      		loopControl = false;
+					} catch (Exception e) {
+						if(retryCount > 3) {
+					        log.error("Cannot get harmony client (" + aHub.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+					        loopControl = false;
+						} else {
+							try {
+								Thread.sleep(2000);
+							} catch (InterruptedException e1) {
+								// ignore
+							}
+						}
+							
+						retryCount++;
+					}
+				}
+			}
+			if(hubs.isEmpty())
+				validHarmony = false;
+		}
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(validHarmony) {
+			if(type.equalsIgnoreCase(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]))
+				return getActivities();
+			if(type.equalsIgnoreCase(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]))
+				return getDevices();
+			if(type.equalsIgnoreCase("current_activity"))
+				return getCurrentActivities();
+		}
+		return null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyServer.java

@@ -0,0 +1,117 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import static java.lang.String.format;
+
+import javax.inject.Inject;
+
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import org.apache.http.client.methods.HttpGet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettingsDescriptor;
+import com.bwssystems.HABridge.NamedIP;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
+import net.whistlingfish.harmony.ActivityChangeListener;
+import net.whistlingfish.harmony.HarmonyClient;
+import net.whistlingfish.harmony.HarmonyClientModule;
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.protocol.OAReplyProvider;
+
+import java.net.URLEncoder;
+
+public class HarmonyServer {
+
+    private static final String ACTIVIY_ID = "${activity.id}";
+    private static final String ACTIVIY_LABEL = "${activity.label}";
+
+    @Inject
+    private HarmonyClient harmonyClient;
+
+    private HarmonyHandler myHarmony;
+    private DevModeResponse devResponse;
+    private OAReplyProvider dummyProvider;
+    private NamedIP myNameAndIP;
+    private Boolean isDevMode;
+    private HTTPHandler httpClient;
+    private Logger log = LoggerFactory.getLogger(HarmonyServer.class);
+
+    public HarmonyServer(NamedIP theHarmonyAddress) {
+        super();
+        myHarmony = null;
+        dummyProvider = null;
+        myNameAndIP = theHarmonyAddress;
+        isDevMode = false;
+        httpClient = new HTTPHandler();
+    }
+
+    public static HarmonyServer setup(
+            BridgeSettingsDescriptor bridgeSettings,
+            Boolean harmonyDevMode,
+            NamedIP theHarmonyAddress
+    ) throws Exception {
+        if (!bridgeSettings.isValidHarmony() && harmonyDevMode) {
+            return new HarmonyServer(theHarmonyAddress);
+        }
+        Injector injector = null;
+        if (!harmonyDevMode) {
+            injector = Guice.createInjector(new HarmonyClientModule());
+        }
+        HarmonyServer mainObject = new HarmonyServer(theHarmonyAddress);
+        if (!harmonyDevMode) {
+            injector.injectMembers(mainObject);
+        }
+        mainObject.execute(bridgeSettings, harmonyDevMode);
+        return mainObject;
+    }
+
+    private void execute(BridgeSettingsDescriptor mySettings, Boolean harmonyDevMode) throws Exception {
+        Boolean noopCalls = Boolean.parseBoolean(System.getProperty("noop.calls", "false"));
+        isDevMode = harmonyDevMode;
+        String modeString = "";
+        if (dummyProvider != null) {
+            log.debug("something is very wrong as dummyProvider is not null...");
+        }
+        if (isDevMode) {
+            modeString = " (development mode)";
+        } else if (noopCalls) {
+            modeString = " (no op calls to harmony)";
+        }
+        log.info("setup initiated " + modeString + "....");
+        if (isDevMode) {
+            harmonyClient = null;
+            devResponse = new DevModeResponse();
+        } else {
+            devResponse = null;
+            harmonyClient.addListener(new ActivityChangeListener() {
+                @Override
+                public void activityStarted(Activity activity) {
+                    String webhook = myNameAndIP.getWebhook();
+                    if(webhook != null) {
+                        try {
+                            // Replacing variables
+                            webhook = webhook.replace(ACTIVIY_ID, activity.getId().toString());
+                            webhook = webhook.replace(ACTIVIY_LABEL, URLEncoder.encode(activity.getLabel(), "UTF-8"));
+
+                            log.info(format("calling webhook: %s", webhook));
+
+                            // Calling webhook
+                            httpClient.doHttpRequest(webhook, HttpGet.METHOD_NAME, null, null, null);
+                        } catch (Exception e) {
+                            log.warn("could not call webhook: " + webhook, e);
+                        }
+                    }
+                    log.info(format("activity changed: [%d] %s", activity.getId(), activity.getLabel()));
+                }
+            });
+            harmonyClient.connect(myNameAndIP.getIp());
+        }
+        myHarmony = new HarmonyHandler(harmonyClient, noopCalls, devResponse);
+    }
+
+    public HarmonyHandler getMyHarmony() {
+        return myHarmony;
+    }
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/RunActivity.java

@@ -0,0 +1,27 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+public class RunActivity {
+	private String name;
+	private String hub;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+	public Boolean isValid() {
+		if (name != null && !name.isEmpty())
+			return true;
+		return false;
+	}
+
+	public String getHub() {
+		return hub;
+	}
+
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/Field.java

@@ -0,0 +1,29 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Field {
+
+    @SerializedName("fields")
+    @Expose
+    private Map<String, JsonElement> fields;
+
+	public Field(Map<String, JsonElement> fields) {
+		super();
+		this.fields = fields;
+	}
+
+	public Map<String, JsonElement> getFields() {
+		return fields;
+	}
+
+	public void setFields(Map<String, JsonElement> fields) {
+		this.fields = fields;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/FieldDeserializer.java

@@ -0,0 +1,31 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class FieldDeserializer implements JsonDeserializer<Field> {
+	private Map<String, JsonElement> fields;
+    @Override
+    public Field deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+        JsonObject obj = json.getAsJsonObject();
+        String theKey;
+
+        fields = new HashMap<String, JsonElement>();
+        for(Entry<String, JsonElement> entry:obj.entrySet()){
+        	theKey = entry.getKey();
+            JsonElement theRawDetail = obj.get(theKey);
+            fields.put(theKey, theRawDetail);
+        }
+        
+        return new Field(fields);
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassCommand.java

@@ -0,0 +1,32 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+public class HassCommand {
+	private String entityId;
+	private String hassName;
+	private String state;
+	private String bri;
+	public String getEntityId() {
+		return entityId;
+	}
+	public void setEntityId(String entityId) {
+		this.entityId = entityId;
+	}
+	public String getHassName() {
+		return hassName;
+	}
+	public void setHassName(String hassName) {
+		this.hassName = hassName;
+	}
+	public String getState() {
+		return state;
+	}
+	public void setState(String state) {
+		this.state = state;
+	}
+	public String getBri() {
+		return bri;
+	}
+	public void setBri(String bri) {
+		this.bri = bri;
+	}	
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassDevice.java

@@ -0,0 +1,46 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+public class HassDevice {
+	private State deviceState;
+	private String deviceName;
+	private String domain;
+	private Boolean secure;
+	private String hassaddress;
+	private String hassname;
+	public State getDeviceState() {
+		return deviceState;
+	}
+	public void setDeviceState(State deviceState) {
+		this.deviceState = deviceState;
+	}
+	public String getDeviceName() {
+		return deviceName;
+	}
+	public void setDeviceName(String deviceName) {
+		this.deviceName = deviceName;
+	}
+	public String getDomain() {
+		return domain;
+	}
+	public void setDomain(String domain) {
+		this.domain = domain;
+	}
+	public Boolean getSecure() {
+		return secure;
+	}
+	public void setSecure(Boolean secure) {
+		this.secure = secure;
+	}
+	public String getHassaddress() {
+		return hassaddress;
+	}
+	public void setHassaddress(String hassaddress) {
+		this.hassaddress = hassaddress;
+	}
+	public String getHassname() {
+		return hassname;
+	}
+	public void setHassname(String hassname) {
+		this.hassname = hassname;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassHome.java

@@ -0,0 +1,164 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+
+public class HassHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HassHome.class);
+	private Map<String, HomeAssistant> hassMap;
+	private Boolean validHass;
+	private Gson aGsonHandler;
+	
+	public HassHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		hassMap = null;
+		aGsonHandler = null;
+		validHass = bridgeSettings.getBridgeSettingsDescriptor().isValidHass();
+		log.info("HomeAssistant Home created." + (validHass ? "" : " No HomeAssistants configured."));
+		if(validHass) {
+			hassMap = new HashMap<String,HomeAssistant>();
+			aGsonHandler =
+					new GsonBuilder()
+					.create();
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHassaddress().getDevices().iterator();
+			while(theList.hasNext() && validHass) {
+				NamedIP aHass = theList.next();
+		      	try {
+		      		hassMap.put(aHass.getName(), new HomeAssistant(aHass));
+				} catch (Exception e) {
+			        log.error("Cannot get hass (" + aHass.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+			        validHass = false;
+				}
+			}
+        }
+		return this;
+	}
+
+	public HomeAssistant getHomeAssistant(String aName) {
+		if(!validHass)
+			return null;
+		HomeAssistant aHomeAssistant;
+		if(aName == null || aName.equals("")) {
+			aHomeAssistant = null;
+			log.debug("Cannot get HomeAssistant for name as it is empty.");
+		}
+		else {
+			aHomeAssistant = hassMap.get(aName);
+			log.debug("Retrieved a HomeAssistant for name: " + aName);
+		}
+		return aHomeAssistant;
+	}
+	
+	@Override
+	public Object getItems(String type) {
+		log.debug("consolidating devices for hass");
+		if(!validHass)
+			return null;
+		List<State> theResponse = null;
+		Iterator<String> keys = hassMap.keySet().iterator();
+		List<HassDevice> deviceList = new ArrayList<HassDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = hassMap.get(key).getDevices();
+			if(theResponse != null)
+				addHassDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get devices for HomeAssistant with name: " + key + ", skipping this Hass.");
+				continue;
+			}
+		}
+		return deviceList;
+	}
+
+	private Boolean addHassDevices(List<HassDevice> theDeviceList, List<State> theSourceList, String theKey) {
+		if(!validHass)
+			return null;
+		Iterator<State> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			State theDevice = devices.next();
+			HassDevice aNewHassDevice = new HassDevice();
+			aNewHassDevice.setDeviceState(theDevice);
+			aNewHassDevice.setHassaddress(hassMap.get(theKey).getHassAddress().getIp());
+			aNewHassDevice.setHassname(theKey);
+			JsonElement friendlyName = theDevice.getAttributes().get("friendly_name");
+			if(friendlyName == null)
+				aNewHassDevice.setDeviceName(theDevice.getEntityId());
+			else
+				aNewHassDevice.setDeviceName(friendlyName.getAsString());
+			aNewHassDevice.setDomain(theDevice.getEntityId().substring(0, theDevice.getEntityId().indexOf(".")));
+			theDeviceList.add(aNewHassDevice);
+		}
+		return true;
+	}
+	
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		String theReturn = null;
+		log.debug("executing HUE api request to send message to HomeAssistant: " + anItem.getItem().toString());
+		if(!validHass) {
+			log.warn("Should not get here, no HomeAssistant clients configured");
+			theReturn = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no HomeAssistants configured\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";
+
+		} else {
+			HassCommand hassCommand = null;
+			if(anItem.getItem().isJsonObject())
+				hassCommand = aGsonHandler.fromJson(anItem.getItem(), HassCommand.class);
+			else
+				hassCommand = aGsonHandler.fromJson(anItem.getItem().getAsString(), HassCommand.class);
+			hassCommand.setBri(BrightnessDecode.replaceIntensityValue(hassCommand.getBri(),
+								BrightnessDecode.calculateIntensity(intensity, targetBri, targetBriInc), false));
+			HomeAssistant homeAssistant = getHomeAssistant(hassCommand.getHassName());
+			if (homeAssistant == null) {
+				log.warn("Should not get here, no HomeAssistants available");
+				theReturn = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"Should not get here, no HiomeAssistant clients available\", \"parameter\": \"/lights/"
+						+ lightId + "state\"}}]";
+			} else {
+					log.debug("calling HomeAssistant: " + hassCommand.getHassName() + " - "
+							+ hassCommand.getEntityId() + " - " + hassCommand.getState() + " - " + hassCommand.getBri());
+					homeAssistant.callCommand(hassCommand);
+			}
+		}
+		return theReturn;
+	}
+
+	@Override
+	public void closeHome() {
+		if(!validHass)
+			return;
+		if(hassMap == null)
+			return;
+		Iterator<String> keys = hassMap.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			hassMap.get(key).closeClient();
+		}
+		
+		hassMap = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HomeAssistant.java

@@ -0,0 +1,115 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+public class HomeAssistant {
+    private static final Logger log = LoggerFactory.getLogger(HomeAssistant.class);
+    private NamedIP hassAddress;
+    private HTTPHandler anHttpHandler;
+
+	public HomeAssistant(NamedIP addressName) {
+		super();
+		anHttpHandler = new HTTPHandler();
+        hassAddress = addressName;
+	}
+
+	public NamedIP getHassAddress() {
+		return hassAddress;
+	}
+
+	public void setHassAddress(NamedIP hassAddress) {
+		this.hassAddress = hassAddress;
+	}
+
+	public Boolean callCommand(HassCommand aCommand) {
+		log.debug("calling HomeAssistant: " + aCommand.getHassName() + " - "
+				+ aCommand.getEntityId() + " - " + aCommand.getState() + " - " + aCommand.getBri());
+		String aUrl = null;
+		if(hassAddress.getSecure() != null && hassAddress.getSecure())
+			aUrl = "https";
+		else
+			aUrl = "http";
+		String domain = aCommand.getEntityId().substring(0, aCommand.getEntityId().indexOf("."));
+		aUrl = aUrl + "://" + hassAddress.getIp() + ":" + hassAddress.getPort() + "/api/services/";
+		if(domain.equals("group"))
+			aUrl = aUrl + "homeassistant";
+		else
+			aUrl = aUrl + domain;
+		String aBody = "{\"entity_id\":\"" + aCommand.getEntityId() + "\"";
+		NameValue[] headers = null;
+		if(hassAddress.getPassword() != null && !hassAddress.getPassword().isEmpty()) {
+			NameValue password = new NameValue();
+			password.setName("x-ha-access");
+			password.setValue(hassAddress.getPassword());
+			headers = new NameValue[1];
+			headers[0] = password;
+		}
+		if(aCommand.getState().equalsIgnoreCase("on")) {
+			aUrl = aUrl + "/turn_on";
+			if(aCommand.getBri() != null)
+				aBody = aBody + ",\"brightness\":" + aCommand.getBri() + "}";
+			else
+				aBody = aBody + "}";
+		}
+		else {
+			aUrl = aUrl + "/turn_off";
+			aBody = aBody + "}";			
+		}
+		log.debug("Calling HomeAssistant with url: " + aUrl);
+   		String theData = anHttpHandler.doHttpRequest(aUrl, HttpPost.METHOD_NAME, "application/json", aBody, headers);
+   		log.debug("call Command return is: <" + theData + ">");
+		return true;
+	}
+
+	public List<State> getDevices() {
+		List<State> theDeviceStates = null;
+		State[] theHassStates;
+		String theUrl = null;
+    	String theData;
+		NameValue[] headers = null;
+		if(hassAddress.getPassword() != null && !hassAddress.getPassword().isEmpty()) {
+			NameValue password = new NameValue();
+			password.setName("x-ha-access");
+			password.setValue(hassAddress.getPassword());
+			headers = new NameValue[1];
+			headers[0] = password;
+		}
+		if(hassAddress.getSecure() != null && hassAddress.getSecure())
+			theUrl = "https";
+		else
+			theUrl = "http";
+   		theUrl = theUrl + "://" + hassAddress.getIp() + ":" + hassAddress.getPort() + "/api/states";
+   		theData = anHttpHandler.doHttpRequest(theUrl, HttpGet.METHOD_NAME, "application/json", null, headers);
+    	if(theData != null) {
+    		log.debug("GET Hass States - data: " + theData);
+    		theHassStates = new Gson().fromJson(theData, State[].class);
+	    	if(theHassStates == null) {
+	    		log.warn("Cannot get an devices for HomeAssistant " + hassAddress.getName() + " as response is not parsable.");
+	    	}
+	    	else {
+	    		theDeviceStates = new ArrayList<State>(Arrays.asList(theHassStates));
+	    	}
+    	}
+    	else
+    		log.warn("Cannot get an devices for HomeAssistant " + hassAddress.getName() + " http call failed.");
+		return theDeviceStates;
+	}
+
+	
+	protected void closeClient() {
+		anHttpHandler.closeHandler();
+		anHttpHandler = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/Service.java

@@ -0,0 +1,60 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Service {
+
+    @SerializedName("domain")
+    @Expose
+    private String domain;
+    @SerializedName("services")
+    @Expose
+    private Map<String, ServiceElement> services;
+
+    public Service(String domain, Map<String, ServiceElement> services) {
+		super();
+		this.domain = domain;
+		this.services = services;
+	}
+
+	/**
+     * 
+     * @return
+     *     The domain
+     */
+    public String getDomain() {
+        return domain;
+    }
+
+    /**
+     * 
+     * @param domain
+     *     The domain
+     */
+    public void setDomain(String domain) {
+        this.domain = domain;
+    }
+
+    /**
+     * 
+     * @return
+     *     The services
+     */
+	public Map<String, ServiceElement> getServices() {
+		return services;
+	}
+
+    /**
+     * 
+     * @param domain
+     *     The services
+     */
+	public void setServices(Map<String, ServiceElement> services) {
+		this.services = services;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/ServiceDeserializer.java

@@ -0,0 +1,36 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class ServiceDeserializer implements JsonDeserializer<Service> {
+	private Map<String, ServiceElement> services;
+	private String domain;
+    @Override
+    public Service deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+        JsonObject objServices = json.getAsJsonObject();
+        String theKey;
+        domain = objServices.get("domain").getAsString();
+        JsonObject obj = objServices.get("services").getAsJsonObject();
+        services = new HashMap<String, ServiceElement>();
+        for(Entry<String, JsonElement> entry:obj.entrySet()){
+        	ServiceElement theServiceElement = new ServiceElement();
+        	theKey = entry.getKey();
+	            JsonObject theRawDetail = obj.getAsJsonObject(theKey);
+	            
+	            theServiceElement.setDescription(theRawDetail.get("description").getAsString());
+	            theServiceElement.setField(ctx.deserialize(theRawDetail.get("fields"), Field.class));
+	            services.put(theKey, theServiceElement);
+        } 
+        return new Service(domain, services);
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/ServiceElement.java

@@ -0,0 +1,52 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class ServiceElement {
+
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("fields")
+    @Expose
+    private Field fields;
+
+    /**
+     * 
+     * @return
+     *     The description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * 
+     * @param description
+     *     The description
+     */
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    /**
+     * 
+     * @return
+     *     The fields
+     */
+    public Field getFields() {
+        return fields;
+    }
+
+    /**
+     * 
+     * @param fields
+     *     The fields
+     */
+    public void setField(Field fields) {
+        this.fields = fields;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/State.java

@@ -0,0 +1,117 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class State {
+
+@SerializedName("attributes")
+@Expose
+private Map<String, JsonElement>  attributes;
+@SerializedName("entity_id")
+@Expose
+private String entityId;
+@SerializedName("last_changed")
+@Expose
+private String lastChanged;
+@SerializedName("last_updated")
+@Expose
+private String lastUpdated;
+@SerializedName("state")
+@Expose
+private String state;
+
+/**
+* 
+* @return
+* The attributes
+*/
+public Map<String, JsonElement>  getAttributes() {
+return attributes;
+}
+
+/**
+* 
+* @param attributes
+* The attributes
+*/
+public void setAttributes(Map<String, JsonElement>  attributes) {
+this.attributes = attributes;
+}
+
+/**
+* 
+* @return
+* The entityId
+*/
+public String getEntityId() {
+return entityId;
+}
+
+/**
+* 
+* @param entityId
+* The entity_id
+*/
+public void setEntityId(String entityId) {
+this.entityId = entityId;
+}
+
+/**
+* 
+* @return
+* The lastChanged
+*/
+public String getLastChanged() {
+return lastChanged;
+}
+
+/**
+* 
+* @param lastChanged
+* The last_changed
+*/
+public void setLastChanged(String lastChanged) {
+this.lastChanged = lastChanged;
+}
+
+/**
+* 
+* @return
+* The lastUpdated
+*/
+public String getLastUpdated() {
+return lastUpdated;
+}
+
+/**
+* 
+* @param lastUpdated
+* The last_updated
+*/
+public void setLastUpdated(String lastUpdated) {
+this.lastUpdated = lastUpdated;
+}
+
+/**
+* 
+* @return
+* The state
+*/
+public String getState() {
+return state;
+}
+
+/**
+* 
+* @param state
+* The state
+*/
+public void setState(String state) {
+this.state = state;
+}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/http/HTTPHandler.java

@@ -0,0 +1,159 @@
+package com.bwssystems.HABridge.plugins.http;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.config.CookieSpecs;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.api.NameValue;
+
+public class HTTPHandler {
+	private static final Logger log = LoggerFactory.getLogger(HTTPHandler.class);
+	private CloseableHttpClient httpClient;
+	private RequestConfig globalConfig;
+	
+	
+	public HTTPHandler() {
+		globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build();
+		httpClient = HttpClients.custom().setDefaultRequestConfig(globalConfig).build();
+	}
+
+
+	// This function executes the url from the device repository against the
+	// target as http or https as defined
+	public String doHttpRequest(String url, String httpVerb, String contentType, String body, NameValue[] headers) {
+		log.debug("doHttpRequest with url: " + url + " with http command: " + httpVerb + " with body: " + body);
+		HttpUriRequest request = null;
+		String theContent = null;
+		URI theURI = null;
+		ContentType parsedContentType = null;
+		StringEntity requestBody = null;
+		if (contentType != null && !contentType.trim().isEmpty()) {
+			parsedContentType = ContentType.parse(contentType);
+			if (body != null && body.length() > 0)
+				requestBody = new StringEntity(body, parsedContentType);
+		}
+		try {
+			theURI = new URI(url);
+		} catch (URISyntaxException e1) {
+			log.warn("Error creating URI http request: " + url + " with message: " + e1.getMessage());
+			return null;
+		}
+		try {
+			if (httpVerb == null || httpVerb.trim().isEmpty() || HttpGet.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				request = new HttpGet(theURI);
+			} else if (HttpPost.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				HttpPost postRequest = new HttpPost(theURI);
+				if (requestBody != null)
+					postRequest.setEntity(requestBody);
+				request = postRequest;
+			} else if (HttpPut.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				HttpPut putRequest = new HttpPut(theURI);
+				if (requestBody != null)
+					putRequest.setEntity(requestBody);
+				request = putRequest;
+			}
+			else
+				request = new HttpGet(theURI);
+
+		} catch (IllegalArgumentException e) {
+			log.warn("Error creating outbound http request: IllegalArgumentException in log", e);
+			return null;
+		}
+		log.debug("Making outbound call in doHttpRequest: " + request);
+		if (headers != null && headers.length > 0) {
+			for (int i = 0; i < headers.length; i++) {
+				request.setHeader(headers[i].getName(), headers[i].getValue());
+			}
+		}
+		HttpResponse response;
+		try {
+			for(int retryCount = 0; retryCount < 2; retryCount++) {
+				response = httpClient.execute(request);
+				log.debug((httpVerb == null ? "GET" : httpVerb) + " execute (" + retryCount + ") on URL responded: "
+						+ response.getStatusLine().getStatusCode());
+				if (response.getStatusLine().getStatusCode() >= 200 && response.getStatusLine().getStatusCode() < 300) {
+					if (response.getEntity() != null) {
+						try {
+							theContent = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8")); // read
+																												// content
+																												// for
+																												// data
+							EntityUtils.consume(response.getEntity()); // close out
+																		// inputstream
+																		// ignore
+																		// content
+						} catch (Exception e) {
+							log.debug("Error ocurred in handling response entity after successful call, still responding success. "
+											+ e.getMessage(), e);
+						}
+						log.debug("Successfull response - The http response is <<<" + theContent + ">>>");
+					}
+					retryCount = 2;
+				} else {
+					log.warn("HTTP response code was not an expected successful response of between 200 - 299, the code was: " + response.getStatusLine());
+					try {
+						String someContent = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8")); // read
+						// content
+						// for
+						// data
+						EntityUtils.consume(response.getEntity()); // close out
+						// inputstream
+						// ignore
+						// content
+						log.debug("Unsuccessfull response - The http response is <<<" + someContent + ">>>");
+					} catch (Exception e) {
+						//noop
+					}
+					if (response.getStatusLine().getStatusCode() == 504) {
+						log.warn("HTTP response code was 504, retrying...");
+						try {
+							Thread.sleep(1000);
+						} catch (InterruptedException e1) {
+							// noop
+						}
+					}
+					else
+						retryCount = 2;
+				}
+			}
+		} catch (IOException e) {
+			log.warn("Error calling out to HA gateway: IOException in log", e);
+		}
+		return theContent;
+	}
+	
+//	public HttpClient getHttpClient() {
+//		return httpClient;
+//	}
+
+
+	public CloseableHttpClient getHttpClient() {
+		return httpClient;
+	}
+
+
+	public void closeHandler() {
+		try {
+			httpClient.close();
+		} catch (IOException e) {
+			// noop
+		}
+		httpClient = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/http/HTTPHome.java

@@ -0,0 +1,101 @@
+package com.bwssystems.HABridge.plugins.http;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.DeviceDataDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.hue.TimeDecode;
+import com.google.gson.Gson;
+
+public class HTTPHome implements Home {
+	private static final Logger log = LoggerFactory.getLogger(HTTPHome.class);
+	private HTTPHandler anHttpHandler;
+
+	public HTTPHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		String responseString = null;
+		
+		String theUrl = anItem.getItem().getAsString();
+		if(theUrl != null && !theUrl.isEmpty () && (theUrl.startsWith("http://") || theUrl.startsWith("https://"))) {
+			//Backwards Compatibility Items
+			if(anItem.getHttpVerb() == null || anItem.getHttpVerb().isEmpty())
+			{
+				if(device.getHttpVerb() != null && !device.getHttpVerb().isEmpty())
+					anItem.setHttpVerb(device.getHttpVerb());
+			}
+	
+			if(anItem.getHttpHeaders() == null || anItem.getHttpHeaders().isEmpty()) {
+				if(device.getHeaders() != null && !device.getHeaders().isEmpty() )
+					anItem.setHttpHeaders(device.getHeaders());
+			}
+	
+			log.debug("executing HUE api request to Http "
+					+ (anItem.getHttpVerb() == null ? "GET" : anItem.getHttpVerb()) + ": "
+					+ anItem.getItem().getAsString());
+
+			String anUrl = BrightnessDecode.calculateReplaceIntensityValue(theUrl,
+					intensity, targetBri, targetBriInc, false);
+			anUrl = DeviceDataDecode.replaceDeviceData(anUrl, device);
+			anUrl = TimeDecode.replaceTimeValue(anUrl);
+
+			String aBody = null;
+			if(anItem.getHttpBody()!= null && !anItem.getHttpBody().isEmpty()) {
+				aBody = BrightnessDecode.calculateReplaceIntensityValue(anItem.getHttpBody(),
+						intensity, targetBri, targetBriInc, false);
+				aBody = DeviceDataDecode.replaceDeviceData(aBody, device);
+				aBody = TimeDecode.replaceTimeValue(aBody);
+			}
+			// make call
+			if (anHttpHandler.doHttpRequest(anUrl, anItem.getHttpVerb(), anItem.getContentType(), aBody,
+					new Gson().fromJson(anItem.getHttpHeaders(), NameValue[].class)) == null) {
+				log.warn("Error on calling url to change device state: " + anUrl);
+				responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+						"Error on calling url to change device state", "/lights/"
+						+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+			}
+		} else {
+			log.warn("HTTP Call to be presented as http(s)://<ip_address>(:<port>)/payload, format of request unknown: " + theUrl);
+			responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+					"Error on calling url to change device state", "/lights/"
+					+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		}
+
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		anHttpHandler = new HTTPHandler();
+		log.info("Http Home created.");
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		// Not a resource
+		return null;
+	}
+
+	@Override
+	public void closeHome() {
+		if(anHttpHandler != null)
+			anHttpHandler.closeHandler();
+		anHttpHandler = null;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueDevice.java

@@ -0,0 +1,35 @@
+package com.bwssystems.HABridge.plugins.hue;
+
+import com.bwssystems.HABridge.api.hue.DeviceResponse;
+
+
+public class HueDevice {
+	private DeviceResponse device;
+	private String huedeviceid;
+	private String hueaddress;
+	private String huename;
+	public DeviceResponse getDevice() {
+		return device;
+	}
+	public void setDevice(DeviceResponse adevice) {
+		this.device = adevice;
+	}
+	public String getHuedeviceid() {
+		return huedeviceid;
+	}
+	public void setHuedeviceid(String huedeviceid) {
+		this.huedeviceid = huedeviceid;
+	}
+	public String getHueaddress() {
+		return hueaddress;
+	}
+	public void setHueaddress(String ahueaddress) {
+		this.hueaddress = ahueaddress;
+	}
+	public String getHuename() {
+		return huename;
+	}
+	public void setHuename(String ahuename) {
+		this.huename = ahuename;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueDeviceIdentifier.java

@@ -0,0 +1,25 @@
+package com.bwssystems.HABridge.plugins.hue;
+
+public class HueDeviceIdentifier {
+	private String hueName;
+	private String ipAddress;
+	private String deviceId;
+	public String getHueName() {
+		return hueName;
+	}
+	public void setHueName(String hueName) {
+		this.hueName = hueName;
+	}
+	public String getIpAddress() {
+		return ipAddress;
+	}
+	public void setIpAddress(String ipAddress) {
+		this.ipAddress = ipAddress;
+	}
+	public String getDeviceId() {
+		return deviceId;
+	}
+	public void setDeviceId(String deviceId) {
+		this.deviceId = deviceId;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueHome.java

@@ -0,0 +1,136 @@
+package com.bwssystems.HABridge.plugins.hue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.hue.DeviceResponse;
+import com.bwssystems.HABridge.api.hue.HueApiResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class HueHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HueHome.class);
+	private Map<String, HueInfo> hues;
+	private Boolean validHue;
+	private Gson aGsonHandler;
+	
+	public HueHome(BridgeSettings bridgeSettings) {
+		super();
+		createHome(bridgeSettings);
+	}
+
+	@Override
+	public Object getItems(String type) {
+		log.debug("consolidating devices for hues");
+		if(!validHue)
+			return null;
+		Iterator<String> keys = hues.keySet().iterator();
+		ArrayList<HueDevice> deviceList = new ArrayList<HueDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			HueApiResponse theResponse = hues.get(key).getHueApiResponse();
+			if(theResponse != null) {
+				Map<String, DeviceResponse> theDevices = theResponse.getLights();
+				if(theDevices != null) {
+					Iterator<String> deviceKeys = theDevices.keySet().iterator();
+					while(deviceKeys.hasNext()) {
+						String theDeviceKey = deviceKeys.next();
+						HueDevice aNewHueDevice = new HueDevice();
+						aNewHueDevice.setDevice(theDevices.get(theDeviceKey));
+						aNewHueDevice.setHuedeviceid(theDeviceKey);
+						aNewHueDevice.setHueaddress(hues.get(key).getHueAddress().getIp());
+						aNewHueDevice.setHuename(key);
+						deviceList.add(aNewHueDevice);
+					}
+				}
+				else {
+					deviceList = null;
+					break;
+				}
+			}
+			else
+				log.warn("Cannot get lights for Hue with name: " + key);
+		}
+		return deviceList;
+	}
+
+	public DeviceResponse getHueDeviceInfo(CallItem anItem, DeviceDescriptor device) {
+		if(!validHue)
+			return null;
+		HueDeviceIdentifier deviceId = null;
+		if(anItem.getItem().isJsonObject())
+			deviceId = aGsonHandler.fromJson(anItem.getItem(), HueDeviceIdentifier.class);
+		else
+			deviceId = aGsonHandler.fromJson(anItem.getItem().getAsString(), HueDeviceIdentifier.class);
+		if(deviceId.getHueName() == null || deviceId.getHueName().isEmpty())
+			deviceId.setHueName(device.getTargetDevice());
+		
+		DeviceResponse deviceResponse = null;
+		HueInfo aHueInfo = hues.get(device.getTargetDevice());
+		deviceResponse = aHueInfo.getHueDeviceInfo(deviceId.getDeviceId(), device);
+		return deviceResponse;
+	}
+	
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, DeviceDescriptor device, String body) {
+		if(!validHue)
+			return null;
+		String responseString = null;
+		HueDeviceIdentifier deviceId = null;
+		if(anItem.getItem().isJsonObject())
+			deviceId = aGsonHandler.fromJson(anItem.getItem(), HueDeviceIdentifier.class);
+		else
+			deviceId = aGsonHandler.fromJson(anItem.getItem().getAsString(), HueDeviceIdentifier.class);
+		if(deviceId.getHueName() == null || deviceId.getHueName().isEmpty())
+			deviceId.setHueName(device.getTargetDevice());
+		
+		HueInfo theHue = hues.get(deviceId.getHueName());
+
+		// make call
+		responseString = theHue.changeState(deviceId, lightId, body);
+
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		validHue = bridgeSettings.getBridgeSettingsDescriptor().isValidHue();
+		log.info("Hue passthru Home created." + (validHue ? "" : " No Hue passtrhu systems configured."));
+		if(validHue) {
+			hues = new HashMap<String, HueInfo>();
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHueaddress().getDevices().iterator();
+			while(theList.hasNext()) {
+				NamedIP aHue = theList.next();
+	      		hues.put(aHue.getName(), new HueInfo(aHue));
+			}
+			aGsonHandler = new GsonBuilder().create();
+		}
+		return this;
+	}
+
+	@Override
+	public void closeHome() {
+		if(!validHue)
+			return;
+		if(hues == null)
+			return;
+		Iterator<String> keys = hues.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			hues.get(key).closeHue();;
+		}
+		hues = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueInfo.java

@@ -0,0 +1,199 @@
+package com.bwssystems.HABridge.plugins.hue;
+
+import java.io.IOException;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.SuccessUserResponse;
+import com.bwssystems.HABridge.api.UserCreateRequest;
+import com.bwssystems.HABridge.api.hue.DeviceResponse;
+import com.bwssystems.HABridge.api.hue.HueApiResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+
+public class HueInfo {
+    private static final Logger log = LoggerFactory.getLogger(HueInfo.class);
+    private HTTPHandler httpClient;
+    private NamedIP hueAddress;
+	public static final String HUE_REQUEST = "/api";
+
+    public HueInfo(NamedIP addressName) {
+		super();
+        httpClient = new HTTPHandler();
+        hueAddress = addressName;
+ 	}
+    
+	public HueApiResponse getHueApiResponse() {
+		log.debug("Get hue info to hue " + hueAddress.getName());
+		HueApiResponse theHueApiResponse = null;
+
+		if(hueAddress.getUsername() == null) {
+			registerWithHue();
+			if(hueAddress.getUsername() == null) {
+				log.warn("Could not register with hue: " + hueAddress.getName());
+			}
+		}
+		
+		String theUrl = "http://" + hueAddress.getIp() + HUE_REQUEST + "/" + hueAddress.getUsername();
+    	String theData;
+    	boolean loopControl = true;
+    	int retryCount = 0;
+    	while(loopControl) {
+    		if(retryCount > 3) {
+	    		log.warn("Max Retry reached to get Hue data from " + hueAddress.getName());
+	    		loopControl = false;
+    			break;
+    		} else if (retryCount > 0) {
+    			try {
+					Thread.sleep(1000);
+				} catch (InterruptedException e) {
+					// ignore
+				}
+    		}
+    		theUrl = "http://" + hueAddress.getIp() + HueUtil.HUE_REQUEST + "/" + hueAddress.getUsername();
+    		theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+	    	if(theData != null) {
+	    		log.debug("GET HueApiResponse - data: " + theData);
+	    		if(theData.contains("[{\"error\":")) {
+	    			if(theData.contains("unauthorized user")) {
+	    				registerWithHue();
+	        			if(hueAddress.getUsername() == null) {
+	        				log.warn("Retry Register to Hue for " + hueAddress.getName() + " returned error: " + theData);
+	        			}
+	        			retryCount++;
+	    			}
+	    			else {
+	    				log.warn("GET HueApiResponse for " + hueAddress.getName() + " - returned error: " + theData);
+	    				return null;
+	    			}
+	    		}
+	    		else {
+			    	theHueApiResponse = new Gson().fromJson(theData, HueApiResponse.class);
+			        log.debug("GET HueApiResponse for " + hueAddress.getName() + " - Gson parse - name: " + theHueApiResponse.getConfig().getName() + ", mac addr: " + theHueApiResponse.getConfig().getMac());
+			        loopControl = false;
+	    		}
+	    	}
+	    	else {
+	    		log.warn("GET HueApiResponse for " + hueAddress.getName() + " - returned null, no data.");
+	    		loopControl = false;
+	    	}
+    	}
+    	return theHueApiResponse;
+    }
+	
+	public String registerWithHue() {
+    	UserCreateRequest theLogin = new UserCreateRequest();
+        theLogin.setDevicetype("HABridge#MyMachine");
+        HttpPost postRequest = new HttpPost("http://" + hueAddress.getIp() + HUE_REQUEST);
+        ContentType parsedContentType = ContentType.parse("application/json");
+        StringEntity requestBody = new StringEntity(new Gson().toJson(theLogin), parsedContentType);
+        HttpResponse response = null;
+        postRequest.setEntity(requestBody);
+        HttpClient anHttpClient = httpClient.getHttpClient();
+        try {
+            response = anHttpClient.execute(postRequest);
+            log.debug("registerWithHue - POST execute on " + hueAddress.getName() + "URL responded: " + response.getStatusLine().getStatusCode());
+            if(response.getStatusLine().getStatusCode() >= 200  && response.getStatusLine().getStatusCode() < 300){
+            	String theBody = EntityUtils.toString(response.getEntity());
+                log.debug("registerWithHue response data: " + theBody);
+                if(theBody.contains("[{\"error\":")) {
+                	if(theBody.contains("link button not")) {
+                		log.warn("registerWithHue needs link button pressed on HUE bridge: " + hueAddress.getName());
+                	}
+                	else
+                		log.warn("registerWithHue returned an unexpected error: " + theBody);
+                }
+                else {
+	            	SuccessUserResponse[] theResponses = new Gson().fromJson(theBody, SuccessUserResponse[].class); //read content for data, SuccessUserResponse[].class);
+	            	hueAddress.setUsername(theResponses[0].getSuccess().getUsername());
+                }
+            }
+            EntityUtils.consume(response.getEntity()); //close out inputstream ignore content
+        } catch (IOException e) {
+        	log.warn("Error logging into HUE: IOException in log", e);
+        }
+        return hueAddress.getUsername();
+    }
+
+	public DeviceResponse getHueDeviceInfo(String hueDeviceId, DeviceDescriptor device) {
+		log.debug("Get hue device info to "+ hueAddress.getName() + " passthru id " + hueDeviceId);
+		String responseString = null;
+		DeviceResponse deviceResponse = null;
+		if(hueAddress.getUsername() == null)
+			registerWithHue();
+		if (hueAddress.getUsername() != null) {
+			// make call
+			responseString = httpClient.doHttpRequest(
+					"http://" + hueAddress.getIp() + "/api/" + hueAddress.getUsername()
+							+ "/lights/" + hueDeviceId,
+					HttpGet.METHOD_NAME, "application/json", null, null);
+			if (responseString == null) {
+				log.warn("Error on calling hue device to get state: " + device.getName());
+				deviceResponse = DeviceResponse.createResponse(device);
+			} else if (responseString.contains("[{\"error\":") && responseString.contains("unauthorized user")) {
+				log.warn("Error on calling hue device to get state: " + device.getName() + " with errors: " + responseString);
+				deviceResponse = DeviceResponse.createResponse(device);
+			} else {
+				deviceResponse = new Gson().fromJson(responseString, DeviceResponse.class);
+				if (deviceResponse != null) 
+					deviceResponse.setName(device.getName());
+			}
+		} else  {
+			log.warn("Error on calling hue device to get state: " + device.getName() + " Could not register with hue: " + hueAddress.getName());
+			deviceResponse = DeviceResponse.createResponse(device);
+		}
+
+		return deviceResponse;
+	}
+
+	public String changeState(HueDeviceIdentifier deviceId, String lightId, String body) {
+		log.debug("Changing state for ha-bridge id " + lightId + " to " + deviceId.getHueName() + " passthru id " + deviceId.getDeviceId() + " with state " + body );
+		String responseString = null;
+		if(hueAddress.getUsername() == null)
+			registerWithHue();
+		if (hueAddress.getUsername() != null) {
+			responseString = httpClient.doHttpRequest(
+					"http://" + deviceId.getIpAddress() + "/api/" + hueAddress.getUsername()
+							+ "/lights/" + deviceId.getDeviceId() + "/state",
+					HttpPut.METHOD_NAME, "application/json", body, null);
+			if (responseString == null) {
+				log.warn("Error on calling Hue passthru to change device state: " + deviceId.getHueName());
+				responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"Error on calling HUE to change device state\", \"parameter\": \"/lights/"
+						+ lightId + "state\"}}]";
+			} else if (responseString.contains("[{\"error\":")) {
+				if(responseString.contains("unauthorized user")) {
+				}
+				log.warn("Error occurred when calling Hue Passthru: " + responseString);
+			}
+		} else  {
+			log.warn("Error on calling hue device to change state: " + deviceId.getHueName() + " Could not register with hue: " + hueAddress.getName());
+		}
+		return responseString;
+	}
+
+	public void closeHue() {
+		httpClient.closeHandler();
+		httpClient = null;
+	}
+	
+	public NamedIP getHueAddress() {
+		return hueAddress;
+	}
+
+	public void setHueAddress(NamedIP hueAddress) {
+		this.hueAddress = hueAddress;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueUtil.java

@@ -0,0 +1,56 @@
+package com.bwssystems.HABridge.plugins.hue;
+
+import java.io.IOException;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.api.SuccessUserResponse;
+import com.bwssystems.HABridge.api.UserCreateRequest;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+public class HueUtil {
+    private static final Logger log = LoggerFactory.getLogger(HueUtil.class);
+	public static final String HUE_REQUEST = "/api";
+
+	public static final String registerWithHue(HTTPHandler anHttpHandler, String ipAddress, String aName, String theUser) {
+    	UserCreateRequest theLogin = new UserCreateRequest();
+        theLogin.setDevicetype("HABridge#MyMachine");
+        HttpPost postRequest = new HttpPost("http://" + ipAddress + HUE_REQUEST);
+        ContentType parsedContentType = ContentType.parse("application/json");
+        StringEntity requestBody = new StringEntity(new Gson().toJson(theLogin), parsedContentType);
+        HttpResponse response = null;
+        postRequest.setEntity(requestBody);
+        HttpClient anHttpClient = anHttpHandler.getHttpClient();
+        try {
+            response = anHttpClient.execute(postRequest);
+            log.debug("POST execute on URL responded: " + response.getStatusLine().getStatusCode());
+            if(response.getStatusLine().getStatusCode() >= 200  && response.getStatusLine().getStatusCode() < 300){
+            	String theBody = EntityUtils.toString(response.getEntity());
+                log.debug("registerWithHue response data: " + theBody);
+                if(theBody.contains("[{\"error\":")) {
+                	if(theBody.contains("link button not")) {
+                		log.warn("registerWithHue needs link button pressed on HUE bridge: " + aName);
+                	}
+                	else
+                		log.warn("registerWithHue returned an unexpected error: " + theBody);
+                }
+                else {
+	            	SuccessUserResponse[] theResponses = new Gson().fromJson(theBody, SuccessUserResponse[].class); //read content for data, SuccessUserResponse[].class);
+	            	theUser = theResponses[0].getSuccess().getUsername();
+                }
+            }
+            EntityUtils.consume(response.getEntity()); //close out inputstream ignore content
+        } catch (IOException e) {
+        	log.warn("Error logging into HUE: IOException in log", e);
+        }
+        return theUser;
+    }
+}

src/main/java/com/bwssystems/HABridge/plugins/lifx/LifxDevice.java

@@ -0,0 +1,49 @@
+package com.bwssystems.HABridge.plugins.lifx;
+
+import com.github.besherman.lifx.LFXGroup;
+import com.github.besherman.lifx.LFXLight;
+
+public class LifxDevice {
+	private Object lifxObject;
+	private String type;
+	public final static String LIGHT_TYPE = "Light";
+	public final static String GROUP_TYPE = "Group";
+	
+	public LifxDevice(Object lifxObject, String type) {
+		super();
+		this.lifxObject = lifxObject;
+		this.type = type;
+	}
+
+	public LifxEntry toEntry() {
+		LifxEntry anEntry = null;
+		if(type.equals(LIGHT_TYPE)) {
+			anEntry = new LifxEntry();
+			anEntry.setId(((LFXLight)lifxObject).getID());
+			anEntry.setName(((LFXLight)lifxObject).getLabel());
+			anEntry.setType(LIGHT_TYPE);
+		}
+		if(type.equals(GROUP_TYPE)) {
+			anEntry = new LifxEntry();
+			anEntry.setId("na");
+			anEntry.setName(((LFXGroup)lifxObject).getLabel());
+			anEntry.setType(GROUP_TYPE);
+		}
+		return anEntry;
+	}
+	public Object getLifxObject() {
+		return lifxObject;
+	}
+
+	public void setLifxObject(Object lifxObject) {
+		this.lifxObject = lifxObject;
+	}
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/lifx/LifxEntry.java

@@ -0,0 +1,25 @@
+package com.bwssystems.HABridge.plugins.lifx;
+
+public class LifxEntry {
+	private String name;
+	private String id;
+	private String type;
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getId() {
+		return id;
+	}
+	public void setId(String id) {
+		this.id = id;
+	}
+	public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+}