MSA-1371: Its a prototype for connecting the largest T (Car) in the IoT eco-system

smartapps/cloudcar/cloudcar.src/cloudcar.groovy

@@ -0,0 +1,333 @@
+/**
+ *  CCTest
+ *
+ *  Copyright 2016 Kuldip
+ *
+ *  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: "CloudCar",
+    namespace: "CloudCar",
+    author: "Kuldip@CloudCar",
+    description: "Connect Car and Home",
+    category: "Convenience",
+    iconUrl: "http://justdrive.net/wp-content/themes/justdrive/assets/img/jd-logo-sans.png",
+    iconX2Url: "http://justdrive.net/wp-content/themes/justdrive/assets/img/jd-logo-sans.png",
+    iconX3Url: "http://justdrive.net/wp-content/themes/justdrive/assets/img/jd-logo-sans.png",
+    oauth: [displayName: "CloudCar", displayLink: "https://CloudCar.com"]
+)
+
+preferences {
+    section ("Control your home while driving your car") {
+                input "switches", "capability.switch", title: "Which Switches?", multiple: true, required: false
+                input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false
+                input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors?", multiple: true, required: false
+                input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors?", multiple: true, required: false
+                input "temperatureSensors", "capability.temperatureMeasurement", title: "Which Temperature Sensors?", multiple: true, required: false
+                input "accelerationSensors", "capability.accelerationSensor", title: "Which Vibration Sensors?", multiple: true, required: false
+                input "waterSensors", "capability.waterSensor", title: "Which Water Sensors?", multiple: true, required: false
+                input "lightSensors", "capability.illuminanceMeasurement", title: "Which Light Sensors?", multiple: true, required: false
+                input "humiditySensors", "capability.relativeHumidityMeasurement", title: "Which Relative Humidity Sensors?", multiple: true, required: false
+                input "alarms", "capability.alarm", title: "Which Sirens?", multiple: true, required: false
+                input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
+    }
+}
+
+mappings {
+    path("/scan") {
+        action: [
+            GET: "scanDevices"
+        ]
+    }
+    path("/control/:command") {
+        action: [
+            GET: "updateSwitches"
+        ]
+    }
+    path("/control/:deviceType/:deviceId/:command") {
+        action: [
+            GET: "updateDevice"
+        ]
+    }
+}
+
+def installed() {
+    log.debug "[installed]: state ${state}"
+    initialize ()
+}
+
+def uninstalled() {
+        log.debug "[uninstalled]: ${settings}"
+}
+
+def updated () {
+	log.debug "[updated]: ${settings}"
+    unsubscribe()
+    initialize ()
+}
+
+def initialize () {
+    state.clear() // clear previous state - state is loaded from persistant store
+    addSubscription()
+}
+ 
+def addSubscription() {
+	def callbackUrl = 'http://ec2-54-67-21-37.us-west-1.compute.amazonaws.com/notify' //data.callbackUrl
+    log.debug "[addSubscription]  state ${state}"
+    log.debug "[addSubscription]  settings ${settings}"
+	settings.each {
+		log.debug "[addSubscription]  settings ${it}"
+    }
+    
+    def currentDeviceIds = settings.collect { k, devices -> devices }.flatten().collect()// { it.id }.unique()
+    log.debug "[addSubscription]  currentDeviceIds  ${currentDeviceIds}"
+	currentDeviceIds.each {
+        log.debug "[addSubscription]  device ids ${it} - ${it.id}"
+        log.debug "Adding switch subscription " + callbackUrl
+		state[it.id] = [callbackUrl: callbackUrl]
+    }
+	subscribe(switches, "switch.on", mydeviceHandler)
+	subscribe(contactSensors, "contact.open", mydeviceHandler)
+    subscribe(motionSensors, "motion.active", mydeviceHandler)
+	log.debug "[addSubscription] COMPLETED ${state}"
+}
+
+def mydeviceHandler(evt) {
+	def callbackUrl = 'http://ec2-54-67-21-37.us-west-1.compute.amazonaws.com/notify' //data.callbackUrl
+	//def callbackUrl = 'https://testing.justdrive.cloudcar.com/notify/5c5dca5f-1b98-fff9-f111-8072b41c5fb3'
+	log.debug "[deviceHandler] $evt.displayName"
+	def deviceInfo = state[evt.deviceId]
+    log.debug "[deviceHandler] deviceInfo ${deviceInfo}"
+	if (deviceInfo) {
+		try {
+				httpPostJson(uri: callbackUrl, path: '',  body: [deviceId: evt.deviceId, deviceType: evt.name, deviceName: evt.displayName, value: evt.value]) {   
+				log.debug "[deviceHandler] Event data successfully posted"
+			}
+		} catch (groovyx.net.http.ResponseParseException e) {
+			log.debug("Error parsing payload ${e}")
+		}
+	} else {
+		log.debug "[deviceHandler] No subscribed device found"
+	}
+}
+
+
+def scanDevices() {
+        log.debug "[scandevices] ${type}"
+        [
+        switches: switches.collect{KPdevice(it,"switches")},
+        contactSensors: contacts.collect{KPdevice(it,"contactSensors")},
+        temperatures: temperatures.collect{KPdevice(it,"temperature")},
+        ]
+}
+
+private KPdevice(it, type) {
+	def device_state = null
+    log.debug "KPDevice it: ${it}"
+	if (it.currentValue("switch") == "on" ) {
+        device_state = [label:it.label, type:type, id:it.id]
+			for (attribute in it.supportedAttributes) {
+				device_state."${attribute}" = it.currentValue("${attribute}")
+			}
+		}
+		log.debug "KPdevice: ${device_state}"
+		device_state ? device_state : null
+}
+
+def void updateSwitches() {
+	// use the built-in request object to get the command parameter
+	def command = params.command
+	log.debug "updateSwitches: ${params.command}"
+    // all switches have the command
+    // execute the command on all switches
+    // (note we can do this on the array - the command will be invoked on every element
+
+    switch(command) {
+        case "on":
+            switches.on()
+            break
+        case "off":
+            switches.off()
+            break
+        default:
+            httpError(400, "$command is not a valid command for all switches specified")
+    }
+}
+
+def void updateDevice() {
+	// use the built-in request object to get the command parameter
+	def command = params.command
+    def deviceId = params.deviceId
+    def devices = settings[params.deviceType]
+
+    log.debug "[updateDevice] ${deviceId} - ${command} - ${devices}"
+    
+    // all switches have the command
+    // execute the command on all switches
+    // (note we can do this on the array - the command will be invoked on every element
+	def device = devices.find { it.id == deviceId }
+	if (!device) {
+		httpError(404, "Device not found")
+	} else {
+		device."$command"()
+	}
+}
+
+def list() {
+        log.debug "[PROD] list, params: ${params}"
+        def type = params.deviceType
+        settings[type]?.collect{deviceItem(it)} ?: []
+}
+
+def listStates() {
+        log.debug "[PROD] liststates, params: ${params}"
+        def type = params.deviceType
+        def attributeName = attributeFor(type)
+        settings[type]?.collect{deviceState(it, it.currentState(attributeName))} ?: []
+}
+
+def listSubscriptions() {
+        log.debug "[PROD] listSubscription, params: ${params}"
+        state
+}
+
+def update() {
+        def type = params.deviceType
+        def data = request.JSON
+        def devices = settings[type]
+        def device = settings[type]?.find { it.id == params.id }
+        def command = data.command
+
+        log.debug "[PROD] update, params: ${params}, request: ${data}, devices: ${devices*.id}"
+
+        if (!device) {
+                httpError(404, "Device not found")
+        }
+
+        if (validateCommand(device, type, command)) {
+                device."$command"()
+        } else {
+                httpError(403, "Access denied. This command is not supported by current capability.")
+        }
+}
+
+/**
+ * Validating the command passed by the user based on capability.
+
+ * @return boolean
+ */
+def validateCommand(device, deviceType, command) {
+        log.debug "[validatecommand] ${device} ${deviceType} ${command}"
+        def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
+        def currentDeviceCapability = getCapabilityName(deviceType)
+        if (capabilityCommands[currentDeviceCapability]) {
+                return command in capabilityCommands[currentDeviceCapability] ? true : false
+        } else {
+                // Handling other device types here, which don't accept commands
+                httpError(400, "Bad request.")
+        }
+}
+
+/**
+ * Need to get the attribute name to do the lookup. Only
+ * doing it for the device types which accept commands
+ * @return attribute name of the device type
+ */
+def getCapabilityName(type) {
+        log.debug "[getCapabilityName] ${type}"
+    switch(type) {
+                case "switches":
+                        return "Switch"
+                case "alarms":
+                        return "Alarm"
+                case "locks":
+                        return "Lock"
+                default:
+                        return type
+        }
+}
+
+/**
+ * Constructing the map over here of
+ * supported commands by device capability
+ * @return a map of device capability -> supported commands
+ */
+def getDeviceCapabilityCommands(deviceCapabilities) {
+        log.debug "[getDeviceCapabilities] ${deviceCapabilities}"
+        def map = [:]
+        deviceCapabilities.collect {
+                map[it.name] = it.commands.collect{ it.name.toString() }
+        }
+        return map
+}
+
+def show() {
+        def type = params.deviceType
+        def devices = settings[type]
+        def device = devices.find { it.id == params.id }
+
+        log.debug "[PROD] show, params: ${params}, devices: ${devices*.id}"
+        if (!device) {
+                httpError(404, "Device not found")
+        }
+        else {
+                def attributeName = attributeFor(type)
+                def s = device.currentState(attributeName)
+                deviceState(device, s)
+        }
+}
+
+def removeSubscription() {
+        def type = params.deviceType
+        def devices = settings[type]
+        def deviceId = params.id
+        def device = devices.find { it.id == deviceId }
+
+        log.debug "[PROD] removeSubscription, params: ${params}, request: ${data}, device: ${device}"
+        if (device) {
+                log.debug "Removing $device.displayName subscription"
+                state.remove(device.id)
+                unsubscribe(device)
+        }
+        log.info state
+}
+
+private deviceItem(it) {
+        log.debug "[deviceItem] ${it}"
+        it ? [id: it.id, label: it.displayName] : null
+
+}
+
+private deviceState(device, s) {
+        log.debug "[deviceState] ${device}: ${s}"
+        device && s ? [id: device.id, label: device.displayName, name: s.name, value: s.value, unixTime: s.date.time] : null
+}
+
+private attributeFor(type) {
+        log.debug "[attributeFor] ${type}"
+        switch (type) {
+                case "switches":
+                        log.debug "[PROD] switch type"
+                        return "switch"
+                case "locks":
+                        log.debug "[PROD] lock type"
+                        return "lock"
+                case "alarms":
+                        log.debug "[PROD] alarm type"
+                        return "alarm"
+                case "lightSensors":
+                        log.debug "[PROD] illuminance type"
+                        return "illuminance"
+                default:
+                        log.debug "[PROD] other sensor type"
+                        return "Sensors"
+        }
+}