MSA-1956: The Lloyds Connect & Protect SmartApp is a bridge between SmartThings Cloud and Lloyds Banking Group to enable advanced connected device monitoring and alerting features to be included in the offering to their customers for the connected home service

Rolling down staging to master

smartapps/domotz-dev/lloyds-banking-group-connect-protect.src/lloyds-banking-group-connect-protect.groovy

@@ -0,0 +1,273 @@
+/**
+ *  Lloyds Banking Group Connect & Protect
+ *
+ *  Copyright 2016 Domotz
+ *
+ *  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: "Lloyds Banking Group Connect & Protect",
+        namespace: "domotz.dev",
+        author: "Domotz",
+        description: "The Lloyds Connect & Protect SmartApp is a bridge between SmartThings Cloud and Lloyds Banking Group to enable advanced connected device monitoring and alerting features to be included in the offering to their customers for the connected home service",
+        category: "Convenience",
+        singleInstance: true,
+        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",
+        oauth: [displayName: "Lloyds Banking Group Connect & Protect", displayLink: ""]) {
+    appSetting "endpointRetrievalUrl"
+    appSetting "xApiKey"
+}
+
+def getSupportedTypes() {
+    return [
+            [obj: switches, name: "switches", attribute: "switch", capability: "switch", title: "Switches"],
+            [obj: motions, name: "motions", attribute: "motion", capability: "motionSensor", title: "Motion Sensors"],
+            [obj: temperature, name: "temperature", attribute: "temperature", capability: "temperatureMeasurement", title: "Temperature Sensors"],
+            [obj: contact, name: "contact", attribute: "contact", capability: "contactSensor", title: "Contact Sensors"],
+            [obj: presence, name: "presence", attribute: "presence", capability: "presenceSensor", title: "Presence Sensors"],
+            [obj: water, name: "water", attribute: "water", capability: "waterSensor", title: "Water Sensors"],
+            [obj: smoke, name: "smoke", attribute: "smoke", capability: "smokeDetector", title: "Smoke Sensors"],
+            [obj: battery, name: "battery", attribute: "battery", capability: "battery", title: "Batteries"]
+    ]
+}
+
+preferences {
+    section("Allow Lloyds Banking Group Connect & Protect service to monitor these devices") {
+        for (type in getSupportedTypes()) {
+            input type.get("name"), "capability.${type.get('capability')}", title: type.get('title'), multiple: true
+        }
+    }
+}
+
+def installed() {
+    initialize()
+}
+
+def updated() {
+    unsubscribe()
+    initialize()
+    hubUpdateHandler()
+
+}
+
+def getRequestHeaders() {
+    return ['Accept': '*/*', 'X-API-KEY': appSettings.xApiKey]
+}
+
+def subscribeToDeviceEvents() {
+    for (type in getSupportedTypes()) {
+        subscribe(type.get("obj"), "${type.get("attribute")}", genericDeviceEventHandler)
+    }
+}
+
+def initialize() {
+    if (atomicState.endpoint != null) {
+        log.debug "Detected endpoint: ${atomicState.endpoint}"
+        subscribeToDeviceEvents()
+        subscribe(location, "routineExecuted", modeChangeHandler)
+        subscribe(location, "mode", modeChangeHandler)
+    } else {
+        log.debug "There is no endpoint, requesting domotz for a new one"
+        requestNewEndpoint()
+    }
+}
+
+
+def getHubLocation() {
+    def location_info = [:]
+    location_info['uid'] = location.id
+    //location_info['hubs'] = location.hubs
+    location_info['latitude'] = location.latitude
+    location_info['longitude'] = location.longitude
+    location_info['current_mode'] = location.mode
+    //location_info['modes'] = location.modes
+    location_info['name'] = location.name
+    location_info['temperature_scale'] = location.temperatureScale
+    location_info['version'] = location.version
+    location_info['channel_name'] = location.channelName
+    location_info['zip_code'] = location.zipCode
+    log.debug "Triggered getHubLocation with properties: ${location_info}"
+    return location_info
+}
+
+def modeChangeHandler(evt) {
+    log.debug "mode changed to ${evt.value}"
+    def url = null
+    if (atomicState.endpoint != null) {
+        url = atomicState.endpoint + '/hub-change'
+
+        httpPutJson(
+                uri: url,
+                body: getHubLocation(),
+                headers: getRequestHeaders()
+        )
+    } else {
+        log.debug "There is no endpoint, requesting domotz for a new one"
+        requestNewEndpoint()
+    }
+
+}
+
+def genericDeviceEventHandler(event) {
+    log.debug "Device Event Handler, event properties: ${event.getProperties().toString()}"
+    log.debug "Device Event Handler, value: ${event.value}"
+    def resp = [:]
+    def url = null
+    def device = null
+
+    device = getDevice(event.device, resp)
+
+    url = atomicState.endpoint + "/device/" + device.provider_uid + "/${event.name}"
+
+    log.debug "Device Event Handler, put url: ${url}"
+    log.debug "Device Event Handler, put body: value: ${event.value}\ndate: ${event.isoDate}"
+    httpPutJson(
+            uri: url,
+            body: [
+                    "value": event.value,
+                    "time" : event.isoDate
+            ],
+            headers: getRequestHeaders()
+    )
+}
+
+
+def hubUpdateHandler() {
+    log.debug "Hub Update Handler, with settings: ${settings}"
+    def url = null
+    def deviceList = [:]
+
+    if (atomicState.endpoint != null) {
+        url = atomicState.endpoint + '/device-list'
+        log.debug "Hub Update Event Handler, put url: ${url}"
+        deviceList = getDeviceList()
+        httpPutJson(
+                uri: url,
+                body: deviceList,
+                headers: getRequestHeaders()
+        )
+    } else {
+        log.debug "There is no endpoint, requesting domotz for a new one"
+        requestNewEndpoint()
+    }
+}
+
+
+
+def getDeviceList() {
+    try {
+
+        def resp = [:]
+        def attribute = null
+
+        for (type in getSupportedTypes()) {
+            type.get("obj").each {
+                device = getDevice(it, resp)
+                attribute = type.get("attribute")
+                if (it.currentState(attribute)) {
+                    device['attributes'][attribute] = [
+                            "value": it.currentState(attribute).value,
+                            "time" : it.currentState(attribute).getIsoDate(),
+                            "unit" : it.currentState(attribute).unit
+                    ]
+                }
+
+            }
+        }
+        return resp
+    } catch (e) {
+        log.debug("caught exception", e)
+        return [:]
+    }
+}
+
+def getDevice(it, resp) {
+    if (resp[it.id]) {
+        return resp[it.id]
+    }
+    resp[it.id] = [name: it.name, display_name: it.displayName, provider_uid: it.id, type: it.typeName, label: it.label, manufacturer_name: it.manufacturerName, model: it.modelName, attributes: [:]]
+
+}
+
+def activateMonitoring(resp) {
+    unsubscribe()
+    log.debug "Event monitoring activated for endpoint: ${request.JSON.endpoint}"
+    atomicState.endpoint = request.JSON.endpoint
+    log.debug "Event monitoring activated for endpoint: ${atomicState.endpoint}"
+    initialize()
+}
+
+def deactivateMonitoring() {
+    log.debug "Event monitoring deactivated."
+    atomicState.endpoint = null
+    unsubscribe()
+}
+
+def requestNewEndpoint() {
+    log.debug "Requesting a new endpoint."
+    def hubId = location.id
+    def params = [
+            uri    : "${appSettings.endpointRetrievalUrl}/${hubId}/endpoint",
+            headers: getRequestHeaders()
+    ]
+
+    try {
+        httpGet(params) { response ->
+            log.debug "Request was successful, received endpoint: ${response.data.endpoint}"
+            atomicState.endpoint = response.data.endpoint
+            subscribeToDeviceEvents()
+        }
+    }
+    catch (e) {
+        log.debug "Unable to retrieve the endpoint"
+    }
+
+}
+
+def handleClientUninstall() {
+	log.info("Deactivated from client")
+	try {
+		app.delete()
+	} catch (e) {
+		unschedule()
+		unsubscribe()
+		httpError(500, "An error occurred during deleting SmartApp: ${e}")
+	}
+}
+
+mappings {
+    path("/device") {
+        action:
+        [
+                GET: getDeviceList
+        ]
+    }
+    path("/location") {
+        action:
+        [
+                GET: getHubLocation
+        ]
+    }
+    path("/monitoring") {
+        action:
+        [
+                POST  : activateMonitoring,
+                DELETE: deactivateMonitoring
+        ]
+    }
+    path("/uninstall") {
+        action
+        [GET: handleClientUninstall]
+    }
+}

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

