MSA-1718: Beta version of Gideon

devicetypes/gouldner/stateless-on-off-button-tile.src/stateless-on-off-button-tile.groovy

@@ -1,46 +0,0 @@
-/**
- *  Stateless On/Off Button Tile
- *
- *  Author: Ronald Gouldner
- *
- *  Date: 2015-05-14
- */
-metadata {
-	// Automatically generated. Make future change here.
-	definition (name: "Stateless On-Off Button Tile", namespace: "gouldner", author: "Ronald Gouldner") {
-		capability "Actuator"
-		capability "Switch"
-		capability "Sensor"
-	}
-
-	// simulator metadata
-	simulator {
-	}
-
-	// UI tile definitions
-	tiles {
-		standardTile("button", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "offReady", label: 'Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "onReady"
-			state "onReady", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "offReady"
-			state "off", label: 'Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			state "on", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
-		}
-		main "button"
-		details "button"
-	}
-}
-
-def parse(String description) {
-}
-
-def on() {
-    log.debug "Stateless On/Off Button Tile Virtual Switch ${device.name} turned on"
-    sendEvent(name: "switch", value: "on")
-    sendEvent(name: "switch", value: "onReady")
-}
-
-def off() {
-    log.debug "Stateless On/Off Button Tile Virtual Switch ${device.name} turned off"
-    sendEvent(name: "switch", value: "off")
-    sendEvent(name: "switch", value: "offReady")
-}

devicetypes/smartthings/centralite-thermostat.src/centralite-thermostat.groovy

