mirror of
https://github.com/mtan93/SmartThingsPublic.git
synced 2026-03-09 13:21:53 +00:00
Compare commits
1 Commits
MSA-1371-2
...
MSA-1349-1
| Author | SHA1 | Date | |
|---|---|---|---|
|
ee5077aeda |
@@ -29,7 +29,6 @@ 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
|
||||
@@ -264,9 +263,5 @@ 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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,333 +0,0 @@
|
||||
/**
|
||||
* 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"
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
|
||||
@@ -39,7 +39,6 @@ preferences {
|
||||
page(name: "completionPage")
|
||||
page(name: "numbersPage")
|
||||
page(name: "controllerExplanationPage")
|
||||
page(name: "unsupportedDevicesPage")
|
||||
}
|
||||
|
||||
def rootPage() {
|
||||
@@ -48,9 +47,6 @@ 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")
|
||||
}
|
||||
}
|
||||
@@ -75,31 +71,6 @@ 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") {
|
||||
|
||||
@@ -557,16 +528,14 @@ def updateDimmers(percentComplete) {
|
||||
} else {
|
||||
|
||||
def shouldChangeColors = (colorize && colorize != "false")
|
||||
def canChangeColors = hasSetColorCommand(dimmer)
|
||||
|
||||
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)
|
||||
log.debug "Setting ${deviceLabel(dimmer)} to ${nextLevel}"
|
||||
|
||||
if (shouldChangeColors && canChangeColors) {
|
||||
dimmer.setColor([hue: getHue(dimmer, nextLevel), saturation: 100, level: nextLevel])
|
||||
} else {
|
||||
log.warn "${deviceLabel(dimmer)} does not have setColor or setLevel commands."
|
||||
dimmer.setLevel(nextLevel)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -848,21 +817,24 @@ private getRedHue(level) {
|
||||
if (level >= 96) return 17
|
||||
}
|
||||
|
||||
private dimmersContainUnsupportedDevices() {
|
||||
def found = dimmers.find { hasSetLevelCommand(it) == false }
|
||||
return found != null
|
||||
}
|
||||
|
||||
private hasSetLevelCommand(device) {
|
||||
return hasCommand(device, "setLevel")
|
||||
def isDimmer = false
|
||||
device.supportedCommands.each {
|
||||
if (it.name.contains("setLevel")) {
|
||||
isDimmer = true
|
||||
}
|
||||
}
|
||||
return isDimmer
|
||||
}
|
||||
|
||||
private hasSetColorCommand(device) {
|
||||
return hasCommand(device, "setColor")
|
||||
}
|
||||
|
||||
private hasCommand(device, String command) {
|
||||
return (device.supportedCommands.find { it.name == command } != null)
|
||||
def hasColor = false
|
||||
device.supportedCommands.each {
|
||||
if (it.name.contains("setColor")) {
|
||||
hasColor = true
|
||||
}
|
||||
}
|
||||
return hasColor
|
||||
}
|
||||
|
||||
private dimmersWithSetColorCommand() {
|
||||
@@ -1101,4 +1073,4 @@ def hasStartLevel() {
|
||||
|
||||
def hasEndLevel() {
|
||||
return (endLevel != null && endLevel != "")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -658,73 +658,29 @@ 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 (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.")
|
||||
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"}'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
@@ -824,51 +780,17 @@ def deviceHandler(evt) {
|
||||
|
||||
def sendToHarmony(evt, String callbackUrl) {
|
||||
def callback = new URI(callbackUrl)
|
||||
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 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]]
|
||||
))
|
||||
}
|
||||
|
||||
def listHubs() {
|
||||
|
||||
@@ -0,0 +1,369 @@
|
||||
/**
|
||||
* 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"
|
||||
}
|
||||
@@ -92,89 +92,24 @@ void updateLock() {
|
||||
|
||||
private void updateAll(devices) {
|
||||
def command = request.JSON?.command
|
||||
def type = params.param1
|
||||
if (!devices) {
|
||||
httpError(404, "Devices not found")
|
||||
}
|
||||
|
||||
if (command){
|
||||
devices.each { device ->
|
||||
executeCommand(device, type, command)
|
||||
}
|
||||
if (command) {
|
||||
devices."$command"()
|
||||
}
|
||||
}
|
||||
|
||||
private void update(devices) {
|
||||
log.debug "update, request: ${request.JSON}, params: ${params}, devices: $devices.id"
|
||||
def command = request.JSON?.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)
|
||||
def device = devices.find { it.id == params.id }
|
||||
if (!device) {
|
||||
httpError(404, "Device not found")
|
||||
} else {
|
||||
device."$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) {
|
||||
def device = devices.find { it.id == params.id }
|
||||
if (!device) {
|
||||
|
||||
Reference in New Issue
Block a user