MSA-1435: Create connection between Ubi device and Smartthings device.

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

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2016 SmartThings
+ *  Copyright 2015 SmartThings
  *
  *  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:
@@ -11,133 +11,100 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+/*
+ * Capabilities
+ * - Battery
+ * - Configuration
+ * - Refresh
+ * - Switch
+ * - Valve
+*/
 
 metadata {
-    definition (name: "ZigBee Valve", namespace: "smartthings", author: "SmartThings") {
-        capability "Actuator"
-        capability "Battery"
-        capability "Configuration"
-        capability "Power Source"
-        capability "Refresh"
-        capability "Valve"
+	definition (name: "Zigbee Valve", namespace: "smartthings", author: "SmartThings") {
+		capability "Battery"
+		capability "Configuration"
+		capability "Refresh"
+		capability "Switch"
+		capability "Valve"
 
-        fingerprint profileId: "0104", inClusters: "0000, 0001, 0003, 0006, 0020, 0B02, FC02", outClusters: "0019", manufacturer: "WAXMAN", model: "leakSMART Water Valve v2.10", deviceJoinName: "leakSMART Valve"
-        fingerprint profileId: "0104", inClusters: "0000, 0001, 0003, 0004, 0005, 0006, 0008, 000F, 0020, 0B02", outClusters: "0003, 0019", manufacturer: "WAXMAN", model: "House Water Valve - MDL-TBD", deviceJoinName: "Waxman House Water Valve"
-    }
+		fingerprint profileId: "0104", inClusters: "0000,0001,0003,0004,0005,0020,0006,0B02", outClusters: "0003"
+	}
 
-    // simulator metadata
-    simulator {
-        // status messages
-        status "on": "on/off: 1"
-        status "off": "on/off: 0"
+	// simulator metadata
+	simulator {
+		// status messages
+		status "on": "on/off: 1"
+		status "off": "on/off: 0"
 
-        // reply messages
-        reply "zcl on-off on": "on/off: 1"
-        reply "zcl on-off off": "on/off: 0"
-    }
+		// reply messages
+		reply "zcl on-off on": "on/off: 1"
+		reply "zcl on-off off": "on/off: 0"
+	}
 
-    tiles(scale: 2) {
-        multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
-                attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#53a7c0", nextState:"closing"
-                attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#e86d13", nextState:"opening"
-                attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#53a7c0", nextState:"closing"
-                attributeState "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#e86d13", nextState:"opening"
-            }
-            tileAttribute ("powerSource", key: "SECONDARY_CONTROL") {
-                attributeState "powerSource", label:'Power Source: ${currentValue}'
-            }
-        }
-
-        valueTile("battery", "device.battery", inactiveLabel:false, decoration:"flat", width:2, height:2) {
-            state "battery", label:'${currentValue}% battery', unit:""
-        }
-
-        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        main(["valve"])
-        details(["valve", "battery", "refresh"])
-    }
+	// UI tile definitions
+	tiles {
+		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "off", label: 'closed', action: "switch.on", icon: "st.Outdoor.outdoor16", backgroundColor: "#e86d13"
+			state "on", label: 'open', action: "switch.off", icon: "st.Outdoor.outdoor16", backgroundColor: "#53a7c0"
+		}
+		main "switch"
+		details(["switch"])
+	}
 }
 
-private getCLUSTER_BASIC() { 0x0000 }
-private getBASIC_ATTR_POWER_SOURCE() { 0x0007 }
-private getCLUSTER_POWER() { 0x0001 }
-private getPOWER_ATTR_BATTERY_PERCENTAGE_REMAINING() { 0x0021 }
-private getTYPE_U8() { 0x20 }
-private getTYPE_ENUM8() { 0x30 }
-
 // Parse incoming device messages to generate events
 def parse(String description) {
-    log.debug "description is $description"
-    def event = zigbee.getEvent(description)
-    if (event) {
-        if(event.name == "switch") {
-            event.name = "contact"                  //0006 cluster in valve is tied to contact
-            if(event.value == "on") {
-                event.value = "open"
-            }
-            else if(event.value == "off") {
-                event.value = "closed"
-            }
-        }
-        sendEvent(event)
-    }
-    else {
-        def descMap = zigbee.parseDescriptionAsMap(description)
-        if (descMap.clusterInt == CLUSTER_BASIC && descMap.attrInt == BASIC_ATTR_POWER_SOURCE){
-            def value = descMap.value
-            if (value == "01" || value == "02") {
-                sendEvent(name: "powerSource", value: "Mains")
-            }
-            else if (value == "03") {
-                sendEvent(name: "powerSource", value: "Battery")
-            }
-            else if (value == "04") {
-                sendEvent(name: "powerSource", value: "DC")
-            }
-            else {
-                sendEvent(name: "powerSource", value: "Unknown")
-            }
-        }
-        else if (descMap.clusterInt == CLUSTER_POWER && descMap.attrInt == POWER_ATTR_BATTERY_PERCENTAGE_REMAINING) {
-            event.name = "battery"
-            event.value = Math.round(Integer.parseInt(descMap.value, 16) / 2)
-            sendEvent(event)
-        }
-        else {
-            log.warn "DID NOT PARSE MESSAGE for description : $description"
-            log.debug descMap
-        }
-    }
+	log.info description
+	if (description?.startsWith("catchall:")) {
+        def value = name == "switch" ? (description?.endsWith(" 1") ? "on" : "off") : null
+		def result = createEvent(name: name, value: value)
+        def msg = zigbee.parse(description)
+		log.debug "Parse returned ${result?.descriptionText}"
+		return result
+		log.trace msg
+		log.trace "data: $msg.data"
+	}
+	else {
+		def name = description?.startsWith("on/off: ") ? "switch" : null
+		def value = name == "switch" ? (description?.endsWith(" 1") ? "on" : "off") : null
+		def result = createEvent(name: name, value: value)
+		log.debug "Parse returned ${result?.descriptionText}"
+		return result
+	}
+}
+
+// Commands to device
+def on() {
+	log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
+}
+
+def off() {
+	log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+	"st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
 }
 
 def open() {
-    zigbee.on()
+	log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
 
 def close() {
-    zigbee.off()
+	log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+	"st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
 }
 
 def refresh() {
-    log.debug "refresh called"
-    zigbee.onOffRefresh() +
-    zigbee.readAttribute(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE) +
-    zigbee.readAttribute(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING) +
-    zigbee.onOffConfig() +
-    zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING, TYPE_U8, 600, 21600, 1) +
-    zigbee.configureReporting(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE, TYPE_ENUM8, 5, 21600, 1)
+	log.debug "sending refresh command"
+	"st rattr 0x${device.deviceNetworkId} 1 6 0"
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() +
-    zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING, TYPE_U8, 600, 21600, 1) +
-    zigbee.configureReporting(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE, TYPE_ENUM8, 5, 21600, 1) +
-    zigbee.onOffRefresh() +
-    zigbee.readAttribute(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE) +
-    zigbee.readAttribute(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING)
+
+	"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}"
 }