@@ -81,47 +81,51 @@ metadata {
 // parse events into attributes
 def parse(String description) {
 	log.debug "Parse description $description"
-	List result = []
-	def descMap = zigbee.parseDescriptionAsMap(description)
-	log.debug "Desc Map: $descMap"
-	List attrData = [[cluster: descMap.cluster ,attrId: descMap.attrId, value: descMap.value]]
-	descMap.additionalAttrs.each {
-	    attrData << [cluster: descMap.cluster, attrId: it.attrId, value: it.value]
-	}
-	attrData.each {
 	def map = [:]
-		if (it.cluster == "0201" && it.attrId == "0000") {
+	if (description?.startsWith("read attr -")) {
+		def descMap = parseDescriptionAsMap(description)
+		log.debug "Desc Map: $descMap"
+		if (descMap.cluster == "0201" && descMap.attrId == "0000") {
 			log.debug "TEMP"
 			map.name = "temperature"
-			map.value = getTemperature(it.value)
+			map.value = getTemperature(descMap.value)
 			map.unit = temperatureScale
-		} else if (it.cluster == "0201" && it.attrId == "0011") {
+		} else if (descMap.cluster == "0201" && descMap.attrId == "0011") {
 			log.debug "COOLING SETPOINT"
 			map.name = "coolingSetpoint"
-			map.value = getTemperature(it.value)
+			map.value = getTemperature(descMap.value)
 			map.unit = temperatureScale
-		} else if (it.cluster == "0201" && it.attrId == "0012") {
+		} else if (descMap.cluster == "0201" && descMap.attrId == "0012") {
 			log.debug "HEATING SETPOINT"
 			map.name = "heatingSetpoint"
-			map.value = getTemperature(it.value)
+			map.value = getTemperature(descMap.value)
 			map.unit = temperatureScale
-		} else if (it.cluster == "0201" && it.attrId == "001c") {
+		} else if (descMap.cluster == "0201" && descMap.attrId == "001c") {
 			log.debug "MODE"
 			map.name = "thermostatMode"
-			map.value = getModeMap()[it.value]
+			map.value = getModeMap()[descMap.value]
-		} else if (it.cluster == "0202" && it.attrId == "0000") {
+		} else if (descMap.cluster == "0202" && descMap.attrId == "0000") {
 			log.debug "FAN MODE"
 			map.name = "thermostatFanMode"
-			map.value = getFanModeMap()[it.value]
+			map.value = getFanModeMap()[descMap.value]
 		}
+	}
+
+	def result = null
 	if (map) {
-			result << createEvent(map)
+		result = createEvent(map)
 	}
 	log.debug "Parse returned $map"
-	}
 	return result
 }
 
+def parseDescriptionAsMap(description) {
+	(description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+	}
+}
+
 def getModeMap() { [
 	"00":"off",
 	"03":"cool",

devicetypes/smartthings/cree-bulb.src/cree-bulb.groovy

@@ -82,7 +82,7 @@ def on() {
 }
 
 def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()       //adding refresh because of ZLL bulb not conforming to send-me-a-report
+    zigbee.setLevel(value) + ["delay 500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
 /**

devicetypes/smartthings/hue-bloom.src/hue-bloom.groovy

@@ -17,7 +17,6 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 		capability "Health Check"
-		capability "Light"
 
 		command "setAdjustedColor"
         command "reset"

devicetypes/smartthings/hue-bulb.src/hue-bulb.groovy

@@ -18,7 +18,6 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 		capability "Health Check"
-		capability "Light"
 
 		command "setAdjustedColor"
         command "reset"

devicetypes/smartthings/hue-lux-bulb.src/hue-lux-bulb.groovy

@@ -15,7 +15,6 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
         capability "Health Check"
-		capability "Light"
 
         command "refresh"
 	}

devicetypes/smartthings/hue-white-ambiance-bulb.src/hue-white-ambiance-bulb.groovy

@@ -16,7 +16,6 @@ metadata {
         capability "Switch"
         capability "Refresh"
         capability "Health Check"
-        capability "Light"
 
         command "refresh"
     }

devicetypes/smartthings/testing/simulated-switch.src/simulated-switch.groovy

@@ -39,7 +39,9 @@ metadata {
 	}
 }
 
-def parse(description) {
+def parse(String description) {
+	def pair = description.split(":")
+	createEvent(name: pair[0].trim(), value: pair[1].trim())
 }
 
 def on() {

devicetypes/smartthings/zigbee-dimmer.src/zigbee-dimmer.groovy

@@ -28,10 +28,6 @@ metadata {
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B05", outClusters: "0019", manufacturer: "OSRAM SYLVANIA", model: "iQBR30", deviceJoinName: "Sylvania Ultra iQ"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY PAR38 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart PAR38 Soft White"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY BR ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart BR30 Soft White"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702, 0B05", outClusters: "0019", manufacturer: "sengled", model: "E11-G13", deviceJoinName: "Sengled Element Classic"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008", outClusters: "0003, 0006, 0008, 0019, 0406", manufacturer: "Leviton", model: "DL6HD", deviceJoinName: "Leviton Dimmer Switch"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008", outClusters: "0003, 0006, 0008, 0019, 0406", manufacturer: "Leviton", model: "DL3HL", deviceJoinName: "Leviton Lumina RF Plug-In Dimmer"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008", outClusters: "0003, 0006, 0008, 0019, 0406", manufacturer: "Leviton", model: "DL1KD", deviceJoinName: "Leviton Lumina RF Dimmer Switch"
     }
 
     tiles(scale: 2) {

devicetypes/smartthings/zigbee-switch.src/zigbee-switch.groovy

@@ -22,7 +22,6 @@ metadata {
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0006", outClusters: "0003, 0006, 0019, 0406", manufacturer: "Leviton", model: "ZSS-10", deviceJoinName: "Leviton Switch"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0006", outClusters: "000A", manufacturer: "HAI", model: "65A21-1", deviceJoinName: "Leviton Wireless Load Control Module-30amp"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006", outClusters: "0003, 0006, 0008, 0019, 0406", manufacturer: "Leviton", model: "DL15A", deviceJoinName: "Leviton Lumina RF Plug-In Appliance Module"
     }
 
     // simulator metadata

devicetypes/smartthings/zll-dimmer-bulb.src/zll-dimmer-bulb.groovy

@@ -89,7 +89,7 @@ def on() {
 }
 
 def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
+    zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
 def refresh() {

devicetypes/smartthings/zll-rgb-bulb.src/zll-rgb-bulb.groovy

@@ -115,7 +115,7 @@ def refreshAttributes() {
 }
 
 def setLevel(value) {
-	zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
+	zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
 def setColor(value){

devicetypes/smartthings/zll-rgbw-bulb.src/zll-rgbw-bulb.groovy

@@ -135,7 +135,7 @@ def setColorTemperature(value) {
 }
 
 def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()        //adding refresh because of ZLL bulb not conforming to send-me-a-report
+    zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
 def setColor(value){

devicetypes/smartthings/zll-white-color-temperature-bulb.src/zll-white-color-temperature-bulb.groovy

@@ -90,7 +90,7 @@ def on() {
 }
 
 def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()
 }
 
 def refresh() {

smartapps/dianoga/netatmo-connect.src/netatmo-connect.groovy

@@ -73,7 +73,7 @@ def authPage() {
 			return dynamicPage(name: "Credentials", title: "Authorize Connection", nextPage:"listDevices", uninstall: uninstallAllowed, install:false) {
 				section() {
 					paragraph "Tap below to log in to the netatmo and authorize SmartThings access."
-					href url:redirectUrl, style:"embedded", required:false, title:"Connect to ${getVendorName()}", description:description
+					href url:redirectUrl, style:"embedded", required:false, title:"Connect to ${getVendorName()}:", description:description
 				}
 			}
 		} else {
@@ -146,23 +146,18 @@ def callback() {
 
 		// log.debug "PARAMS: ${params}"
 
-		try {
 		httpPost(params) { resp ->
 
 			def slurper = new JsonSlurper()
 
 			resp.data.each { key, value ->
 				def data = slurper.parseText(key)
-					log.debug "Data: $data"
+
 				state.refreshToken = data.refresh_token
 				state.authToken = data.access_token
-                    //state.accessToken = data.access_token
 				state.tokenExpires = now() + (data.expires_in * 1000)
 				// log.debug "swapped token: $resp.data"
 			}
-            }
-        } catch (Exception e) {
-			log.debug "callback: Call failed $e"
 		}
 
 		// Handle success and failure here, and render stuff accordingly
@@ -392,18 +387,18 @@ def getDeviceList() {
 	state.deviceDetail = [:]
 	state.deviceState = [:]
 
-	apiGet("/api/getstationsdata") { response ->
+	apiGet("/api/devicelist") { response ->
 		response.data.body.devices.each { value ->
 			def key = value._id
 			deviceList[key] = "${value.station_name}: ${value.module_name}"
 			state.deviceDetail[key] = value
             state.deviceState[key] = value.dashboard_data
-            value.modules.each { value2 ->            
-                def key2 = value2._id
-                deviceList[key2] = "${value.station_name}: ${value2.module_name}"
-                state.deviceDetail[key2] = value2
-                state.deviceState[key2] = value2.dashboard_data            
 		}
+		response.data.body.modules.each { value ->
+			def key = value._id
+			deviceList[key] = "${state.deviceDetail[value.main_device].station_name}: ${value.module_name}"
+			state.deviceDetail[key] = value
+            state.deviceState[key] = value.dashboard_data
 		}
 	}
 
@@ -453,7 +448,6 @@ def listDevices() {
 }
 
 def apiGet(String path, Map query, Closure callback) {
-
 	if(now() >= state.tokenExpires) {
 		refreshToken();
 	}
@@ -475,13 +469,9 @@ def apiGet(String path, Map query, Closure callback) {
 		log.debug "apiGet: Call failed $e"
 		if(refreshToken()) {
 			log.debug "apiGet: Trying again after refreshing token"
-            try {
 			httpGet(params)	{ response ->
 				callback.call(response)
 			}
-            } catch (Exception f) {
-                log.debug "apiGet: Call failed $f"
-            }
 		}
 	}
 }

smartapps/gideon-api/gideon.src/gideon.groovy

@@ -16,33 +16,55 @@
 definition(
     name: "Gideon",
     namespace: "gideon.api",
-    author: "Braindrain Solutions",
+    author: "Braindrain Solutions ltd",
-    description: "Gideon AI Smart app allows you to connect and control all of your SmartThings devices through the Gideon AI app, making your SmartThings devices even smarter.",
+    description: "Gideon Smart Home SmartApp allows you to connect and control all of your SmartThings devices through the Gideon app, making your SmartThings devices even smarter.",
     category: "Family",
     iconUrl: "http://s33.postimg.org/t77u7y7v3/logo.png",
     iconX2Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
     iconX3Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    oauth: [displayName: "Gideon AI API", displayLink: "gideon.ai"])
+    oauth: [displayName: "Gideon Smart Home API app", displayLink: "gideon.ai"])
 
 
 preferences {
+	section("Control these contact sensors...") {
+        input "contact", "capability.contactSensor", multiple:true, required:false
+    }
 	section("Control these switches...") {
-        input "switches", "capability.switch", multiple:true
+        input "switches", "capability.switch", multiple:true, required:false
+    }
+    section("Control these smoke alarms...") {
+        input "smoke_alarms", "capability.smokeDetector", multiple:true, required:false
+    }
+    section("Control these window shades...") {
+        input "shades", "capability.windowShade", multiple:true, required:false
+    }
+    section("Control these garage doors...") {
+        input "garage", "capability.garageDoorControl", multiple:true, required:false
+    }
+    section("Control these water sensors...") {
+        input "water_sensors", "capability.waterSensor", multiple:true, required:false
     }
     section("Control these motion sensors...") {
-        input "motions", "capability.motionSensor", multiple:true
+        input "motions", "capability.motionSensor", multiple:true, required:false
     }
     section("Control these presence sensors...") {
-    	input "presence_sensors", "capability.presenceSensor", multiple:true
+    	input "presence_sensors", "capability.presenceSensor", multiple:true, required:false
     }
-    section("Control these outlets...") {
+/** section("Control these outlets...") {
-    	input "outlets", "capability.switch", multiple:true
+    	input "outlets", "capability.switch", multiple:true, required:false
+    }
+*/
+     section("Control these power meters...") {
+        input "meters", "capability.powerMeter", multiple:true, required:false
     }
     section("Control these locks...") {
-    	input "locks", "capability.lock", multiple:true
+    	input "locks", "capability.lock", multiple:true, required:false
     }
-    section("Control these locks...") {
+    section("Control these temperature sensors...") {
-	    input "temperature_sensors", "capability.temperatureMeasurement"
+	    input "temperature_sensors", "capability.temperatureMeasurement", multiple:true, required:false
+    }
+    section("Control these batteries...") {
+	    input "batteries", "capability.battery", multiple:true, required:false
     }
 }
 
@@ -60,18 +82,8 @@ def updated() {
 }
 
 def initialize() {
-	// TODO: subscribe to attributes, devices, locations, etc.
-    subscribe(outlet, "energy", outletHandler)
-  	subscribe(outlet, "switch", outletHandler)
 }
 
-// TODO: implement event handlers
-def outletHandler(evt) {
-	log.debug "$outlet.currentEnergy"
-	//TODO call G API  
-}
-
-
 private device(it, type) {
 	it ? [id: it.id, label: it.label, type: type] : null
 }
@@ -83,9 +95,14 @@ mappings {
       	GET: "getAllDevices"
    ]
   }
-	path("/doorlocks/:id/:command") {
+  path("/doorlocks/lock/:id") {
     action: [
-      GET: "updateDoorLock"
+      GET: "lockDoorLock"
+    ]
+  }
+  path("/doorlocks/unlock/:id") {
+    action: [
+      GET: "unlockDoorLock"
     ]
   }
   path("/doorlocks/:id") {
@@ -93,10 +110,70 @@ mappings {
       GET: "getDoorLockStatus"
     ]
   }
+  path("/contacts/:id") {
+    action: [
+  	GET: "getContactStatus"
+    ]
+  }
+  path("/smoke/:id") {
+    action: [
+      			GET: "getSmokeStatus"
+    		]
+  	}
+    path("/shades/open/:id") {
+    action: [
+      GET: "openShade"
+    ]
+  }
+  path("/shades/preset/:id") {
+    action: [
+      GET: "presetShade"
+    ]
+  }
+  path("/shades/close/:id") {
+    action: [
+      GET: "closeShade"
+    ]
+  }
+  	path("/shades/:id") {
+    action: [
+      			GET: "getShadeStatus"
+    		]
+  	}
+    path("/garage/open/:id") {
+    action: [
+      GET: "openGarage"
+    ]
+  }
+  path("/garage/close/:id") {
+    action: [
+      GET: "closeGarage"
+    ]
+  }
+  	path("/garage/:id") {
+    action: [
+      			GET: "getGarageStatus"
+    		]
+  	}
+    path("/watersensors/:id") {
+    action: [
+      			GET: "getWaterSensorStatus"
+    		]
+  	}
   	path("/tempsensors/:id") {
     action: [
       GET: "getTempSensorsStatus"
     ]
+  }
+  path("/meters/:id") {
+    action: [
+      GET: "getMeterStatus"
+    ]
+  }
+  path("/batteries/:id") {
+    action: [
+      GET: "getBatteryStatus"
+    ]
   }
   	path("/presences/:id") {
     action: [
@@ -108,19 +185,35 @@ mappings {
       GET: "getMotionStatus"
     ]
   }
-  	path("/outlets/:id") {
+/**  	path("/outlets/:id") {
     action: [
       GET: "getOutletStatus"
     ]
   }
-  	path("/outlets/:id/:command") {
+  	path("/outlets/turnon/:id") {
     action: [
-      GET: "updateOutlet"
+      GET: "turnOnOutlet"
     ]
   }
-  	path("/switches/:command") {
+  path("/outlets/turnoff/:id") {
     action: [
-      PUT: "updateSwitch"
+      GET: "turnOffOutlet"
+    ]
+  }
+*/
+  	path("/switches/turnon/:id") {
+    action: [
+      GET: "turnOnSwitch"
+    ]
+  }
+  path("/switches/turnoff/:id") {
+    action: [
+      GET: "turnOffSwitch"
+    ]
+  }
+  path("/switches/:id") {
+    action: [
+      GET: "getSwitchStatus"
     ]
   }
 }
@@ -128,12 +221,149 @@ mappings {
 //API Methods
 def getAllDevices() {
 	def locks_list = locks.collect{device(it,"Lock")}
+    def contact_list = contact.collect{device(it,"Contact Sensor")}
+    def smokes_list = smoke_alarms.collect{device(it,"Smoke Alarm")}
+    def shades_list = shades.collect{device(it,"Window Shade")}
+    def garage_list = garage.collect{device(it,"Garage Door")}
+    def water_sensors_list = water_sensors.collect{device(it,"Water Sensor")}
     def presences_list = presence_sensors.collect{device(it,"Presence")}
     def motions_list = motions.collect{device(it,"Motion")}
-    def outlets_list = outlets.collect{device(it,"Outlet")}
+  /**  def outlets_list = outlets.collect{device(it,"Outlet")} */
     def switches_list = switches.collect{device(it,"Switch")}
     def temp_list = temperature_sensors.collect{device(it,"Temperature")}
-    return [Locks: locks_list, Presences: presences_list, Motions: motions_list, Outlets: outlets_list, Switches: switches_list, Temperatures: temp_list]
+    def meters_list = meters.collect{device(it,"Power Meters")}
+    def battery_list = batteries.collect{device(it,"Batteries")}
+    return smokes_list + contact_list + water_sensors_list + shades_list + garage_list + locks_list + presences_list + motions_list + switches_list + temp_list + meters_list + battery_list
+}
+
+//contact sensors
+def getContactStatus() {
+	def device = contact.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	def args = getTempSensorsStatus(device.id)
+        	return [Device_state: device.currentValue('contact')] + args
+        }
+}
+
+//smoke detectors
+def getSmokeStatus() {
+	def device = smoke_alarms.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        def bat = getBatteryStatus(device.id)
+        	return [Device_state: device.currentValue('smoke')] + bat
+        }
+}
+
+//garage
+def getGarageStatus() {
+	def device = garage.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('door')]
+        }
+}
+
+def openGarage() {
+    def device = garage.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.open();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
+
+def closeGarage() {
+	def device = garage.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.close();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
+//shades
+def getShadeStatus() {
+	def device = shades.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('windowShade')]
+        }
+}
+
+def openShade() {
+    def device = shades.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.open();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
+    
+def presetShade() {
+    def device = shades.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.presetPosition();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
+
+def closeShade() {
+	def device = shades.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.close();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
+
+//water sensor
+def getWaterSensorStatus() {
+	def device = water_sensors.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	def bat = getBatteryStatus(device.id)
+        	return [Device_state: device.currentValue('water')] + bat
+        }
+}
+//batteries
+def getBatteryStatus() {
+	def device = batteries.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.latestValue("battery")]
+        }
+}
+
+def getBatteryStatus(id) {
+	def device = batteries.find { it.id == id }
+    if (!device) {
+            return []
+        } else {
+        	return [battery_state: device.latestValue("battery")]
+        }
 }
 
 //LOCKS
@@ -142,30 +372,34 @@ def getDoorLockStatus() {
     if (!device) {
             httpError(404, "Device not found")
         } else {
-        	return [Device_state: device.currentValue('lock')]
+        	def bat = getBatteryStatus(device.id)
+        	return [Device_state: device.currentValue('lock')] + bat
         }
 }
 
-def updateDoorLock() {
+def lockDoorLock() {
-	def command = params.command
     def device = locks.find { it.id == params.id }
-    if (command){
     if (!device) {
             httpError(404, "Device not found")
         } else {
-            if(command == "toggle")
+            
-            {
-                if(device.currentValue('lock') == "locked")
-                  device.unlock();
-                else
             device.lock();
                   
             return [Device_id: params.id, result_action: "200"]                              
             }
     }
-    }
-}
 
+def unlockDoorLock() {
+	def device = locks.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.unlock();
+                  
+            return [Device_id: params.id, result_action: "200"]                              
+            }
+    }
 //PRESENCE
 def getPresenceStatus() {
 
@@ -173,7 +407,8 @@ def getPresenceStatus() {
     if (!device) {
             httpError(404, "Device not found")
         } else {
-        	return [Device_state: device.currentValue('presence')]
+        def bat = getBatteryStatus(device.id)
+        	return [Device_state: device.currentValue('presence')] + bat
    }
 }
 
@@ -184,62 +419,111 @@ def getMotionStatus() {
     if (!device) {
             httpError(404, "Device not found")
         } else {
-        	return [Device_state: device.currentValue('motion')]
+        	def args = getTempSensorsStatus(device.id)
+        	return [Device_state: device.currentValue('motion')] + args
    }
 }
 
 //OUTLET
+/**
 def getOutletStatus() {
 	
     def device = outlets.find { it.id == params.id }
    	if (!device) {
             httpError(404, "Device not found")
         } else {
-        	return [Device_state: device.currentSwitch, Current_watt: device.currentValue("energy")]
+        	def watt = getMeterStatus(device.id)
+        	return [Device_state: device.currentSwitch] + watt
+  }
+}
+*/
+def getMeterStatus() {
+	
+    def device = meters.find { it.id == params.id }
+   	if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_id: device.id, Device_type: device.type, Current_watt: device.currentValue("power")]
   }
 }
 
-def updateOutlet() {
+def getMeterStatus(id) {
 	
-    def command = params.command
+    def device = meters.find { it.id == id }
+   	if (!device) {
+            return []
+        } else {
+        	return [Current_watt: device.currentValue("power")]
+  }
+}
+
+/**
+def turnOnOutlet() {
     def device = outlets.find { it.id == params.id }
     if (command){
         if (!device) {
             httpError(404, "Device not found")
         } else {
-            if(command == "toggle")
+            
-            {
-                if(device.currentSwitch == "on")
-                  device.off();
-                else
             device.on();
                   
             return [Device_id: params.id, result_action: "200"]
         }
     }
 }
+
+def turnOffOutlet() {
+    def device = outlets.find { it.id == params.id }
+    if (command){
+        if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.off();
+                  
+            return [Device_id: params.id, result_action: "200"]
+        }
+    }
+}
+*/
+//SWITCH
+def getSwitchStatus() {
+	def device = switches.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('switch')]
+	}
 }
 
-//SWITCH
+def turnOnSwitch() {
-def updateSwitch() {
-    def command = params.command
     def device = switches.find { it.id == params.id }
     if (command){
         if (!device) {
             httpError(404, "Device not found")
         } else {
-            if(command == "toggle")
+            
-            {
-                if(device.currentSwitch == "on")
-                  device.off();
-                else
             device.on();
                   
             return [Device_id: params.id, result_action: "200"]
         }
     }
 }
+
+def turnOffSwitch() {
+    def device = switches.find { it.id == params.id }
+    if (command){
+        if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            
+            device.on();
+                  
+            return [Device_id: params.id, result_action: "200"]
         }
+    }
+}
+
 
 //TEMPERATURE
 def getTempSensorsStatus() {
@@ -248,6 +532,17 @@ def getTempSensorsStatus() {
     if (!device) {
             httpError(404, "Device not found")
         } else {
-        	return [Device_state: device.currentValue('temperature')]
+        	def bat = getBatteryStatus(device.id)
+        	return [Device_state: device.currentValue('temperature')] + bat
+   }
+}
+   
+def getTempSensorsStatus(id) {	
+    def device = temperature_sensors.find { it.id == id }
+    if (!device) {
+            return []
+        } else {
+        	def bat = getBatteryStatus(device.id)
+        	return [temperature: device.currentValue('temperature')] + bat
    		}
    }

smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy

@@ -1,461 +0,0 @@
-/**
- *  OpenT2T SmartApp Test
- *
- *  Copyright 2016 OpenT2T
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-definition(
-		name: "OpenT2T SmartApp Test",
-		namespace: "opent2t",
-		author: "OpenT2T",
-		description: "Test app to test end to end SmartThings scenarios via OpenT2T",
-		category: "SmartThings Labs",
-		iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
-		iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
-		iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png")
-
-/** --------------------+---------------+-----------------------+------------------------------------
- *  Device Type         | Attribute Name| Commands              | Attribute Values
- *  --------------------+---------------+-----------------------+------------------------------------
- *  switches            | switch        | on, off               | on, off
- *  motionSensors       | motion        |                       | active, inactive
- *  contactSensors      | contact       |                       | open, closed
- *  presenceSensors     | presence      |                       | present, 'not present'
- *  temperatureSensors  | temperature   |                       | <numeric, F or C according to unit>
- *  accelerationSensors | acceleration  |                       | active, inactive
- *  waterSensors        | water         |                       | wet, dry
- *  lightSensors        | illuminance   |                       | <numeric, lux>
- *  humiditySensors     | humidity      |                       | <numeric, percent>
- *  locks               | lock          | lock, unlock          | locked, unlocked
- *  garageDoors         | door          | open, close           | unknown, closed, open, closing, opening
- *  cameras             | image         | take                  | <String>
- *  thermostats         | thermostat    | setHeatingSetpoint,   | temperature, heatingSetpoint, coolingSetpoint,
- * 	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
- *                      |				| off, heat, cool, auto,| thermostatFanMode, thermostatOperatingState
- *                      |				| emergencyHeat,        |
- *                      |				| setThermostatMode,    |
- *                      |				| fanOn, fanAuto,       |
- *                      |				| fanCirculate,         |
- *                      |				| setThermostatFanMode  |
- *  --------------------+---------------+-----------------------+------------------------------------
- */
-
-//Device Inputs
-preferences {
-	section("Allow <PLACEHOLDER: Your App Name> to control these things...") {
-		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false
-		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false
-		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
-		input "cameras", "capability.videoCapture", title: "Which Cameras?", multiple: true, required: false
-		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false
-		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false
-		input "switches", "capability.switch", title: "Which Switches and Lights?", multiple: true, required: false
-		input "thermostats", "capability.thermostat", title: "Which Thermostat?", multiple: true, required: false
-		input "waterSensors", "capability.waterSensor", title: "Which Water Leak Sensors?", multiple: true, required: false
-	}
-}
-
-def getInputs() {
-	def inputList = []
-	inputList += contactSensors ?: []
-	inputList += garageDoors ?: []
-	inputList += locks ?: []
-	inputList += cameras ?: []
-	inputList += motionSensors ?: []
-	inputList += presenceSensors ?: []
-	inputList += switches ?: []
-	inputList += thermostats ?: []
-	inputList += waterSensors ?: []
-	return inputList
-}
-
-//API external Endpoints
-mappings {
-	path("/subscriptionURL/:url") {
-		action:
-		[
-				PUT: "updateEndpointURL"
-		]
-	}
-	path("/connectionId/:connId") {
-		action:
-		[
-				PUT: "updateConnectionId"
-		]
-	}
-	path("/devices") {
-		action:
-		[
-				GET: "getDevices"
-		]
-	}
-	path("/devices/:id") {
-		action:
-		[
-				GET: "getDevice"
-		]
-	}
-	path("/update/:id") {
-		action:
-		[
-				PUT: "updateDevice"
-		]
-	}
-	path("/subscription/:id") {
-		action:
-		[
-				POST  : "registerDeviceChange",
-				DELETE: "unregisterDeviceChange"
-		]
-	}
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-	unsubscribe()
-	registerSubscriptions()
-}
-
-def initialize() {
-	state.connectionId = ""
-	state.endpointURL = "https://ifs.windows-int.com/v1/cb/81C7E77B-EABC-488A-B2BF-FEC42F0DABD2/notify"
-	registerSubscriptions()
-}
-
-//Subscribe events for all devices
-def registerSubscriptions() {
-	registerChangeHandler(inputs)
-}
-
-//Subscribe to events from a list of devices
-def registerChangeHandler(myList) {
-	myList.each { myDevice ->
-		def theAtts = myDevice.supportedAttributes
-		theAtts.each { att ->
-			subscribe(myDevice, att.name, eventHandler)
-			log.info "Registering ${myDevice.displayName}.${att.name}"
-		}
-	}
-}
-
-//Endpoints function: Subscribe to events from a specific device
-def registerDeviceChange() {
-	def myDevice = findDevice(params.id)
-	def theAtts = myDevice.supportedAttributes
-	try {
-		theAtts.each { att ->
-			subscribe(myDevice, att.name, eventHandler)
-			log.info "Registering ${myDevice.displayName}.${att.name}"
-		}
-		return ["succeed"]
-	} catch (e) {
-		httpError(500, "something went wrong: $e")
-	}
-}
-
-//Endpoints function: Unsubscribe to events from a specific device
-def unregisterDeviceChange() {
-	def myDevice = findDevice(params.id)
-	try {
-		unsubscribe(myDevice)
-		log.info "Unregistering ${myDevice.displayName}"
-		return ["succeed"]
-	} catch (e) {
-		httpError(500, "something went wrong: $e")
-	}
-}
-
-//When events are triggered, send HTTP post to web socket servers
-def eventHandler(evt) {
-	def evt_device_id = evt.deviceId
-	def evt_device_value = evt.value
-	def evt_name = evt.name
-	def evt_device = evt.device
-	def evt_deviceType = getDeviceType(evt_device);
-	def params = [
-			uri : "${state.endpointURL}/${state.connectionId}",
-			body: [
-					name        : evt_device.displayName,
-					id          : evt_device.id,
-					deviceType  : evt_deviceType,
-					manufacturer: evt_device.getManufacturerName(),
-					model       : evt_device.getModelName(),
-					attributes  : deviceAttributeList(evt_device)
-			]
-	]
-	try {
-		log.trace "POST URI: ${params.uri}"
-		log.trace "Payload: ${params.body}"
-		httpPostJson(params) { resp ->
-			resp.headers.each {
-				log.debug "${it.name} : ${it.value}"
-			}
-			log.trace "response status code: ${resp.status}"
-			log.trace "response data: ${resp.data}"
-		}
-	} catch (e) {
-		log.debug "something went wrong: $e"
-	}
-}
-
-//Endpoints function: update subcription endpoint url [state.endpoint]
-void updateEndpointURL() {
-	state.endpointURL = params.url
-	log.info "Updated EndpointURL to ${state.endpointURL}"
-}
-
-//Endpoints function: update global variable [state.connectionId]
-void updateConnectionId() {
-	def connId = params.connId
-	state.connectionId = connId
-	log.info "Updated ConnectionID to ${state.connectionId}"
-}
-
-//Endpoints function: return all device data in json format
-def getDevices() {
-	def deviceData = []
-	inputs?.each {
-		def deviceType = getDeviceType(it)
-		if (deviceType == "thermostat") {
-			deviceData << [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
-		} else {
-			deviceData << [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it)]
-		}
-	}
-
-	log.debug "getDevices, return: ${deviceData}"
-	return deviceData
-}
-
-//Endpoints function: get device data
-def getDevice() {
-	def it = findDevice(params.id)
-	def deviceType = getDeviceType(it)
-	def device
-	if (deviceType == "thermostat") {
-		device = [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
-	} else {
-		device = [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it)]
-	}
-	log.debug "getDevice, return: ${device}"
-	return device
-}
-
-//Endpoints function: update device data
-void updateDevice() {
-	def device = findDevice(params.id)
-	request.JSON.each {
-		def command = it.key
-		def value = it.value
-		if (command) {
-			def commandList = mapDeviceCommands(command, value)
-			command = commandList[0]
-			value = commandList[1]
-
-			if (command == "setAwayMode") {
-				log.info "Setting away mode to ${value}"
-				if (location.modes?.find { it.name == value }) {
-					location.setMode(value)
-				}
-			} else if (command == "thermostatSetpoint") {
-				switch (device.currentThermostatMode) {
-					case "cool":
-						log.info "Update: ${device.displayName}, [${command}, ${value}]"
-						device.setCoolingSetpoint(value)
-						break
-					case "heat":
-					case "emergency heat":
-						log.info "Update: ${device.displayName}, [${command}, ${value}]"
-						device.setHeatingSetpoint(value)
-						break
-					default:
-						httpError(501, "this mode: ${device.currentThermostatMode} does not allow changing thermostat setpoint.")
-						break
-				}
-			} else if (!device) {
-				log.error "updateDevice, Device not found"
-				httpError(404, "Device not found")
-			} else if (!device.hasCommand(command)) {
-				log.error "updateDevice, Device does not have the command"
-				httpError(404, "Device does not have such command")
-			} else {
-				if (command == "setColor") {
-					log.info "Update: ${device.displayName}, [${command}, ${value}]"
-					device."$command"(hex: value)
-				} else if (value.isNumber()) {
-					def intValue = value as Integer
-					log.info "Update: ${device.displayName}, [${command}, ${intValue}(int)]"
-					device."$command"(intValue)
-				} else if (value) {
-					log.info "Update: ${device.displayName}, [${command}, ${value}]"
-					device."$command"(value)
-				} else {
-					log.info "Update: ${device.displayName}, [${command}]"
-					device."$command"()
-				}
-			}
-		}
-	}
-}
-
-/*** Private Functions ***/
-
-//Return current location mode info
-private getLocationModeInfo() {
-	return [mode: location.mode, supported: location.modes.name]
-}
-
-//Map each device to a type given it's capabilities
-private getDeviceType(device) {
-	def deviceType
-	def caps = device.capabilities
-	log.debug "capabilities: [${device}, ${caps}]"
-	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
-	caps.each {
-		switch (it.name.toLowerCase()) {
-			case "switch":
-				deviceType = "switch"
-				break
-			case "switch level":
-				deviceType = "light"
-				break
-			case "contact sensor":
-				deviceType = "contactSensor"
-				break
-			case "garageDoorControl":
-				deviceType = "garageDoor"
-				break
-			case "lock":
-				deviceType = "lock"
-				break
-			case "video camera":
-				deviceType = "camera"
-				break
-			case "motion sensor":
-				deviceType = "motionSensor"
-				break
-			case "presence sensor":
-				deviceType = "presenceSensor"
-				break
-			case "thermostat":
-				deviceType = "thermostat"
-				break
-			case "water sensor":
-				deviceType = "waterSensor"
-				break
-			default:
-				break
-		}
-	}
-	return deviceType
-}
-
-//Return a specific device give the device ID.
-private findDevice(deviceId) {
-	return inputs?.find { it.id == deviceId }
-}
-
-//Return a list of device attributes
-private deviceAttributeList(device) {
-	device.supportedAttributes.collectEntries { attribute ->
-		try {
-			[(attribute.name): device.currentValue(attribute.name)]
-		} catch (e) {
-			[(attribute.name): null]
-		}
-	}
-}
-
-//Map device command and value.
-//input command and value are from UWP,
-//returns resultCommand and resultValue that corresponds with function and value in SmartApps
-private mapDeviceCommands(command, value) {
-	log.debug "mapDeviceCommands: [${command}, ${value}]"
-	def resultCommand = command
-	def resultValue = value
-	switch (command) {
-		case "switch":
-			if (value == 1 || value == "1" || value == "on") {
-				resultCommand = "on"
-				resultValue = ""
-			} else if (value == 0 || value == "0" || value == "off") {
-				resultCommand = "off"
-				resultValue = ""
-			}
-			break
-	// light attributes
-		case "level":
-			resultCommand = "setLevel"
-			resultValue = value
-			break
-		case "hue":
-			resultCommand = "setHue"
-			resultValue = value
-			break
-		case "saturation":
-			resultCommand = "setSaturation"
-			resultValue = value
-			break
-		case "ct":
-			resultCommand = "setColorTemperature"
-			resultValue = value
-			break
-		case "color":
-			resultCommand = "setColor"
-			resultValue = value
-	// thermostat attributes
-		case "hvacMode":
-			resultCommand = "setThermostatMode"
-			resultValue = value
-			break
-		case "fanMode":
-			resultCommand = "setThermostatFanMode"
-			resultValue = value
-			break
-		case "awayMode":
-			resultCommand = "setAwayMode"
-			resultValue = value
-			break
-		case "coolingSetpoint":
-			resultCommand = "setCoolingSetpoint"
-			resultValue = value
-			break
-		case "heatingSetpoint":
-			resultCommand = "setHeatingSetpoint"
-			resultValue = value
-			break
-		case "thermostatSetpoint":
-			resultCommand = "thermostatSetpoint"
-			resultValue = value
-			break
-	// lock attributes
-		case "locked":
-			if (value == 1 || value == "1" || value == "lock") {
-				resultCommand = "lock"
-				resultValue = ""
-			} else if (value == 0 || value == "0" || value == "unlock") {
-				resultCommand = "unlock"
-				resultValue = ""
-			}
-			break
-		default:
-			break
-	}
-
-	return [resultCommand, resultValue]
-}
-

smartapps/osotech/plantlink-connector.src/plantlink-connector.groovy

@@ -137,7 +137,6 @@ def dock_sensor(device_serial, expected_plant_name) {
             contentType: "application/json",
     ]
     log.debug "Creating new plant on myplantlink.com - ${expected_plant_name}"
-    try {
     httpPost(docking_params) { docking_response ->
         if (parse_api_response(docking_response, "Docking a link")) {
             if (docking_response.data.plants.size() == 0) {
@@ -146,7 +145,6 @@ def dock_sensor(device_serial, expected_plant_name) {
                 plant_post_body_map['links_key'] = [docking_response.data.key]
                 def plant_post_body_json_builder = new JsonBuilder(plant_post_body_map)
                 plant_post_params["body"] = plant_post_body_json_builder.toString()
-                    try {
                 httpPost(plant_post_params) { plant_post_response ->
                     if(parse_api_response(plant_post_response, 'creating plant')){
                         def attached_map = atomicState.attached_sensors
@@ -154,9 +152,6 @@ def dock_sensor(device_serial, expected_plant_name) {
                         atomicState.attached_sensors = attached_map
                     }
                 }
-                    } catch (Exception f) {
-                        log.debug "call failed $f"
-                    }
             } else {
                 def plant = docking_response.data.plants[0]
                 def attached_map = atomicState.attached_sensors
@@ -166,9 +161,6 @@ def dock_sensor(device_serial, expected_plant_name) {
             }
         }
     }
-    } catch (Exception e) {
-        log.debug "call failed $e"
-    }
     return true
 }
 
@@ -186,13 +178,9 @@ def checkAndUpdatePlantIfNeeded(plant, expected_plant_name){
         ]
         def plant_put_body_json_builder = new JsonBuilder(plant_put_body_map)
         plant_put_params["body"] = plant_put_body_json_builder.toString()
-        try {
         httpPut(plant_put_params) { plant_put_response ->
             parse_api_response(plant_put_response, 'updating plant name')
         }
-        } catch (Exception e) {
-            log.debug "call failed $e"
-        }
     }
 }
 
@@ -210,7 +198,6 @@ def moistureHandler(event){
                 contentType: "application/json",
                 body: event.value
         ]
-        try {
         httpPost(measurement_post_params) { measurement_post_response ->
             if (parse_api_response(measurement_post_response, 'creating moisture measurement') &&
                     measurement_post_response.data.size() >0){
@@ -231,9 +218,6 @@ def moistureHandler(event){
                 }
             }
         }
-        } catch (Exception e) {
-            log.debug "call failed $e"
-        }
     }
 }
 
@@ -251,13 +235,9 @@ def batteryHandler(event){
                 contentType: "application/json",
                 body: event.value
         ]
-        try {
         httpPost(measurement_post_params) { measurement_post_response ->
             parse_api_response(measurement_post_response, 'creating battery measurement')
         }
-        } catch (Exception e) {
-            log.debug "call failed $e"
-        }
     }
 }
 