@@ -1,7 +1,3 @@
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import java.security.InvalidKeyException;
-
 /**
  *  OpenT2T SmartApp Test
  *
@@ -85,33 +81,28 @@ def getInputs() {
 //API external Endpoints
 mappings {
 	path("/devices") {
-		action:
+		action: [
-		[
 				GET: "getDevices"
 		]
 	}
 	path("/devices/:id") {
-		action:
+		action: [
-		[
 				GET: "getDevice"
 		]
 	}
 	path("/update/:id") {
-		action:
+		action: [
-		[
 				PUT: "updateDevice"
 		]
 	}
 	path("/deviceSubscription") {
-		action:
+		action: [
-		[
 				POST: "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
 	path("/locationSubscription") {
-		action:
+		action: [
-		[
 				POST: "registerDeviceGraph",
 				DELETE: "unregisterDeviceGraph"
 		]
@@ -125,8 +116,6 @@ def installed() {
 
 def updated() {
 	log.debug "Updating with settings: ${settings}"
-
-	//Initialize state variables if didn't exist.
 	if(state.deviceSubscriptionMap == null){
 		state.deviceSubscriptionMap = [:]
 		log.debug "deviceSubscriptionMap created."
@@ -135,11 +124,6 @@ def updated() {
 		state.locationSubscriptionMap = [:]
 		log.debug "locationSubscriptionMap created."
 	}
-	if (state.verificationKeyMap == null) {
-		state.verificationKeyMap = [:]
-		log.debug "verificationKeyMap created."
-	}
-
 	unsubscribe()
 	registerAllDeviceSubscriptions()
 }
@@ -148,11 +132,9 @@ def initialize() {
 	log.debug "Initializing with settings: ${settings}"
 	state.deviceSubscriptionMap = [:]
 	log.debug "deviceSubscriptionMap created."
+	registerAllDeviceSubscriptions()
 	state.locationSubscriptionMap = [:]
 	log.debug "locationSubscriptionMap created."
-	state.verificationKeyMap = [:]
-	log.debug "verificationKeyMap created."
-	registerAllDeviceSubscriptions()
 }
 
 /*** Subscription Functions  ***/