devicetypes/smartthings/zwave-lock-reporting.src/zwave-lock-reporting.groovy

@@ -1,683 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  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.
- *
- */
-metadata {
-	definition (name: "Z-Wave Lock Reporting", namespace: "smartthings", author: "SmartThings") {
-		capability "Actuator"
-		capability "Lock"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
-		capability "Lock Codes"
-		capability "Battery"
-
-		command "unlockwtimeout"
-
-		fingerprint deviceId: "0x4003", inClusters: "0x98"
-		fingerprint deviceId: "0x4004", inClusters: "0x98"
-	}
-
-	simulator {
-		status "locked": "command: 9881, payload: 00 62 03 FF 00 00 FE FE"
-		status "unlocked": "command: 9881, payload: 00 62 03 00 00 00 FE FE"
-
-		reply "9881006201FF,delay 4200,9881006202": "command: 9881, payload: 00 62 03 FF 00 00 FE FE"
-		reply "988100620100,delay 4200,9881006202": "command: 9881, payload: 00 62 03 00 00 00 FE FE"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"toggle", type: "generic", width: 6, height: 4){
-			tileAttribute ("device.lock", key: "PRIMARY_CONTROL") {
-				attributeState "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#79b821", nextState:"unlocking"
-				attributeState "unlocked", label:'unlocked', action:"lock.lock", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff", nextState:"locking"
-				attributeState "unknown", label:"unknown", action:"lock.lock", icon:"st.locks.lock.unknown", backgroundColor:"#ffffff", nextState:"locking"
-				attributeState "locking", label:'locking', icon:"st.locks.lock.locked", backgroundColor:"#79b821"
-				attributeState "unlocking", label:'unlocking', icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
-			}
-		}
-		standardTile("lock", "device.lock", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'lock', action:"lock.lock", icon:"st.locks.lock.locked", nextState:"locking"
-		}
-		standardTile("unlock", "device.lock", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'unlock', action:"lock.unlock", icon:"st.locks.lock.unlocked", nextState:"unlocking"
-		}
-		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "battery", label:'${currentValue}% battery', unit:""
-		}
-		standardTile("refresh", "device.lock", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main "toggle"
-		details(["toggle", "lock", "unlock", "battery", "refresh"])
-	}
-}
-
-import physicalgraph.zwave.commands.doorlockv1.*
-import physicalgraph.zwave.commands.usercodev1.*
-
-def updated() {
-	try {
-		if (!state.init) {
-			state.init = true
-			response(secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()]))
-		}
-	} catch (e) {
-		log.warn "updated() threw $e"
-	}
-}
-
-def parse(String description) {
-	def result = null
-	if (description.startsWith("Err 106")) {
-		if (state.sec) {
-			result = createEvent(descriptionText:description, displayed:false)
-		} else {
-			result = createEvent(
-				descriptionText: "This lock failed to complete the network security key exchange. If you are unable to control it via SmartThings, you must remove it from your network and add it again.",
-				eventType: "ALERT",
-				name: "secureInclusion",
-				value: "failed",
-				displayed: true,
-			)
-		}
-	} else if (description == "updated") {
-		return null
-	} else {
-		def cmd = zwave.parse(description, [ 0x98: 1, 0x72: 2, 0x85: 2, 0x86: 1 ])
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
-	}
-	log.debug "\"$description\" parsed to ${result.inspect()}"
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x62: 1, 0x71: 2, 0x80: 1, 0x85: 2, 0x63: 1, 0x98: 1, 0x86: 1])
-	// log.debug "encapsulated: $encapsulatedCommand"
-	if (encapsulatedCommand) {
-		zwaveEvent(encapsulatedCommand)
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.NetworkKeyVerify cmd) {
-	createEvent(name:"secureInclusion", value:"success", descriptionText:"Secure inclusion was successful")
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-	state.sec = cmd.commandClassSupport.collect { String.format("%02X ", it) }.join()
-	if (cmd.commandClassControl) {
-		state.secCon = cmd.commandClassControl.collect { String.format("%02X ", it) }.join()
-	}
-	log.debug "Security command classes: $state.sec"
-	createEvent(name:"secureInclusion", value:"success", descriptionText:"Lock is securely included")
-}
-
-def zwaveEvent(DoorLockOperationReport cmd) {
-	def result = []
-	def map = [ name: "lock" ]
-	if (cmd.doorLockMode == 0xFF) {
-		map.value = "locked"
-	} else if (cmd.doorLockMode >= 0x40) {
-		map.value = "unknown"
-	} else if (cmd.doorLockMode & 1) {
-		map.value = "unlocked with timeout"
-	} else {
-		map.value = "unlocked"
-		if (state.assoc != zwaveHubNodeId) {
-			log.debug "setting association"
-			result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
-			result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
-			result << response(secure(zwave.associationV1.associationGet(groupingIdentifier:1)))
-		}
-	}
-	result ? [createEvent(map), *result] : createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd) {
-	def result = []
-	def map = null
-	if (cmd.zwaveAlarmType == 6) {
-		if (1 <= cmd.zwaveAlarmEvent && cmd.zwaveAlarmEvent < 10) {
-			map = [ name: "lock", value: (cmd.zwaveAlarmEvent & 1) ? "locked" : "unlocked" ]
-		}
-		switch(cmd.zwaveAlarmEvent) {
-			case 1:
-				map.descriptionText = "$device.displayName was manually locked"
-				break
-			case 2:
-				map.descriptionText = "$device.displayName was manually unlocked"
-				break
-			case 5:
-				if (cmd.eventParameter) {
-					map.descriptionText = "$device.displayName was locked with code ${cmd.eventParameter.first()}"
-					map.data = [ usedCode: cmd.eventParameter[0] ]
-				}
-				break
-			case 6:
-				if (cmd.eventParameter) {
-					map.descriptionText = "$device.displayName was unlocked with code ${cmd.eventParameter.first()}"
-					map.data = [ usedCode: cmd.eventParameter[0] ]
-				}
-				break
-			case 9:
-				map.descriptionText = "$device.displayName was autolocked"
-				break
-			case 7:
-			case 8:
-			case 0xA:
-				map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName was not locked fully" ]
-				break
-			case 0xB:
-				map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName is jammed" ]
-				break
-			case 0xC:
-				map = [ name: "codeChanged", value: "all", descriptionText: "$device.displayName: all user codes deleted", isStateChange: true ]
-				allCodesDeleted()
-				break
-			case 0xD:
-				if (cmd.eventParameter) {
-					map = [ name: "codeReport", value: cmd.eventParameter[0], data: [ code: "" ], isStateChange: true ]
-					map.descriptionText = "$device.displayName code ${map.value} was deleted"
-					map.isStateChange = (state["code$map.value"] != "")
-					state["code$map.value"] = ""
-				} else {
-					map = [ name: "codeChanged", descriptionText: "$device.displayName: user code deleted", isStateChange: true ]
-				}
-				break
-			case 0xE:
-				map = [ name: "codeChanged", value: cmd.alarmLevel,  descriptionText: "$device.displayName: user code added", isStateChange: true ]
-				if (cmd.eventParameter) {
-					map.value = cmd.eventParameter[0]
-					result << response(requestCode(cmd.eventParameter[0]))
-				}
-				break
-			case 0xF:
-				map = [ name: "codeChanged", descriptionText: "$device.displayName: user code not added, duplicate", isStateChange: true ]
-				break
-			case 0x10:
-				map = [ name: "tamper", value: "detected", descriptionText: "$device.displayName: keypad temporarily disabled", displayed: true ]
-				break
-			case 0x11:
-				map = [ descriptionText: "$device.displayName: keypad is busy" ]
-				break
-			case 0x12:
-				map = [ name: "codeChanged", descriptionText: "$device.displayName: program code changed", isStateChange: true ]
-				break
-			case 0x13:
-				map = [ name: "tamper", value: "detected", descriptionText: "$device.displayName: code entry attempt limit exceeded", displayed: true ]
-				break
-			default:
-				map = map ?: [ descriptionText: "$device.displayName: alarm event $cmd.zwaveAlarmEvent", displayed: false ]
-				break
-		}
-	} else if (cmd.zwaveAlarmType == 7) {
-		map = [ name: "tamper", value: "detected", displayed: true ]
-		switch (cmd.zwaveAlarmEvent) {
-			case 0:
-				map.value = "clear"
-				map.descriptionText = "$device.displayName: tamper alert cleared"
-				break
-			case 1:
-			case 2:
-				map.descriptionText = "$device.displayName: intrusion attempt detected"
-				break
-			case 3:
-				map.descriptionText = "$device.displayName: covering removed"
-				break
-			case 4:
-				map.descriptionText = "$device.displayName: invalid code"
-				break
-			default:
-				map.descriptionText = "$device.displayName: tamper alarm $cmd.zwaveAlarmEvent"
-				break
-		}
-	} else switch(cmd.alarmType) {
-		case 21:  // Manually locked
-		case 18:  // Locked with keypad
-		case 24:  // Locked by command (Kwikset 914)
-		case 27:  // Autolocked
-			map = [ name: "lock", value: "locked" ]
-			break
-		case 16:  // Note: for levers this means it's unlocked, for non-motorized deadbolt, it's just unsecured and might not get unlocked
-		case 19:
-			map = [ name: "lock", value: "unlocked" ]
-			if (cmd.alarmLevel) {
-				map.descriptionText = "$device.displayName was unlocked with code $cmd.alarmLevel"
-				map.data = [ usedCode: cmd.alarmLevel ]
-			}
-			break
-		case 22:
-		case 25:  // Kwikset 914 unlocked by command
-			map = [ name: "lock", value: "unlocked" ]
-			break
-		case 9:
-		case 17:
-		case 23:
-		case 26:
-			map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName bolt is jammed" ]
-			break
-		case 13:
-			map = [ name: "codeChanged", value: cmd.alarmLevel, descriptionText: "$device.displayName code $cmd.alarmLevel was added", isStateChange: true ]
-			result << response(requestCode(cmd.alarmLevel))
-			break
-		case 32:
-			map = [ name: "codeChanged", value: "all", descriptionText: "$device.displayName: all user codes deleted", isStateChange: true ]
-			allCodesDeleted()
-			break
-		case 33:
-			map = [ name: "codeReport", value: cmd.alarmLevel, data: [ code: "" ], isStateChange: true ]
-			map.descriptionText = "$device.displayName code $cmd.alarmLevel was deleted"
-			map.isStateChange = (state["code$cmd.alarmLevel"] != "")
-			state["code$cmd.alarmLevel"] = ""
-			break
-		case 112:
-			map = [ name: "codeChanged", value: cmd.alarmLevel, descriptionText: "$device.displayName code $cmd.alarmLevel changed", isStateChange: true ]
-			result << response(requestCode(cmd.alarmLevel))
-			break
-		case 130:  // Yale YRD batteries replaced
-			map = [ descriptionText: "$device.displayName batteries replaced", isStateChange: true ]
-			break
-		case 131:
-			map = [ /*name: "codeChanged", value: cmd.alarmLevel,*/ descriptionText: "$device.displayName code $cmd.alarmLevel is duplicate", isStateChange: false ]
-			break
-		case 161:
-			if (cmd.alarmLevel == 2) {
-				map = [ descriptionText: "$device.displayName front escutcheon removed", isStateChange: true ]
-			} else {
-				map = [ descriptionText: "$device.displayName detected failed user code attempt", isStateChange: true ]
-			}
-			break
-		case 167:
-			if (!state.lastbatt || now() - state.lastbatt > 12*60*60*1000) {
-				map = [ descriptionText: "$device.displayName: battery low", isStateChange: true ]
-				result << response(secure(zwave.batteryV1.batteryGet()))
-			} else {
-				map = [ name: "battery", value: device.currentValue("battery"), descriptionText: "$device.displayName: battery low", displayed: true ]
-			}
-			break
-		case 168:
-			map = [ name: "battery", value: 1, descriptionText: "$device.displayName: battery level critical", displayed: true ]
-			break
-		case 169:
-			map = [ name: "battery", value: 0, descriptionText: "$device.displayName: battery too low to operate lock", isStateChange: true ]
-			break
-		default:
-			map = [ displayed: false, descriptionText: "$device.displayName: alarm event $cmd.alarmType level $cmd.alarmLevel" ]
-			break
-	}
-	result ? [createEvent(map), *result] : createEvent(map)
-}
-
-def zwaveEvent(UserCodeReport cmd) {
-	def result = []
-	def name = "code$cmd.userIdentifier"
-	def code = cmd.code
-	def map = [:]
-	if (cmd.userIdStatus == UserCodeReport.USER_ID_STATUS_OCCUPIED ||
-		(cmd.userIdStatus == UserCodeReport.USER_ID_STATUS_STATUS_NOT_AVAILABLE && cmd.user && code != "**********"))
-	{
-		if (code == "**********") {  // Schlage locks send us this instead of the real code
-			state.blankcodes = true
-			code = state["set$name"] ?: decrypt(state[name]) ?: code
-			state.remove("set$name".toString())
-		}
-		if (!code && cmd.userIdStatus == 1) {  // Schlage touchscreen sends blank code to notify of a changed code
-			map = [ name: "codeChanged", value: cmd.userIdentifier, displayed: true, isStateChange: true ]
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier " + (state[name] ? "changed" : "was added")
-			code = state["set$name"] ?: decrypt(state[name]) ?: "****"
-			state.remove("set$name".toString())
-		} else {
-			map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: code ] ]
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier is set"
-			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = true
-		}
-		result << createEvent(map)
-	} else {
-		map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: "" ] ]
-		if (state.blankcodes && state["reset$name"]) {  // we deleted this code so we can tell that our new code gets set
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier was reset"
-			map.displayed = map.isStateChange = true
-			result << createEvent(map)
-			state["set$name"] = state["reset$name"]
-			result << response(setCode(cmd.userIdentifier, state["reset$name"]))
-			state.remove("reset$name".toString())
-		} else {
-			if (state[name]) {
-				map.descriptionText = "$device.displayName code $cmd.userIdentifier was deleted"
-			} else {
-				map.descriptionText = "$device.displayName code $cmd.userIdentifier is not set"
-			}
-			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = true
-			result << createEvent(map)
-		}
-		code = ""
-	}
-	state[name] = code ? encrypt(code) : code
-
-	if (cmd.userIdentifier == state.requestCode) {  // reloadCodes() was called, keep requesting the codes in order
-		if (state.requestCode + 1 > state.codes || state.requestCode >= 30) {
-			state.remove("requestCode")  // done
-		} else {
-			state.requestCode = state.requestCode + 1  // get next
-			result << response(requestCode(state.requestCode))
-		}
-	}
-	if (cmd.userIdentifier == state.pollCode) {
-		if (state.pollCode + 1 > state.codes || state.pollCode >= 30) {
-			state.remove("pollCode")  // done
-		} else {
-			state.pollCode = state.pollCode + 1
-		}
-	}
-	log.debug "code report parsed to ${result.inspect()}"
-	result
-}
-
-def zwaveEvent(UsersNumberReport cmd) {
-	def result = []
-	state.codes = cmd.supportedUsers
-	if (state.requestCode && state.requestCode <= cmd.supportedUsers) {
-		result << response(requestCode(state.requestCode))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {
-	def result = []
-	if (cmd.nodeId.any { it == zwaveHubNodeId }) {
-		state.remove("associationQuery")
-		log.debug "$device.displayName is associated to $zwaveHubNodeId"
-		result << createEvent(descriptionText: "$device.displayName is associated")
-		state.assoc = zwaveHubNodeId
-		if (cmd.groupingIdentifier == 2) {
-			result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-		}
-	} else if (cmd.groupingIdentifier == 1) {
-		result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
-	} else if (cmd.groupingIdentifier == 2) {
-		result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.timev1.TimeGet cmd) {
-	def result = []
-	def now = new Date().toCalendar()
-	if(location.timeZone) now.timeZone = location.timeZone
-	result << createEvent(descriptionText: "$device.displayName requested time update", displayed: false)
-	result << response(secure(zwave.timeV1.timeReport(
-		hourLocalTime: now.get(Calendar.HOUR_OF_DAY),
-		minuteLocalTime: now.get(Calendar.MINUTE),
-		secondLocalTime: now.get(Calendar.SECOND)))
-	)
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	// The old Schlage locks use group 1 for basic control - we don't want that, so unsubscribe from group 1
-	def result = [ createEvent(name: "lock", value: cmd.value ? "unlocked" : "locked") ]
-	result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-	if (state.assoc != zwaveHubNodeId) {
-		result << response(zwave.associationV1.associationGet(groupingIdentifier:2))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [ name: "battery", unit: "%" ]
-	if (cmd.batteryLevel == 0xFF) {
-		map.value = 1
-		map.descriptionText = "$device.displayName has a low battery"
-	} else {
-		map.value = cmd.batteryLevel
-	}
-	state.lastbatt = now()
-	createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
-	def result = []
-
-	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
-	log.debug "msr: $msr"
-	updateDataValue("MSR", msr)
-
-	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {
-	def fw = "${cmd.applicationVersion}.${cmd.applicationSubVersion}"
-	updateDataValue("fw", fw)
-	if (state.MSR == "003B-6341-5044") {
-		updateDataValue("ver", "${cmd.applicationVersion >> 4}.${cmd.applicationVersion & 0xF}")
-	}
-	def text = "$device.displayName: firmware version: $fw, Z-Wave version: ${cmd.zWaveProtocolVersion}.${cmd.zWaveProtocolSubVersion}"
-	createEvent(descriptionText: text, isStateChange: false)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.applicationstatusv1.ApplicationBusy cmd) {
-	def msg = cmd.status == 0 ? "try again later" :
-	          cmd.status == 1 ? "try again in $cmd.waitTime seconds" :
-	          cmd.status == 2 ? "request queued" : "sorry"
-	createEvent(displayed: true, descriptionText: "$device.displayName is busy, $msg")
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.applicationstatusv1.ApplicationRejectedRequest cmd) {
-	createEvent(displayed: true, descriptionText: "$device.displayName rejected the last request")
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	createEvent(displayed: false, descriptionText: "$device.displayName: $cmd")
-}
-
-def lockAndCheck(doorLockMode) {
-	secureSequence([
-		zwave.doorLockV1.doorLockOperationSet(doorLockMode: doorLockMode),
-		zwave.doorLockV1.doorLockOperationGet()
-	], 4200)
-}
-
-def lock() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_SECURED)
-}
-
-def unlock() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED)
-}
-
-def unlockwtimeout() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED_WITH_TIMEOUT)
-}
-
-def refresh() {
-	def cmds = [secure(zwave.doorLockV1.doorLockOperationGet())]
-	if (state.assoc == zwaveHubNodeId) {
-		log.debug "$device.displayName is associated to ${state.assoc}"
-	} else if (!state.associationQuery) {
-		log.debug "checking association"
-		cmds << "delay 4200"
-		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()  // old Schlage locks use group 2 and don't secure the Association CC
-		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = now()
-	} else if (secondsPast(state.associationQuery, 9)) {
-		cmds << "delay 6000"
-		cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
-		cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
-		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = now()
-	}
-	log.debug "refresh sending ${cmds.inspect()}"
-	cmds
-}
-
-def poll() {
-	def cmds = []
-	// Only check lock state if it changed recently or we haven't had an update in an hour
-	def latest = device.currentState("lock")?.date?.time
-	if (!latest || !secondsPast(latest, 6 * 60) || secondsPast(state.lastPoll, 55 * 60)) {
-		cmds << secure(zwave.doorLockV1.doorLockOperationGet())
-		state.lastPoll = now()
-	} else if (!state.lastbatt || now() - state.lastbatt > 53*60*60*1000) {
-		cmds << secure(zwave.batteryV1.batteryGet())
-		state.lastbatt = now()  //inside-214
-	}
-	if (cmds) {
-		log.debug "poll is sending ${cmds.inspect()}"
-		cmds
-	} else {
-		// workaround to keep polling from stopping due to lack of activity
-		sendEvent(descriptionText: "skipping poll", isStateChange: true, displayed: false)
-		null
-	}
-
-    reportAllCodes(state)
-}
-
-def requestCode(codeNumber) {
-	secure(zwave.userCodeV1.userCodeGet(userIdentifier: codeNumber))
-}
-
-def reloadAllCodes() {
-	def cmds = []
-	if (!state.codes) {
-		state.requestCode = 1
-		cmds << secure(zwave.userCodeV1.usersNumberGet())
-	} else {
-		if(!state.requestCode) state.requestCode = 1
-		cmds << requestCode(codeNumber)
-	}
-	cmds
-}
-
-def setCode(codeNumber, code) {
-	def strcode = code
-	log.debug "setting code $codeNumber to $code"
-	if (code instanceof String) {
-		code = code.toList().findResults { if(it > ' ' && it != ',' && it != '-') it.toCharacter() as Short }
-	} else {
-		strcode = code.collect{ it as Character }.join()
-	}
-	if (state.blankcodes) {
-		// Can't just set, we won't be able to tell if it was successful
-		if (state["code$codeNumber"] != "") {
-			if (state["setcode$codeNumber"] != strcode) {
-				state["resetcode$codeNumber"] = strcode
-				return deleteCode(codeNumber)
-			}
-		} else {
-			state["setcode$codeNumber"] = strcode
-		}
-	}
-	secureSequence([
-		zwave.userCodeV1.userCodeSet(userIdentifier:codeNumber, userIdStatus:1, user:code),
-		zwave.userCodeV1.userCodeGet(userIdentifier:codeNumber)
-	], 7000)
-}
-
-def deleteCode(codeNumber) {
-	log.debug "deleting code $codeNumber"
-	secureSequence([
-		zwave.userCodeV1.userCodeSet(userIdentifier:codeNumber, userIdStatus:0),
-		zwave.userCodeV1.userCodeGet(userIdentifier:codeNumber)
-	], 7000)
-}
-
-def updateCodes(codeSettings) {
-	if(codeSettings instanceof String) codeSettings = util.parseJson(codeSettings)
-	def set_cmds = []
-	def get_cmds = []
-	codeSettings.each { name, updated ->
-		def current = decrypt(state[name])
-		if (name.startsWith("code")) {
-			def n = name[4..-1].toInteger()
-			log.debug "$name was $current, set to $updated"
-			if (updated?.size() >= 4 && updated != current) {
-				def cmds = setCode(n, updated)
-				set_cmds << cmds.first()
-				get_cmds << cmds.last()
-			} else if ((current && updated == "") || updated == "0") {
-				def cmds = deleteCode(n)
-				set_cmds << cmds.first()
-				get_cmds << cmds.last()
-			} else if (updated && updated.size() < 4) {
-				// Entered code was too short
-				codeSettings["code$n"] = current
-			}
-		} else log.warn("unexpected entry $name: $updated")
-	}
-	if (set_cmds) {
-		return response(delayBetween(set_cmds, 2200) + ["delay 2200"] + delayBetween(get_cmds, 4200))
-	}
-}
-
-def getCode(codeNumber) {
-	decrypt(state["code$codeNumber"])
-}
-
-def getAllCodes() {
-	state.findAll { it.key.startsWith 'code' }.collectEntries {
-		[it.key, (it.value instanceof String && it.value.startsWith("~")) ? decrypt(it.value) : it.value]
-	}
-}
-
-private secure(physicalgraph.zwave.Command cmd) {
-	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-}
-
-private secureSequence(commands, delay=4200) {
-	delayBetween(commands.collect{ secure(it) }, delay)
-}
-
-private Boolean secondsPast(timestamp, seconds) {
-	if (!(timestamp instanceof Number)) {
-		if (timestamp instanceof Date) {
-			timestamp = timestamp.time
-		} else if ((timestamp instanceof String) && timestamp.isNumber()) {
-			timestamp = timestamp.toLong()
-		} else {
-			return true
-		}
-	}
-	return (now() - timestamp) > (seconds * 1000)
-}
-
-private allCodesDeleted() {
-	if (state.codes instanceof Integer) {
-		(1..state.codes).each { n ->
-			if (state["code$n"]) {
-				result << createEvent(name: "codeReport", value: n, data: [ code: "" ], descriptionText: "code $n was deleted",
-					displayed: false, isStateChange: true)
-			}
-			state["code$n"] = ""
-		}
-	}
-}
-
-def reportAllCodes(state) {
-  def map = [ name: "reportAllCodes", data: [:], displayed: false, isStateChange: false, type: "physical" ]
-  state.each { entry ->
-    //iterate through all the state entries and add them to the event data to be handled by application event handlers
-    if ( entry.key ==~ /^code\d{1,}/ && entry.value.startsWith("~") ) {
-      map.data.put(entry.key, decrypt(entry.value))
-    } else {
-      map.data.put(entry.key, entry.value)
-    }
-  }
-  sendEvent(map)
-}

