MSA-1372: This is an updated version of the previous, however a user can now set the preferences and permissions from an OAuth page.

Gwu exception handling

devicetypes/smartthings/zwave-door-window-sensor.src/zwave-door-window-sensor.groovy

@@ -29,6 +29,7 @@ metadata {
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x98", outClusters: "0x5A,0x82"
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x80,0x71,0x85,0x70,0x72,0x86,0x30,0x31,0x84,0x59,0x73,0x5A,0x8F,0x98,0x7A", outClusters:"0x20" // Philio multi+
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x72,0x5A,0x80,0x73,0x86,0x84,0x85,0x59,0x71,0x70,0x7A,0x98" // Vision door/window
+		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x98,0x86,0x72,0x5A,0x85,0x59,0x73,0x80,0x71,0x31,0x70,0x84,0x7A" // Vision Motion
 	}
 
 	// simulator metadata
@@ -263,5 +264,9 @@ def retypeBasedOnMSR() {
 			log.debug "Changing device type to Door / Window Sensor Plus (SG)"
 			setDeviceType("Door / Window Sensor Plus (SG)")
 			break
+		case "0109-2002-0205": // Vision Motion
+			log.debug "Changing device type to Vision Motion Sensor Plus (SG)"
+			setDeviceType("Vision Motion Sensor Plus (SG)")
+			break
 	}
 }

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

@@ -24,17 +24,24 @@ 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
+        }
 
-
-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
-
-  }
+    }
+    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."
+        }
+    }
 }