@@ -162,12 +144,22 @@ def registerAllDeviceSubscriptions() {
 	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, deviceEventHandler)
+			log.info "Registering for ${myDevice.displayName}.${att.name}"
+		}
+	}
+}
+
 //Endpoints function: Subscribe to events from a specific device
 def registerDeviceChange() {
 	def subscriptionEndpt = params.subscriptionURL
 	def deviceId = params.deviceId
 	def myDevice = findDevice(deviceId)
-
 	if( myDevice == null ){
 		httpError(404, "Cannot find device with device ID ${deviceId}.")
 	}
@@ -187,18 +179,12 @@ def registerDeviceChange() {
 				state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			}
-
-			if (params.key != null) {
-				state.verificationKeyMap[subscriptionEndpt] = params.key
-				log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
-			}
 		}
 	} catch (e) {
 		httpError(500, "something went wrong: $e")
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
-	log.info "Current verification key map is ${state.verificationKeyMap}"
 	return ["succeed"]
 }
 
@@ -220,7 +206,6 @@ def unregisterDeviceChange() {
 				} else {
 					state.deviceSubscriptionMap[deviceId].remove(subscriptionEndpt)
 				}
-				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			}
 		} else {
@@ -232,7 +217,6 @@ def unregisterDeviceChange() {
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
-	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //Endpoints function: Subscribe to device additiona/removal updated in a location
@@ -251,14 +235,7 @@ def registerDeviceGraph() {
 			state.locationSubscriptionMap[location.id] << subscriptionEndpt
 			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 		}
-
-		if (params.key != null) {
-			state.verificationKeyMap[subscriptionEndpt] = params.key
-			log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
-		}
-
 		log.info "Current location subscription map is ${state.locationSubscriptionMap}"
-		log.info "Current verification key map is ${state.verificationKeyMap}"
 		return ["succeed"]
 	} else {
 		httpError(400, "missing input parameter: subscriptionURL")
@@ -277,7 +254,6 @@ def unregisterDeviceGraph() {
 				} else {
 					state.locationSubscriptionMap[location.id].remove(subscriptionEndpt)
 				}
-				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 			}
 		}else{
@@ -288,38 +264,26 @@ def unregisterDeviceGraph() {
 	}
 
 	log.info "Current location subscription map is ${state.locationSubscriptionMap}"
-	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //When events are triggered, send HTTP post to web socket servers
 def deviceEventHandler(evt) {
-	def evtDevice = evt.device
+	def evt_device = evt.device
-	def evtDeviceType = getDeviceType(evtDevice)
+	def evt_deviceType = getDeviceType(evt_device)
-	def deviceData = [];
+	def deviceInfo
+
+	def params = [ body: [deviceName: evt_device.displayName, deviceId: evt_device.id,  locationId: location.id] ]
 
 	if(evt.data != null){
 		def evtData = parseJson(evt.data)
-		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
+		log.info "Received event for ${evt_device.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
 	}
 
-	if (evtDeviceType == "thermostat") {
-		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationMode: getLocationModeInfo(), locationId: location.id]
-	} else {
-		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationId: location.id]
-	}
-
-	def params = [body: deviceData]
-
 	//send event to all subscriptions urls