smartapps/com-gidjit-smartthings-hub/gidjit-hub.src/gidjit-hub.groovy

@@ -24,24 +24,17 @@ definition(
     iconX3Url: "http://www.gidjit.com/appicon@3x.png",
     oauth: [displayName: "Gidjit", displayLink: "www.gidjit.com"])
 
-preferences(oauthPage: "deviceAuthorization") {
-    // deviceAuthorization page is simply the devices to authorize
-    page(name: "deviceAuthorization", title: "Device Authorization", nextPage: "instructionPage",
-         install: false, uninstall: true) {
-  		section ("Allow Gidjit to have access, thereby allowing you to quickly control and monitor your following devices. Privacy Policy can be found at http://priv.gidjit.com/privacy.html") {
-    		input "switches", "capability.switch", title: "Control/Monitor your switches", multiple: true, required: false
-    		input "thermostats", "capability.thermostat", title: "Control/Monitor your thermostats", multiple: true, required: false
-    		input "windowShades", "capability.windowShade", title: "Control/Monitor your window shades", multiple: true, required: false //windowShade
-        }
 
-    }
-    page(name: "instructionPage", title: "Device Discovery", install: true) {
-        section() {
-            paragraph "Now the process is complete return to the Devices section of the Detected Screen. From there and you can add actions to each of your device panels, including launching SmartThings routines."
-        }
-    }
+
+preferences {
+  section ("Allow Gidjit to have access, there by allowing you to quickly control and monitor the following devices") {
+    input "switches", "capability.switch", title: "Control/Monitor your switches", multiple: true, required: false
+    input "thermostats", "capability.thermostat", title: "Control/Monitor your thermostats", multiple: true, required: false
+    input "windowShades", "capability.windowShade", title: "Control/Monitor your window shades", multiple: true, required: false //windowShade
+    //input "bulbs", "capability.colorControl", title: "Control your lights", multiple: true, required: false //windowShade
+
+  }
 }
-
 mappings {
   path("/structureinfo") {
     action: [

smartapps/ucic-io/ubi.src/ubi.groovy

@@ -0,0 +1,520 @@
+/**
+ *  Ubi
+ *
+ *  Copyright 2016 UCIC
+ *
+ *  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: "Ubi",
+    namespace: "ucic.io",
+    author: "UCIC",
+    description: "Connect Ubi with SmartThings",
+    category: "SmartThings Labs",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/ubi-app-icn.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/ubi-app-icn@2x.png",
+    iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Partner/ubi-app-icn@2x.png",
+    oauth: true)
+
+
+preferences {
+	section("Allow a web application to control these things...") {
+		input name: "switches", type: "capability.switch", title: "Which Switches?", multiple: true, required: false
+		input name: "motions", type: "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false
+		input name: "locks", type: "capability.lock", title: "Which Locks?", multiple: true, required: false
+		input name: "contactSensors", type: "capability.contactSensor", title: "Which Contact Sensors?", multiple: true, required: false
+		input name: "presenceSensors", type: "capability.presenceSensor", title: "Which Presence Sensors?", multiple: true, required: false
+	}
+}
+
+mappings {
+	path("/list") {
+		action: [
+			GET: "listAll"
+		]
+	}
+
+	path("/events/:id") {
+		action: [
+			GET: "showEvents"
+		]
+	}
+
+	path("/switches") {
+		action: [
+			GET: "listSwitches",
+			PUT: "updateSwitches",
+			POST: "updateSwitches"
+		]
+	}
+	path("/switches/:id") {
+		action: [
+			GET: "showSwitch",
+			PUT: "updateSwitch",
+			POST: "updateSwitch"
+		]
+	}
+	path("/switches/subscriptions") {
+		//log.debug "switches added"
+		action: [
+			POST: "addSwitchSubscription"
+		]
+	}
+	path("/switches/subscriptions/:id") {
+		action: [
+			DELETE: "removeSwitchSubscription",
+			GET: "removeSwitchSubscription"
+		]
+	}
+
+	path("/motionSensors") {
+		action: [
+			GET: "listMotions",
+			PUT: "updateMotions",
+			POST: "updateMotions"
+
+		]
+	}
+	path("/motionSensors/:id") {
+		action: [
+			GET: "showMotion",
+			PUT: "updateMotion",
+			POST: "updateMotion"
+		]
+	}
+	path("/motionSensors/subscriptions") {
+		//log.debug "motionSensors added"
+		action: [
+			POST: "addMotionSubscription"
+		]
+	}
+	path("/motionSensors/subscriptions/:id") {
+		//log.debug "motionSensors Deleted"
+		action: [
+			DELETE: "removeMotionSubscription",
+			GET: "removeMotionSubscription"
+		]
+	}
+
+	path("/locks") {
+		action: [
+			GET: "listLocks",
+			PUT: "updateLock",
+			POST: "updateLock"
+		]
+	}
+	path("/locks/:id") {
+		action: [
+			GET: "showLock",
+			PUT: "updateLock",
+			POST: "updateLock"
+		]
+	}
+	path("/locks/subscriptions") {
+		action: [
+			POST: "addLockSubscription"
+		]
+	}
+	path("/locks/subscriptions/:id") {
+		action: [
+			DELETE: "removeLockSubscription",
+			GET: "removeLockSubscription"
+		]
+	}
+
+	path("/contactSensors") {
+		action: [
+			GET: "listContactSensors",
+			PUT: "updateContactSensor",
+			POST: "updateContactSensor"
+		]
+	}
+	path("/contactSensors/:id") {
+		action: [
+			GET: "showContactSensor",
+			PUT: "updateContactSensor",
+			POST: "updateContactSensor"
+		]
+	}
+	path("/contactSensors/subscriptions") {
+		log.debug "contactSensors/subscriptions"
+		action: [
+			POST: "addContactSubscription"
+		]
+	}
+	path("/contactSensors/subscriptions/:id") {
+		action: [
+			DELETE: "removeContactSensorSubscription",
+			GET: "removeContactSensorSubscription"
+		]
+	}
+
+	path("/presenceSensors") {
+		action: [
+			GET: "listPresenceSensors",
+			PUT: "updatePresenceSensor",
+			POST: "updatePresenceSensor"
+		]
+	}
+	path("/presenceSensors/:id") {
+		action: [
+			GET: "showPresenceSensor",
+			PUT: "updatePresenceSensor",
+			POST: "updatePresenceSensor"
+		]
+	}
+	path("/presenceSensors/subscriptions") {
+		//log.debug "PresenceSensors/subscriptions"
+		action: [
+			POST: "addPresenceSubscription"
+		]
+	}
+	path("/presenceSensors/subscriptions/:id") {
+		action: [
+			DELETE: "removePresenceSensorSubscription",
+			GET: "removePresenceSensorSubscription"
+		]
+	}
+
+	path("/state") {
+		action: [
+			GET: "currentState"
+		]
+	}
+
+	path("/phrases") {
+		action: [
+			GET: "listPhrases"
+		]
+	}
+	path("/phrases/:phraseName") {
+		action: [
+			GET: "executePhrase",
+			POST: "executePhrase",
+		]
+	}
+
+}
+
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+
+	initialize()
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	//unsubscribe()
+	initialize()
+}
+
+def initialize() {
+	// TODO: subscribe to attributes, devices, locations, etc.
+    log.debug "initialize, do nothing..."
+}
+
+def listAll() {
+	listSwitches() + listMotions() + listLocks() + listContactSensors() + listPresenceSensors()
+}
+
+def listContactSensors() {
+	contactSensors.collect { device(it, "contactSensor") }
+}
+
+
+void updateContactSensors() {
+	updateAll(contactSensors)
+}
+
+def showContactSensor() {
+	show(contactSensors, "contact")
+}
+
+void updateContactSensor() {
+	update(contactSensors)
+}
+
+def addContactSubscription() {
+	log.debug "addContactSensorSubscription,  params: ${params}"
+	addSubscription(contactSensors, "contact")
+}
+
+def removeContactSensorSubscription() {
+	removeSubscription(contactSensors)
+}
+
+
+def listPresenceSensors() {
+	presenceSensors.collect { device(it, "presenceSensor") }
+}
+
+
+void updatePresenceSensors() {
+	updateAll(presenceSensors)
+}
+
+def showPresenceSensor() {
+	show(presenceSensors, "presence")
+}
+
+void updatePresenceSensor() {
+	update(presenceSensors)
+}
+
+def addPresenceSubscription() {
+	log.debug "addPresenceSensorSubscription,  params: ${params}"
+	addSubscription(presenceSensors, "presence")
+}
+
+def removePresenceSensorSubscription() {
+	removeSubscription(presenceSensors)
+}
+
+
+def listSwitches() {
+	switches.collect { device(it, "switch") }
+}
+
+void updateSwitches() {
+	updateAll(switches)
+}
+
+def showSwitch() {
+	show(switches, "switch")
+}
+
+void updateSwitch() {
+	update(switches)
+}
+
+def addSwitchSubscription() {
+	log.debug "addSwitchSubscription,  params: ${params}"
+	addSubscription(switches, "switch")
+}
+
+def removeSwitchSubscription() {
+	removeSubscription(switches)
+}
+
+def listMotions() {
+	motions.collect { device(it, "motionSensor") }
+}
+
+void updateMotions() {
+	updateAll(motions)
+}
+
+def showMotion() {
+	show(motions, "motion")
+}
+
+void updateMotion() {
+	update(motions)
+}
+
+def addMotionSubscription() {
+
+	addSubscription(motions, "motion")
+}
+
+def removeMotionSubscription() {
+	removeSubscription(motions)
+}
+
+def listLocks() {
+	locks.collect { device(it, "lock") }
+}
+
+void updateLocks() {
+	updateAll(locks)
+}
+
+def showLock() {
+	show(locks, "lock")
+}
+
+void updateLock() {
+	update(locks)
+}
+
+def addLockSubscription() {
+	addSubscription(locks, "lock")
+}
+
+def removeLockSubscription() {
+	removeSubscription(locks)
+}
+
+/*
+def motionOpenHandler(evt) {
+//log.trace "$evt.value: $evt, $settings"
+
+	log.debug "$motions was active, sending push message to user"
+	//sendPush("Your ${contact1.label ?: contact1.name} was opened")
+
+
+	httpPostJson(uri: "http://automatesolutions.ca/test.php", path: '', body: [evt: [value: "motionSensor Active"]]) {
+	log.debug "Event data successfully posted"
+    }
+
+}
+def contactOpenHandler(evt) {
+	//log.trace "$evt.value: $evt, $settings"
+
+	log.debug "$contactSensors was opened, sending push message to user"
+	//sendPush("Your ${contact1.label ?: contact1.name} was opened")
+
+
+	httpPostJson(uri: "http://automatesolutions.ca/test.php", path: '', body: [evt: [value: "ContactSensor Opened"]]) {
+	log.debug "Event data successfully posted"
+    }
+
+
+}
+*/
+
+
+def deviceHandler(evt) {
+	log.debug "~~~~~TEST~~~~~~"
+	def deviceInfo = state[evt.deviceId]
+	if (deviceInfo)
+	{
+		httpPostJson(uri: deviceInfo.callbackUrl, path: '', body: [evt: [value: evt.value]]) {
+			log.debug "Event data successfully posted"
+		}
+	}
+	else
+	{
+		log.debug "No subscribed device found"
+	}
+}
+
+def currentState() {
+	state
+}
+
+def showStates() {
+	def device = (switches + motions + locks).find { it.id == params.id }
+	if (!device)
+	{
+		httpError(404, "Switch not found")
+	}
+	else
+	{
+		device.events(params)
+	}
+}
+
+def listPhrases() {
+	location.helloHome.getPhrases().label
+}
+
+def executePhrase() {
+	def phraseName = params.phraseName
+	if (phraseName)
+	{
+		location.helloHome.execute(phraseName)
+		log.debug "executed phrase: $phraseName"
+	}
+	else
+	{
+		httpError(404, "Phrase not found")
+	}
+}
+
+private void updateAll(devices) {
+	def command = request.JSON?.command
+	if (command)
+	{
+		command = command.toLowerCase()
+		devices."$command"()
+	}
+}
+
+private void update(devices) {
+	log.debug "update, request: ${request.JSON}, params: ${params}, devices: $devices.id"
+	//def command = request.JSON?.command
+	def command = params.command
+	if (command)
+	{
+		command = command.toLowerCase()
+		def device = devices.find { it.id == params.id }
+		if (!device)
+		{
+			httpError(404, "Device not found")
+		}
+		else
+		{
+			device."$command"()
+		}
+	}
+}
+
+private show(devices, type) {
+	def device = devices.find { it.id == params.id }
+	if (!device)
+	{
+		httpError(404, "Device not found")
+	}
+	else
+	{
+
+		def attributeName = type
+
+
+
+		def s = device.currentState(attributeName)
+		[id: device.id, label: device.displayName, value: s?.value, unitTime: s?.date?.time, type: type]
+	}
+}
+
+private addSubscription(devices, attribute) {
+	//def deviceId = request.JSON?.deviceId
+	//def callbackUrl = request.JSON?.callbackUrl
+
+	log.debug "addSubscription,  params: ${params}"
+
+	def deviceId = params.deviceId
+	def callbackUrl = params.callbackUrl
+
+
+
+
+	def myDevice = devices.find { it.id == deviceId }
+	if (myDevice)
+	{
+		if (state[deviceId])
+		{
+			log.debug "Switch subscription already exists, unsubcribing"
+			unsubscribe(myDevice)
+		}
+		log.debug "Adding switch subscription" + callbackUrl
+		state[deviceId] = [callbackUrl: callbackUrl]
+		log.debug "Added state: $state"
+		subscribe(myDevice, attribute, deviceHandler)
+	}
+}
+
+private removeSubscription(devices) {
+	def deviceId = params.id
+	def device = devices.find { it.id == deviceId }
+	if (device)
+	{
+		log.debug "Removing $device.displayName subscription"
+		state.remove(device.id)
+		unsubscribe(device)
+	}
+}
+
+private device(it, type) {
+	it ? [id: it.id, label: it.displayName, type: type] : null
+}