+
 mappings {
   path("/structureinfo") {
     action: [

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

@@ -337,10 +337,10 @@ def initialize() {
 
 	settings.devices.each {
 		def deviceId = it
-		def detail = state.deviceDetail[deviceId]
+		def detail = state?.deviceDetail[deviceId]
 
 		try {
-			switch(detail.type) {
+			switch(detail?.type) {
 				case 'NAMain':
 					log.debug "Base station"
 					createChildDevice("Netatmo Basestation", deviceId, "${detail.type}.${deviceId}", detail.module_name)
@@ -487,12 +487,12 @@ def poll() {
     log.debug "State: ${state.deviceState}"
 
 	settings.devices.each { deviceId ->
-		def detail = state.deviceDetail[deviceId]
-		def data = state.deviceState[deviceId]
-		def child = children.find { it.deviceNetworkId == deviceId }
+		def detail = state?.deviceDetail[deviceId]
+		def data = state?.deviceState[deviceId]
+		def child = children?.find { it.deviceNetworkId == deviceId }
 
 		log.debug "Update: $child";
-		switch(detail.type) {
+		switch(detail?.type) {
 			case 'NAMain':
 				log.debug "Updating NAMain $data"
 				child?.sendEvent(name: 'temperature', value: cToPref(data['Temperature']) as float, unit: getTemperatureScale())

smartapps/smartthings/gentle-wake-up.src/gentle-wake-up.groovy

@@ -39,6 +39,7 @@ preferences {
 	page(name: "completionPage")
 	page(name: "numbersPage")
 	page(name: "controllerExplanationPage")
+	page(name: "unsupportedDevicesPage")
 }
 
 def rootPage() {
@@ -47,6 +48,9 @@ def rootPage() {
 		section("What to dim") {
 			input(name: "dimmers", type: "capability.switchLevel", title: "Dimmers", description: null, multiple: true, required: true, submitOnChange: true)
 			if (dimmers) {
+				if (dimmersContainUnsupportedDevices()) {
+					href(name: "toUnsupportedDevicesPage", page: "unsupportedDevicesPage", title: "Some of your selected dimmers don't seem to be supported", description: "Tap here to fix it", required: true)
+				}
 				href(name: "toNumbersPage", page: "numbersPage", title: "Duration & Direction", description: numbersPageHrefDescription(), state: "complete")
 			}
 		}
@@ -71,6 +75,31 @@ def rootPage() {
 	}
 }
 
+def unsupportedDevicesPage() {
+
+	def unsupportedDimmers = dimmers.findAll { !hasSetLevelCommand(it) }
+
+	dynamicPage(name: "unsupportedDevicesPage") {
+		if (unsupportedDimmers) {
+			section("These devices do not support the setLevel command") {
+				unsupportedDimmers.each {
+					paragraph deviceLabel(it)
+				}
+			}
+			section {
+				input(name: "dimmers", type: "capability.sensor", title: "Please remove the above devices from this list.", submitOnChange: true, multiple: true)
+			}
+			section {
+				paragraph "If you think there is a mistake here, please contact support."
+			}
+		} else {
+			section {
+				paragraph "You're all set. You can hit the back button, now. Thanks for cleaning up your settings :)"
+			}
+		}
+	}
+}
+
 def controllerExplanationPage() {
 	dynamicPage(name: "controllerExplanationPage", title: "How To Control Gentle Wake Up") {
 
@@ -528,14 +557,16 @@ def updateDimmers(percentComplete) {
 		} else {
 
 			def shouldChangeColors = (colorize && colorize != "false")
-			def canChangeColors = hasSetColorCommand(dimmer)
 
-			log.debug "Setting ${deviceLabel(dimmer)} to ${nextLevel}"
-
-			if (shouldChangeColors && canChangeColors) {
-				dimmer.setColor([hue: getHue(dimmer, nextLevel), saturation: 100, level: nextLevel])
-			} else {
+			if (shouldChangeColors && hasSetColorCommand(dimmer)) {
+				def hue = getHue(dimmer, nextLevel)
+				log.debug "Setting ${deviceLabel(dimmer)} level to ${nextLevel} and hue to ${hue}"
+				dimmer.setColor([hue: hue, saturation: 100, level: nextLevel])
+			} else if (hasSetLevelCommand(dimmer)) {
+				log.debug "Setting ${deviceLabel(dimmer)} level to ${nextLevel}"
 				dimmer.setLevel(nextLevel)
+			} else {
+				log.warn "${deviceLabel(dimmer)} does not have setColor or setLevel commands."
 			}
 
 		}
@@ -817,24 +848,21 @@ private getRedHue(level) {
 	if (level >= 96) return 17
 }
 
+private dimmersContainUnsupportedDevices() {
+	def found = dimmers.find { hasSetLevelCommand(it) == false }
+	return found != null
+}
+
 private hasSetLevelCommand(device) {
-	def isDimmer = false
-	device.supportedCommands.each {
-		if (it.name.contains("setLevel")) {
-			isDimmer = true
-		}
-	}
-	return isDimmer
+	return hasCommand(device, "setLevel")
 }
 
 private hasSetColorCommand(device) {
-	def hasColor = false
-	device.supportedCommands.each {
-		if (it.name.contains("setColor")) {
-			hasColor = true
-		}
-	}
-	return hasColor
+	return hasCommand(device, "setColor")
+}
+
+private hasCommand(device, String command) {
+	return (device.supportedCommands.find { it.name == command } != null)
 }
 
 private dimmersWithSetColorCommand() {
@@ -1073,4 +1101,4 @@ def hasStartLevel() {
 
 def hasEndLevel() {
 	return (endLevel != null && endLevel != "")
-}
+}

smartapps/smartthings/logitech-harmony-connect.src/logitech-harmony-connect.groovy

@@ -658,29 +658,73 @@ def updateDevice() {
 	def data = request.JSON
 	def command = data.command
 	def arguments = data.arguments
-
 	log.debug "updateDevice, params: ${params}, request: ${data}"
 	if (!command) {
 		render status: 400, data: '{"msg": "command is required"}'
 	} else {
 		def device = allDevices.find { it.id == params.id }
-		if (device) {
-        	if (device.hasCommand("$command")) {
-                if (arguments) {
-                    device."$command"(*arguments)
-                } else {
-                    device."$command"()
-                }
-                render status: 204, data: "{}"
-           	} else {
-				render status: 404, data: '{"msg": "Command not supported by this Device"}'
-			}
-		} else {
-			render status: 404, data: '{"msg": "Device not found"}'
-		}
+    if (device) {
+        if (validateCommand(device, command)) {
+            if (arguments) {
+                device."$command"(*arguments)
+            } else {
+                device."$command"()
+            }
+            render status: 204, data: "{}"
+        } else {
+          render status: 403, data: '{"msg": "Access denied. This command is not supported by current capability."}'
+        }
+    } else {
+      render status: 404, data: '{"msg": "Device not found"}'
+    }
+  }
+}
+
+/**
+ * Validating the command passed by the user based on capability.
+ * @return boolean
+ */
+def validateCommand(device, command) {
+	def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
+	def currentDeviceCapability = getCapabilityName(device)
+	if (currentDeviceCapability != "" && 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(device) {
+    def capName = ""
+    if (switches.find{it.id == device.id})
+			capName = "Switch"
+		else if (alarms.find{it.id == device.id})
+			capName = "Alarm"
+		else if (locks.find{it.id == device.id})
+			capName = "Lock"
+    log.trace "Device: $device - Capability Name: $capName"
+		return capName
+}
+
+/**
+ * Constructing the map over here of
+ * supported commands by device capability
+ * @return a map of device capability -> supported commands
+ */
+def getDeviceCapabilityCommands(deviceCapabilities) {
+	def map = [:]
+	deviceCapabilities.collect {
+		map[it.name] = it.commands.collect{ it.name.toString() }
+	}
+	return map
+}
+
 def listSubscriptions() {
 	log.debug "listSubscriptions()"
 	app.subscriptions?.findAll { it.device?.device && it.device.id }?.collect {
@@ -780,17 +824,51 @@ def deviceHandler(evt) {
 
 def sendToHarmony(evt, String callbackUrl) {
 	def callback = new URI(callbackUrl)
-	def host = callback.port != -1 ? "${callback.host}:${callback.port}" : callback.host
-	def path = callback.query ? "${callback.path}?${callback.query}".toString() : callback.path
-	sendHubCommand(new physicalgraph.device.HubAction(
-		method: "POST",
-		path: path,
-		headers: [
-			"Host": host,
-			"Content-Type": "application/json"
-		],
-		body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
-	))
+  if(isIP(callback.host)){
+  	def host = callback.port != -1 ? "${callback.host}:${callback.port}" : callback.host
+  	def path = callback.query ? "${callback.path}?${callback.query}".toString() : callback.path
+  	sendHubCommand(new physicalgraph.device.HubAction(
+  		method: "POST",
+  		path: path,
+  		headers: [
+  			"Host": host,
+  			"Content-Type": "application/json"
+  		],
+  		body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
+  	))
+  } else {
+    def params = [
+      uri: callbackUrl,
+      body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
+    ]
+    try {
+        log.debug "Sending data to Harmony Cloud: $params"
+        httpPostJson(params) { resp ->
+            log.debug "Harmony Cloud - Response: ${resp.status}"
+        }
+    } catch (e) {
+        log.error "Harmony Cloud - Something went wrong: $e"
+    }
+  }
+}
+
+public static boolean isIP(String str) {
+    try {
+         String[] parts = str.split("\\.");
+         if (parts.length != 4) return false;
+         for (int i = 0; i < 4; ++i) {
+             int p
+             try {
+               p = Integer.parseInt(parts[i]);
+             } catch (Exception e) {
+               return false;
+             }
+             if (p > 255 || p < 0) return false;
+         }
+         return true;
+    } catch (Exception e) {
+        return false;
+    }
 }
 
 def listHubs() {

smartapps/smartthings/programmable-thermostat.src/programmable-thermostat.groovy

@@ -1,369 +0,0 @@
-/**
- *  Programmable Thermostat
- *
- *  Copyright 2016 Raymond Ciarcia
- *
- *  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: "Programmable Thermostat",
-    namespace: "smartthings",
-    author: "Raymond Ciarcia",
-    description: "A full-featured, easy to use interface for programming your thermostat based on schedule setpoints and mode changes",
-    category: "Convenience",
-    iconUrl: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png",
-    iconX2Url: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png",
-    iconX3Url: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png"
-)
-
-preferences {
-	page(name:"Settings", title:"Settings", uninstall:true, install:true ) {
-		section() {
-			input (name:"thermostat", type: "capability.thermostat", title: "Select thermostat", required: true, multiple: false)
-		}
-    	section ("Scheduled Setpoints") {
-	    	input (name: "son", type: "bool", title: "Run scheduled setpoints", required:true)
-			input (name:"numscheduled", title: "Number of scheduled setpoints", type: "number",refreshAfterSelection: true)
-			href(title: "Schedule Setpoints", page: "ScheduledChanges")
-		}
-    	section ("Mode-Based Setpoints") {
-			input (name: "eon", type: "bool", title: "Run mode-based setpoints", required:true)
-			input (name:"numevent", title: "Number of mode-based setpoints", type: "number",refreshAfterSelection: true)
-			href(title: "Mode-Based Setpoints Setpoints", page: "EventBasedChanges")
-		}
-    	section("Auto Thermostat Mode Control") {
-        	input (name: "auto", type: "enum", title: "Adjust thermostat heating/cooling mode based on current temperature and setpoint", required:true, multiple: false, options: ['Never','When setpoints are executed','Any time']) 
-		}
-    	section("Notifications") {
-			input (name: "snotifications", type: "bool", title: "Notify when scheduled setpoints execute", required:true)
-            input (name: "enotifications", type: "bool", title: "Notify when mode-based setpoints execute", required:true)
-            input (name: "eventlogging", type: "enum", title: "Set the level of event logging in the notification feed", required:true, multiple: false, options: ['None','Normal','Detailed'])
-		}
-       section("Command Acknowledgement Failure Response and Notification") {
-			input (name: "fnotifications", type: "bool", title: "Resend commands not acknowledged by the theromstat and notify after multiple failed attempts.  Increases thermostat reliability but may not be compatible with all thermostats; disable if every command results in a failure notification.", required:true)
-       }
-    }
-    page(name: "ScheduledChanges")
-    page(name: "EventBasedChanges")
-}
-
-def ScheduledChanges() {
-	dynamicPage(name: "ScheduledChanges", uninstall: true, install: false) {
-		for (int i = 1; i <= settings.numscheduled; i++) {
-			section("Scheduled Setpoint $i") {
-				input "stime${i}", "time", title: "At this time:", required: true
-       			input "sheatset${i}", "decimal", title: "Set this heating temperature:", required: true
-        		input "scoolset${i}", "decimal", title: "Set this cooling temperature:", required: true
-        		input "sdays${i}", "enum", title: "Only on these days (no selection is equivalent to selecting all):", required: false, multiple: true, options: ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
-        		input "smodes${i}", "mode", title: "Only in these modes (no selection is equivalent to selecting all):", multiple: true, required: false       
-			}
-    	}
-	}
-}
-
-def EventBasedChanges() {
-	dynamicPage(name: "EventBasedChanges", uninstall: true, install: false) {
-		for (int i = 1; i <= settings.numevent; i++) {
-			section("Mode-Based Setpoint $i") {
-				input "emodes${i}", "mode", title: "On transition to this mode:", multiple: false, required: true
-				input "eheatset${i}", "decimal", title: "Set this heating temperature:", required: true
-	    		input "ecoolset${i}", "decimal", title: "Set this cooling temperature:", required: true
-                input "edays${i}", "enum", title: "Only on these days (no selection is equivalent to selecting all):", required: false, multiple: true, options: ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
-			}
-		}
-	}
-}
-
-
-//---- INSTALL AND UPDATE
-
-def installed() {initialize()}
-
-def updated() {initialize()}
-
-def initialize() {
-	try {
-    	unschedule()
-    } catch(e) {
-    	try {
-       		unschedule(SchedulerIntegrityChecker)
-    		unschedule(MidnightRunner)        
-        } catch(ev) {}    
-    }    
-    
-    unsubscribe()
-    subscribe(settings.thermostat, "temperature", tempChangeHandler)
-    if ((settings.numevent > 0) && (settings.eon)) {subscribe(location, modeChangeHandler)}
-
-    state.scheduledindex = 0
-    state.pendingindex = 0
-	state.dayoflastrun = TodayAsString()
-    state.timeoflastevent = now()
-    state.nextscheduledtime = now()
-    state.failedcommandcount = 0
-    state.schedulestring = ""
-    state.checkcommandstring = ""
-    
-    state.eventlogging = 0
-    if (settings.eventlogging == "Normal"){state.notificationlevel = 1}
-    if (settings.eventlogging == "Detailed"){state.notificationlevel = 2}
-    
-    if ((settings.numscheduled > 0) && (settings.son)) {
-    	schedule(timeToday("2015-08-04T00:00:00.000",location.timeZone), MidnightRunner)
-    	SchedulerFunction()
-    }
-	log.debug "Programmable Thermostat: successfully initialized."
-    if (state.notificationlevel>0) {sendNotificationEvent("Programmable Thermostat successfully initialized.$state.schedulestring.")}
-	state.schedulestring = ""
-}
-
-//---- SCHEDULING FUNCTIONS
-
-//At midnight, runs scheduler function to set the first scheduled event of the new day
-def MidnightRunner() {
-	state.dayoflastrun = TodayAsString()
-    state.timeoflastevent = now()
-    SchedulerFunction()
-    def i = SearchSchedulePoints("2015-08-04T00:00:00.000")
-    if (i>0) {ThermostatCommander(settings."sheatset${i}", settings."scoolset${i}", settings.snotifications, "per scheduled setpoint.$state.schedulestring")}
-}
-
-//Determines and schedules the next scheduled setpoint
-def SchedulerFunction(){
-	def mindiff = 60*60*1000*24*7 
-    def timeNow = now()
-   	def todaystring = TodayAsString()
-	for (int i = 1; i <= settings.numscheduled; i++) {
-        def ScheduledTime = timeToday(settings["stime$i"],location.timeZone)
-        def ScheduledDays = settings["sdays$i"]
-        if (ScheduledDays == null) {ScheduledDays = TodayAsString()}
- 		if (ScheduledTime != null) {
-        	if ((ScheduledTime.time >= timeNow) && (ScheduledDays.contains(TodayAsString())) && (ScheduledTime.time - timeNow < mindiff)){
-                mindiff = ScheduledTime.time - timeNow
-                state.scheduledindex = i
-    		} 
-    	}
-	}
-    if (mindiff < 60*60*1000*24*7) {
-    	int i = state.scheduledindex
-    	def nextrun = timeToday(settings["stime$i"],location.timeZone)
-        state.nextscheduledtime = nextrun.time
-        def nextrunstring = DisplayTime(nextrun)
-        runOnce(nextrun, ScheduleExecuter)
-		if (state.notificationlevel>1) {state.schedulestring=" Next scheduled setpoint for $thermostat.label is today at $nextrunstring"}
-	} else {
-        state.nextscheduledtime = -1
-		if (state.notificationlevel>1) {state.schedulestring=" There are no remaining scheduled setpoints for $thermostat.label today"}
-	}
-	state.timeoflastevent = now()
-}
-
-def SearchSchedulePoints(time) {
-    for (int i = 1; i <= settings.numscheduled; i++) {
-    	def Modes = settings["smodes$i"]
-        if (Modes == null) {Modes = location.mode}
-        def Days = settings["sdays$i"]
-        if (Days == null) {Days = TodayAsString()}
-    	if(timeToday(settings["stime$i"],location.timeZone) == timeToday(time,location.timeZone) && Modes.contains(location.mode) && Days.contains(TodayAsString())) {
-            return i
-        }
-    }
-	return 0
-}
-
-
-//---- EXECUTION FUNCTIONS
-
-//Runs at scheduled setpoints to determine whether a setpoint should be executed; if yes, calls thermostat commander to execute command
-def ScheduleExecuter() {
-	int i = state.scheduledindex
-	SchedulerFunction()
-    state.timeoflastevent = now()
-	def valid = false
-    def Modes = settings["smodes$i"]
-    if (Modes == null) {Modes = location.mode}    
-	if(Modes.contains(location.mode)){
-    	valid = true
-    } else {
-    	i = SearchSchedulePoints(settings["stime$i"]) 
-        if (i > 0) {valid = true}
-	}
-	if (valid) {
-    	state.failedcommandcount = 0
-        state.pendingindex = i
-        ThermostatCommander(settings."sheatset${i}", settings."scoolset${i}", settings.snotifications, "per scheduled setpoint.$state.schedulestring")
-	} else {
-		if (state.notificationlevel>1) {sendNotificationEvent("Scheduled setpoint for $thermostat.label not executed because the current home mode, $location.mode, does not match a setpoint mode.$state.schedulestring.")}
-    }
-    state.schedulestring = ""
-}
-
-//Sends commands to the thermostat
-def ThermostatCommander(hvalue, cvalue, notifications, notificationphrase) { 
-	state.timeoflastevent = now()
-	if((hvalue == null) || (cvalue == null)) {return}
-    if (settings.auto != "Never") {ThermostatModeSetter(hvalue, cvalue, 0)}   
-
-	def notificationstring = "" 
-    state.checkcommandstring = ""
-    def thermMode = thermostat.currentValue("thermostatMode")
-    def name = thermostat.label
-    
-    def currentheatsetpoint = settings.thermostat.currentValue("heatingSetpoint")
-    def currentcoolsetpoint = settings.thermostat.currentValue("coolingSetpoint")  
-
-    if ("$currentcoolsetpoint" != "$cvalue") {state.checkcommandstring = "c"}
-    if ("$currentheatsetpoint" != "$hvalue") {state.checkcommandstring = "h$state.checkcommandstring"}
-    log.debug "Programmable Thermostat: check string is $state.checkcommandstring; values are $currentcoolsetpoint and $currentheatsetpoint"
-
-    def primarysetpoint = hvalue
-    if (thermMode == "cool") {primarysetpoint = cvalue}
-	if (thermMode == "heat" || thermMode == "cool") {notificationstring = "$name set to $primarysetpoint in $thermMode mode $notificationphrase."}
-    else {notificationstring = "$name set to $hvalue / $cvalue $notificationphrase."}
-    
-    if (settings.fnotifications && state.checkcommandstring != "") (runIn(10 + state.failedcommandcount*30, CommandIntegrityChecker))
-
-    if (hvalue!=0) {
-		log.debug "Programmable Thermostat: Heat command set to $hvalue"
-		thermostat.setHeatingSetpoint(hvalue)
-    }
-    if (cvalue!=0) {
-		log.debug "Programmable Thermostat: Cool command set to $cvalue"
-		thermostat.setCoolingSetpoint(cvalue)
-    }
-    if (notifications && state.failedcommandcount==0) {
-    	sendPush(notificationstring)
-    } else if (state.notificationlevel>0 && state.failedcommandcount==0) {
-    	sendNotificationEvent(notificationstring)
-        if (state.checkcommandstring == "" && state.notificationlevel>2) {sendNotificationEvent("$name confirmed that it was already set to $primarysetpoint in $thermMode mode.")}
-    }
-    if (state.checkcommandstring == "") {log.debug "Programmable Thermostat: $name confirmed that it was already set to $primarysetpoint in $thermMode mode"}
-}
-
-//Auto Sets Thermostat Mode
-def ThermostatModeSetter(hvalue, cvalue, notifications) {
-	if (hvalue==0 || cvalue==0) {return}
-    def currentTemp = settings.thermostat.latestValue("temperature")
-    if (currentTemp > cvalue && settings.thermostat.currentValue("thermostatMode") != "cool") {
-		thermostat.cool()
-		if (notifications > 0) {sendNotificationEvent("$thermostat.label mode changed to cooling when temperature reached $currentTemp")}
-	} else if (currentTemp < hvalue && settings.thermostat.currentValue("thermostatMode") != "heat") {
-		thermostat.heat()
-		if (notifications > 0) {sendNotificationEvent("$thermostat.label mode changed to heating when temperature fell to $currentTemp")}
-	}        
-}
-
-
-//---- INTEGRITY CHECKERS
-
-//Determines whether the last scheduled setpoint was executed; if not, reinitializes or sends missed command
-def SchedulerIntegrityChecker() {
-	def i = state.scheduledindex
-	if ((settings.numscheduled == 0) || (settings.son == false)) {return}
-	if (state.dayoflastrun != TodayAsString()) {initialize()}
-}
-
-//Determines whether commands sent to the thermostat have been properly acknowledged; if not, calls thermostat commander to reissue failed command(s)
-def CommandIntegrityChecker() {
-	state.timeoflastevent = now()
-	if (state.pendingindex == 0) {return}
-	def currentheatsetpoint = settings.thermostat.currentValue("heatingSetpoint")
-    def currentcoolsetpoint = settings.thermostat.currentValue("coolingSetpoint")
-	def thermMode = thermostat.currentValue("thermostatMode")
-    def lastheatcommand = IndexLookUp("heat")
-	def lastcoolcommand = IndexLookUp("cool")
-    def failedstring = ""
-    log.debug "Programmable Thermostat: $thermostat.label heating setpoint was commanded to $lastheatcommand and is currently $currentheatsetpoint; cooling setpoint was commanded to $lastcoolcommand and is currently $currentcoolsetpoint"    
-  
-	if (("$currentheatsetpoint" == "$lastheatcommand") && ("$currentcoolsetpoint" == "$lastcoolcommand")) {return}
-    
-    state.failedcommandcount = state.failedcommandcount + 1
-	if ("$currentheatsetpoint" != "$lastheatcommand" && "$currentcoolsetpoint" != "$lastcoolcommand" && state.checkcommandstring == "hc") {
-		failedstring = "$thermostat.label is non-responsive to setpoint commands."
-		ThermostatCommander(lastheatcommand, lastcoolcommand, false, "")
-	} else if ("$currentheatsetpoint" != "$lastheatcommand" && (state.checkcommandstring == "hc" || state.checkcommandstring == "h")) {
-		if (thermMode == "heat") {failedstring = "$thermostat.label is non-responsive to heat setpoint commands."}
-		ThermostatCommander(lastheatcommand, 0, false, "")    
-    } else if ("$currentcoolsetpoint" != "$lastcoolcommand" && (state.checkcommandstring == "hc" || state.checkcommandstring == "c")) {
-		if (thermMode == "cool") failedstring = "$thermostat.label is non-responsive to cool setpoint commands."
-		ThermostatCommander(0, lastcoolcommand, false, "")
-	}
-
-	if (state.failedcommandcount == 4) {
-		state.failedcommandcount = 0
-        state.pendingindex = 0
-    	if (failedstring != "") {sendPush(failedstring)}
-	}
-}
-
-
-//---- EVENT HANDLERS
-
-//Runs every time a mode change is detected.  Used to execute mode-based setpoints; also used to trigger schedule integrity checks in case all scheduled functions have failed
-def modeChangeHandler(evt) {
-    if (state.notificationlevel>2) {sendNotificationEvent("Programmable Thermostat detected home mode change to $evt.value.")}	
-	for (int i = 1; i <= settings.numevent; i++) {
-        def ScheduledDays = settings["edays$i"]
-        if (ScheduledDays == null) {ScheduledDays = TodayAsString()}
-        if ((evt.value == settings["emodes$i"]) && (ScheduledDays.contains(TodayAsString()))) {
-			state.failedcommandcount = 0
-            state.pendingindex = -i
-            ThermostatCommander(settings."eheatset${i}", settings."ecoolset${i}", settings.enotifications, "with change to $evt.value")
-        	i = settings.numevent + 1
-        }        
-	}
-	SchedulerIntegrityChecker()
-}
-
-//Runs every time the temperature reported by the thermostat changes.  Used to trigger schedule integrity checks in case all scheduled functions have failed.
-def tempChangeHandler(evt) {
-	SchedulerIntegrityChecker()
-    if (settings.auto == "Any time") {ThermostatModeSetter(settings.thermostat.latestValue("heatingSetpoint"), settings.thermostat.latestValue("coolingSetpoint"), state.notificationlevel)}
-}
-
-//---- OTHER
-
-//Returns the setpoint temperature associated with a settings index
-def IndexLookUp(mode) {
-	def result = 0
-	if (mode == "cool") {
-		if (state.pendingindex > 0) {result = settings."scoolset${state.pendingindex}"}
-    	if (state.pendingindex < 0) {result = settings."ecoolset${-state.pendingindex}"}
-	} else if (mode == "heat") {
-		if (state.pendingindex > 0) {result = settings."sheatset${state.pendingindex}"}
-   		if (state.pendingindex < 0) {result = settings."eheatset${-state.pendingindex}"}
-    }
-	return result
-}
-
-//Returns the current day of the week as a string
-def TodayAsString() {
-	return (new Date(now())).format("EEEEEEE", location.timeZone)
-}
-
-//Returns time as a string in 12 hour format
-def DisplayTime(time) {
-	def tz = location.timeZone
-    def hour = time.format("H",tz)
-	def min = time.format("m",tz)
-	def sec = time.format("s",tz)
-	def ampm = "am"        
-	def hournum = hour.toInteger()
-	def minnum = min.toInteger()
-	if (hournum == 0) {hournum = 12}
-	if (hournum > 12) {
-		hournum = hournum - 12
-		ampm = "pm"
-	}   
-	if (minnum < 10) {min = "0$min"}   
-	return "$hournum:$min $ampm"
-}

smartapps/vlaminck/alfred-workflow.src/alfred-workflow.groovy

@@ -92,22 +92,87 @@ void updateLock() {
 
 private void updateAll(devices) {
 	def command = request.JSON?.command
-	if (command) {
-		devices."$command"()
+	def type = params.param1
+	if (!devices) {
+		httpError(404, "Devices not found")
+	}
+	
+	if (command){
+		devices.each { device ->
+			executeCommand(device, type, command)
+		}
 	}
 }
 
 private void update(devices) {
 	log.debug "update, request: ${request.JSON}, params: ${params}, devices: $devices.id"
 	def command = request.JSON?.command
-	if (command) {
-		def device = devices.find { it.id == params.id }
-		if (!device) {
-			httpError(404, "Device not found")
-		} else {
-			device."$command"()
-		}
+	def type = params.param1
+	def device = devices?.find { it.id == params.id }
+
+	if (!device) {
+		httpError(404, "Device not found")
 	}
+
+	if (command) {
+		executeCommand(device, type, command)
+	}
+}
+
+/**
+ * Validating the command passed by the user based on capability.
+ * @return boolean
+ */
+def 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) {
+    switch(type) {
+		case "switches":
+			return "Switch"
+		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) {
+	def map = [:]
+	deviceCapabilities.collect {
+		map[it.name] = it.commands.collect{ it.name.toString() }
+	}
+	return map
+}
+
+/**
+ * Validates and executes the command
+ * on the device or devices
+ */
+def executeCommand(device, type, command) {
+	if (validateCommand(device, type, command)) {
+		device."$command"()
+	} else {
+		httpError(403, "Access denied. This command is not supported by current capability.")
+	}	
 }
 
 private show(devices, name) {