-	log.debug "Current subscription urls for ${evtDevice.displayName} is ${state.deviceSubscriptionMap[evtDevice.id]}"
+	log.debug "Current subscription urls for ${evt_device.displayName} is ${state.deviceSubscriptionMap[evt_device.id]}"
-	state.deviceSubscriptionMap[evtDevice.id].each {
+	state.deviceSubscriptionMap[evt_device.id].each {
 		params.uri = "${it}"
-		if (state.verificationKeyMap[it] != null) {
-			def key = state.verificationKeyMap[it]
-			params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
-		}
 		log.trace "POST URI: ${params.uri}"
-		log.trace "Header: ${params.header}"
 		log.trace "Payload: ${params.body}"
 		try{
 			httpPostJson(params) { resp ->
@@ -337,22 +301,15 @@ def locationEventHandler(evt) {
 	switch(evt.name){
 		case "DeviceCreated":
 		case "DeviceDeleted":
-			def evtDevice = evt.device
+			def evt_device = evt.device
-			def evtDeviceType = getDeviceType(evtDevice)
+			def evt_deviceType = getDeviceType(evt_device)
-			def params = [body: [eventType: evt.name, deviceId: evtDevice.id, locationId: location.id]]
+			log.info "DeviceName: ${evt_device.displayName}, DeviceID: ${evt_device.id}, deviceType: ${evt_deviceType}"
 
-			if (evt.name == "DeviceDeleted" && state.deviceSubscriptionMap[deviceId] != null) {
+			def params = [ body: [ eventType:evt.name, deviceId: evt_device.id, locationId: location.id ] ]
-				state.deviceSubscriptionMap.remove(evtDevice.id)
-			}
 
 			state.locationSubscriptionMap[location.id].each {
 				params.uri = "${it}"
-				if (state.verificationKeyMap[it] != null) {
-					def key = state.verificationKeyMap[it]
-					params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
-				}
 				log.trace "POST URI: ${params.uri}"
-				log.trace "Header: ${params.header}"
 				log.trace "Payload: ${params.body}"
 				try{
 					httpPostJson(params) { resp ->
@@ -369,23 +326,6 @@ def locationEventHandler(evt) {
 	}
 }
 
-private ComputHMACValue(key, data) {
-	try {
-		SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
-		Mac mac = Mac.getInstance("HmacSHA1")
-		mac.init(secretKeySpec)
-		byte[] digest = mac.doFinal(data.getBytes("UTF-8"))
-		return byteArrayToString(digest)
-	} catch (InvalidKeyException e) {
-		log.error "Invalid key exception while converting to HMac SHA1"
-	}
-}
-
-private def byteArrayToString(byte[] data) {
-	BigInteger bigInteger = new BigInteger(1, data)
-	String hash = bigInteger.toString(16)
-	return hash
-}
 
 /*** Device Query/Update Functions  ***/
 
@@ -493,7 +433,8 @@ private getDeviceType(device) {
 
 	//Loop through the device capability list to determine the device type.
 	capabilities.each {capability ->
-		switch (capability.name.toLowerCase()) {
+		switch(capability.name.toLowerCase())
+		{
 			case "switch":
 				deviceType = "switch"
 
@@ -638,7 +579,8 @@ private mapDeviceCommands(command, value) {
 			if (value == 1 || value == "1" || value == "lock") {
 				resultCommand = "lock"
 				resultValue = ""
-			} else if (value == 0 || value == "0" || value == "unlock") {
+			}
+			else if (value == 0 || value == "0" || value == "unlock") {
 				resultCommand = "unlock"
 				resultValue = ""
 			}