@@ -295,13 +275,9 @@ def swapToken(){
     ]
 
     def jsonMap
-    try {
     httpPost(postParams) { resp ->
         jsonMap = resp.data
     }
-    } catch (Exception e) {
-        log.debug "call failed $e"
-    }
 
     atomicState.refreshToken = jsonMap.refresh_token
     atomicState.authToken = jsonMap.access_token

smartapps/smartthings/hue-connect.src/hue-connect.groovy

@@ -177,21 +177,6 @@ def bulbDiscovery() {
 		}
 	}
 
-	if (bulbRefreshCount > 200 && numFound == 0) {
-		// Time out to avoid endless discovery
-		state.inBulbDiscovery = false
-		bulbRefreshCount = 0
-		return dynamicPage(name:"bulbDiscovery", title:"Light Discovery Failed!", nextPage:"", refreshInterval:0, install:true, uninstall: true) {
-			section("Failed to discover any lights, please try again later. Click Done to exit.") {
-				//input "selectedBulbs", "enum", required:false, title:"Select Hue Lights to add (${numFound} found)", multiple:true, submitOnChange: true, options:newLights
-				paragraph title: "Previously added Hue Lights (${existingLights.size()} added)", existingLightsDescription
-			}
-			section {
-				href "bridgeDiscovery", title: title, description: "", state: selectedHue ? "complete" : "incomplete", params: [override: true]
-			}
-		}
-
-	} else {
 	return dynamicPage(name:"bulbDiscovery", title:"Light Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 		section("Please wait while we discover your Hue Lights. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
 			input "selectedBulbs", "enum", required:false, title:"Select Hue Lights to add (${numFound} found)", multiple:true, submitOnChange: true, options:newLights
@@ -202,7 +187,6 @@ def bulbDiscovery() {
 		}
 	}
 }
-}
 
 private discoverBridges() {
 	sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:basic:1", physicalgraph.device.Protocol.LAN))
@@ -835,7 +819,8 @@ def parse(childDevice, description) {
 			try {
 				body = new groovy.json.JsonSlurper().parseText(bodyString)
 			} catch (all) {
-				log.warn "Parsing Body failed"
+				log.warn "Parsing Body failed - trying again..."
+				poll()
 			}
 			if (body instanceof java.util.Map) {
 				// get (poll) reponse
@@ -859,7 +844,7 @@ private sendColorEvents(device, xy, hue, sat, ct, colormode = null) {
 
 	def events = [:]
 	// For now, only care about changing color temperature if requested by user
-	if (ct != null && ct != 0 && (colormode == "ct" || (xy == null && hue == null && sat == null))) {
+	if (ct != null && (colormode == "ct" || (xy == null && hue == null && sat == null))) {
 		// for some reason setting Hue to their specified minimum off 153 yields 154, dealt with below
 		// 153 (6500K) to 500 (2000K)
 		def temp = (ct == 154) ? 6500 : Math.round(1000000 / ct)