Merge pull request #975 from SmartThingsCommunity/staging

Rolling up staging to production

devicetypes/com-lametric/lametric.src/lametric.groovy

@@ -1,126 +0,0 @@
-/**
- *  LaMetric
- *
- *  Copyright 2016 Smart Atoms Ltd.
- *  Author: Mykola Kirichuk
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (name: "LaMetric", namespace: "com.lametric", author: "Mykola Kirichuk") {
-		capability "Actuator"
-		capability "Notification"
-		capability "Polling"
-		capability "Refresh"
-        
-        attribute "currentIP", "string"
-        attribute "serialNumber", "string"
-        attribute "volume", "string"
-        attribute "mode", "enum", ["offline","online"]
-        
-        command "setOffline"
-        command "setOnline"
-	}
-
-	simulator {
-		// TODO: define status and reply messages here
-	}
-
-	tiles (scale: 2){
-		// TODO: define your main and details tiles here
-         tiles(scale: 2) {
-     	multiAttributeTile(name:"rich-control"){
-			tileAttribute ("mode", key: "PRIMARY_CONTROL") {
-	            attributeState "online", label: "LaMetric", action: "", icon:  "https://developer.lametric.com/assets/smart_things/time_100.png", backgroundColor: "#F3C200"
-                attributeState "offline", label: "LaMetric", action: "", icon: "https://developer.lametric.com/assets/smart_things/time_100.png", backgroundColor: "#F3F3F3"
-			}
-	        tileAttribute ("serialNumber", key: "SECONDARY_CONTROL") {
-	            attributeState "default", label:'SN: ${currentValue}'
-			}
-        }
-		valueTile("serialNumber", "device.serialNumber", decoration: "flat", height: 1, width: 2, inactiveLabel: false) {
-			state "default", label:'SN: ${currentValue}'
-		}
-		valueTile("networkAddress", "device.currentIP", decoration: "flat", height: 2, width: 4, inactiveLabel: false) {
-			state "default", label:'${currentValue}', height: 1, width: 2, inactiveLabel: false
-		}
-
-		main (["rich-control"])
-		details(["rich-control","networkAddress"])
-	}
-	}
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parsing '${description}'"
-    if (description)
-    {
-    	unschedule("setOffline")
-    }
-	// TODO: handle 'battery' attribute
-	// TODO: handle 'button' attribute
-	// TODO: handle 'status' attribute
-	// TODO: handle 'level' attribute
-	// TODO: handle 'level' attribute
-
-}
-
-// handle commands
-def setOnline()
-{
-	log.debug("set online");
-    sendEvent(name:"mode", value:"online")
-  	unschedule("setOffline")
-}
-def setOffline(){
-	log.debug("set offline");
-    sendEvent(name:"mode", value:"offline")
-}
-
-def setLevel(level) {
-	log.debug "Executing 'setLevel' ${level}"
-	// TODO: handle 'setLevel' command
-}
-
-def deviceNotification(notif) {
-	log.debug "Executing 'deviceNotification' ${notif}"
-	// TODO: handle 'deviceNotification' command
-    def result = parent.sendNotificationMessageToDevice(device.deviceNetworkId, notif);
-    log.debug ("result ${result}");
-    log.debug parent;
-    return result;
-}
-
-def poll() {
-	// TODO: handle 'poll' command
-    log.debug "Executing 'poll'"
-  	if (device.currentValue("currentIP") != "Offline")
-    {
-	    runIn(30, setOffline)
-    }
-    parent.poll(device.deviceNetworkId)
-}
-
-def refresh() {    
-	log.debug "Executing 'refresh'"
-//    log.debug "${device?.currentIP}"
-    log.debug "${device?.currentValue("currentIP")}"
-    log.debug "${device?.currentValue("serialNumber")}"
-    log.debug "${device?.currentValue("volume")}"
-//    poll()
-	
-}
-
-/*def setLevel() {
-	log.debug "Executing 'setLevel'"
-	// TODO: handle 'setLevel' command
-}*/

devicetypes/smartthings/smartsense-multi-sensor.src/smartsense-multi-sensor.groovy

@@ -403,21 +403,39 @@ def refresh() {
 
 	if (device.getDataValue("manufacturer") == "SmartThings") {
 		log.debug "Refreshing Values for manufacturer: SmartThings "
-		/* These values of Motion Threshold Multiplier(0x01) and Motion Threshold (0x0276)
-            seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
-            Separating these out in a separate if-else because I do not want to touch Centralite part
-            as of now.
-        */
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x01, [mfgCode: manufacturerCode])
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0002, 0x21, 0x0276, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* These values of Motion Threshold Multiplier(01) and Motion Threshold (7602)
+				seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
+				Separating these out in a separate if-else because I do not want to touch Centralite part
+				as of now.
+			*/
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {01}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 2 0x21 {7602}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	} else {
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x02, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* sensitivity - default value (8) */
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {02}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	}
 
 	//Common refresh commands
-	refreshCmds += zigbee.readAttribute(0x0402, 0x0000) +
-			zigbee.readAttribute(0x0001, 0x0020) +
-			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode])
+	refreshCmds = refreshCmds + [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global read 0xFC02 0x0010",
+		"send 0x${device.deviceNetworkId} 1 1","delay 400"
+	]
 
 	return refreshCmds + enrollResponse()
 }
@@ -425,15 +443,38 @@ def refresh() {
 def configure() {
 	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting"
 
-	def configCmds = enrollResponse() +
-			zigbee.batteryConfig() +
-			zigbee.temperatureConfig() +
-			zigbee.configureReporting(0xFC02, 0x0010, 0x18, 10, 3600, 0x01, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0012, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0013, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0014, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode])
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}", "delay 200",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0xFC02 {${device.zigbeeId}} {}", "delay 200",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0010 0x18 10 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+		]
 
 	return configCmds + refresh()
 }

devicetypes/smartthings/zwave-motion-sensor.src/zwave-motion-sensor.groovy

@@ -21,13 +21,6 @@ metadata {
 		capability "Motion Sensor"
 		capability "Sensor"
 		capability "Battery"
-
-		fingerprint mfr: "011F", prod: "0001", model: "0001", deviceJoinName: "Schlage Motion Sensor"  // Schlage motion
-		fingerprint mfr: "014A", prod: "0001", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion
-		fingerprint mfr: "014A", prod: "0004", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion +
-		fingerprint mfr: "0060", prod: "0001", model: "0002", deviceJoinName: "Everspring Motion Sensor"  // Everspring SP814
-		fingerprint mfr: "0060", prod: "0001", model: "0003", deviceJoinName: "Everspring Motion Sensor"  // Everspring HSP02
-		fingerprint mfr: "011A", prod: "0601", model: "0901", deviceJoinName: "Enerwave Motion Sensor"  // Enerwave ZWN-BPC
 	}
 
 	simulator {
@@ -132,9 +125,9 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 	}
 	if (!state.lastbat || (new Date().time) - state.lastbat > 53*60*60*1000) {
 		result << response(zwave.batteryV1.batteryGet())
-	} else {
-		result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+		result << response("delay 1200")
 	}
+	result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	result
 }
 

smartapps/com-lametric/lametric-connect.src/lametric-connect.groovy

@@ -1,839 +0,0 @@
-/**
- *  LaMetric (Connect)
- *
- *  Copyright 2016 Smart Atoms Ltd.
- *  Author: Mykola Kirichuk
- *
- *  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: "LaMetric (Connect)",
-    namespace: "com.lametric",
-    author: "Mykola Kirichuk",
-    description: "Control your LaMetric Time smart display",
-    category: "Family",
-    iconUrl: "https://developer.lametric.com/assets/smart_things/smart_things_60.png",
-    iconX2Url: "https://developer.lametric.com/assets/smart_things/smart_things_120.png",
-    iconX3Url: "https://developer.lametric.com/assets/smart_things/smart_things_120.png",
-    singleInstance: true)
-{
-    appSetting "clientId"
-    appSetting "clientSecret"
-}
-
-preferences {
-    page(name: "auth", title: "LaMetric", nextPage:"", content:"authPage", uninstall: true, install:true)
-    page(name:"deviceDiscovery", title:"Device Setup", content:"deviceDiscovery", refreshTimeout:5);
-}
-
-mappings {
-    path("/oauth/initialize") {action: [GET: "oauthInitUrl"]}
-    path("/oauth/callback") {action: [GET: "callback"]}
-}
-
-import groovy.json.JsonOutput
-
-def getEventNameListOfUserDeviceParsed(){ "EventListOfUserRemoteDevicesParsed" }
-def getEventNameTokenRefreshed(){ "EventAuthTokenRefreshed" }
-
-def installed() {
-    log.debug "Installed with settings: ${settings}"
-    initialize()
-}
-
-def updated() {
-    log.debug "Updated with settings: ${settings}"
-    sendEvent(name:"Updated", value:true)
-    unsubscribe()
-    initialize()
-
-
-}
-
-def initialize() {
-    // TODO: subscribe to attributes, devices, locations, etc.
-    log.debug("initialize");
-    state.subscribe  = false;
-    if (selecteddevice) {
-        addDevice()
-        subscribeNetworkEvents(true)
-        refreshDevices();
-    }
-}
-
-/**
-* Get the name of the new device to instantiate in the user's smartapps
-* This must be an app owned by the namespace (see #getNameSpace).
-*
-* @return name
-*/
-
-def getDeviceName() {
-    return "LaMetric"
-}
-
-/**
-* Returns the namespace this app and siblings use
-*
-* @return namespace
-*/
-def getNameSpace() {
-    return "com.lametric"
-}
-
-
-/**
-* Returns all discovered devices or an empty array if none
-*
-* @return array of devices
-*/
-def getDevices() {
-    state.remoteDevices = state.remoteDevices ?: [:]
-}
-
-/**
-* Returns an array of devices which have been verified
-*
-* @return array of verified devices
-*/
-def getVerifiedDevices() {
-    getDevices().findAll{ it?.value?.verified == true }
-}
-
-/**
-* Generates a Map object which can be used with a preference page
-* to represent a list of devices detected and verified.
-*
-* @return Map with zero or more devices
-*/
-Map getSelectableDevice() {
-    def devices = getVerifiedDevices()
-    def map = [:]
-    devices.each {
-        def value = "${it.value.name}"
-        def key = it.value.id
-        map["${key}"] = value
-    }
-    map
-}
-
-/**
-* Starts the refresh loop, making sure to keep us up-to-date with changes
-*
-*/
-private refreshDevices(){
-    log.debug "refresh device list"
-    listOfUserRemoteDevices()
-    //every 30 min
-    runIn(1800, "refreshDevices")
-}
-
-/**
-* The deviceDiscovery page used by preferences. Will automatically
-* make calls to the underlying discovery mechanisms as well as update
-* whenever new devices are discovered AND verified.
-*
-* @return a dynamicPage() object
-*/
-/******************************************************************************************************************
-DEVICE DISCOVERY AND VALIDATION
-******************************************************************************************************************/
-def deviceDiscovery()
-{
-    //    if(canInstallLabs())
-    if (1)
-    {
-        //    	userDeviceList();
-        log.debug("deviceDiscovery")
-        def refreshInterval = 3 // Number of seconds between refresh
-        int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
-            state.deviceRefreshCount = deviceRefreshCount + refreshInterval
-
-        def devices = getSelectableDevice()
-        def numFound = devices.size() ?: 0
-
-        // Make sure we get location updates (contains LAN data such as SSDP results, etc)
-        subscribeNetworkEvents()
-
-        //device discovery request every 15s
-        //        if((deviceRefreshCount % 15) == 0) {
-        //            discoverLaMetrics()
-        //        }
-
-        // Verify request every 3 seconds except on discoveries
-        if(((deviceRefreshCount % 5) == 0)) {
-            verifyDevices()
-        }
-
-        log.trace "Discovered devices: ${devices}"
-
-        return dynamicPage(name:"deviceDiscovery", title:"Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
-            section("Please wait while we discover your ${getDeviceName()}. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-                input "selecteddevice", "enum", required:false, title:"Select ${getDeviceName()} (${numFound} found)", multiple:true, options:devices
-            }
-        }
-    }
-    else
-    {
-        def upgradeNeeded = """To use SmartThings Labs, your Hub should be completely up to date.
-
-To update your Hub, access Location Settings in the Main Menu (tap the gear next to your location name), select your Hub, and choose "Update Hub"."""
-
-        return dynamicPage(name:"deviceDiscovery", title:"Upgrade needed!", nextPage:"", install:true, uninstall: true) {
-            section("Upgrade") {
-                paragraph "$upgradeNeeded"
-            }
-        }
-    }
-}
-
-/**
-
-/**
-* Starts a subscription for network events
-*
-* @param force If true, will unsubscribe and subscribe if necessary (Optional, default false)
-*/
-private subscribeNetworkEvents(force=false) {
-    if (force) {
-        unsubscribe()
-        state.subscribe = false
-    }
-    if(!state.subscribe) {
-        log.debug("subscribe on network events")
-        subscribe(location, null, locationHandler, [filterEvents:false])
-        //        subscribe(app, appHandler)
-        state.subscribe = true
-    }
-}
-
-private verifyDevices()
-{
-    log.debug "verify.devices"
-    def devices = getDevices();
-    for (it in devices) {
-        log.trace ("verify device ${it.value}")
-        def localIp = it?.value?.ipv4_internal;
-        def apiKey = it?.value?.api_key;
-        getAllInfoFromDevice(localIp, apiKey);
-    }
-}
-def appHandler(evt)
-{
-    log.debug("application event handler ${evt.name}")
-    if (evt.name == eventNameListOfUserDeviceParsed)
-    {
-        log.debug ("new account device list received ${evt.value}")
-        def newRemoteDeviceList
-        try {
-            newRemoteDeviceList = parseJson(evt.value)
-        } catch (e)
-        {
-            log.debug "Wrong value ${e}"
-        }
-        if (newRemoteDeviceList)
-        {
-            def remoteDevices = getDevices();
-            newRemoteDeviceList.each{deviceInfo ->
-                if (deviceInfo) {
-                    def device = remoteDevices[deviceInfo.id]?:[:];
-                        log.debug "before list ${device} ${deviceInfo} ${deviceInfo.id} ${remoteDevices[deviceInfo.id]}";
-                    deviceInfo.each() {
-                        device[it.key] = it.value;
-                    }
-                    remoteDevices[deviceInfo.id] = device;
-                } else {
-                    log.debug ("empty device info")
-                }
-            }
-            verifyDevices();
-        } else {
-            log.debug "wrong value ${newRemoteDeviceList}"
-        }
-    } else if (evt.name == getEventNameTokenRefreshed())
-    {
-        log.debug "token refreshed"
-        state.refreshToken = evt.refreshToken
-        state.authToken = evt.access_token
-    }
-}
-
-def locationHandler(evt)
-{
-    log.debug("network event handler ${evt.name}")
-    if (evt.name == "ssdpTerm")
-    {
-        log.debug "ignore ssdp"
-    } else {
-        def lanEvent = parseLanMessage(evt.description, true)
-        log.debug lanEvent.headers;
-        if (lanEvent.body)
-        {
-            log.trace "lan event ${lanEvent}";
-            def parsedJsonBody;
-            try {
-                parsedJsonBody = parseJson(lanEvent.body);
-            } catch (e)
-            {
-                log.debug ("not json responce ignore $e");
-            }
-            if (parsedJsonBody)
-            {
-                log.trace (parsedJsonBody)
-                log.debug("responce for device ${parsedJsonBody?.id}")
-                //put or post response
-                if (parsedJsonBody.success)
-                {
-
-                } else {
-                    //poll response
-                    log.debug "poll responce"
-                    log.debug ("poll responce ${parsedJsonBody}")
-                    def deviceId = parsedJsonBody?.id;
-                    if (deviceId)
-                    {
-                        def devices = getDevices();
-                        def device = devices."${deviceId}";
-
-                        device.verified = true;
-                        device.dni = [device.serial_number, device.id].join('.')
-                        device.hub = evt?.hubId;
-                        device.volume = parsedJsonBody?.audio?.volume;
-                        log.debug "verified device ${deviceId}"
-                        def childDevice = getChildDevice(device.dni)
-                        //update device info
-                        if (childDevice)
-                        {
-                            log.debug("send event to ${childDevice}")
-                            childDevice.sendEvent(name:"currentIP",value:device?.ipv4_internal);
-                            childDevice.sendEvent(name:"volume",value:device?.volume);
-                            childDevice.setOnline();
-                        }
-                        log.trace device
-                    }
-                }
-            }
-        }
-    }
-}
-
-/**
-* Adds the child devices based on the user's selection
-*
-* Uses selecteddevice defined in the deviceDiscovery() page
-*/
-def addDevice() {
-    def devices = getVerifiedDevices()
-    def devlist
-    log.trace "Adding childs"
-
-    // If only one device is selected, we don't get a list (when using simulator)
-    if (!(selecteddevice instanceof List)) {
-        devlist = [selecteddevice]
-    } else {
-        devlist = selecteddevice
-    }
-
-    log.trace "These are being installed: ${devlist}"
-    log.debug ("devlist" +  devlist)
-    devlist.each { dni ->
-        def newDevice = devices[dni];
-        if (newDevice)
-        {
-            def d = getChildDevice(newDevice.dni)
-            if(!d) {
-                log.debug ("get child devices"  + getChildDevices())
-                log.trace "concrete device ${newDevice}"
-                def deviceName = newDevice.name
-                d = addChildDevice(getNameSpace(), getDeviceName(), newDevice.dni, newDevice.hub, [label:"${deviceName}"])
-                def childDevice = getChildDevice(d.deviceNetworkId)
-                childDevice.sendEvent(name:"serialNumber", value:newDevice.serial_number)
-                log.trace "Created ${d.displayName} with id $dni"
-            } else {
-                log.trace "${d.displayName} with id $dni already exists"
-            }
-        }
-    }
-}
-
-
-//******************************************************************************************************************
-//		 					 					 			OAUTH
-//******************************************************************************************************************
-
-def getServerUrl()           		{ "https://graph.api.smartthings.com" }
-def getShardUrl()            		{ getApiServerUrl() }
-def getCallbackUrl()        		{ "https://graph.api.smartthings.com/oauth/callback" }
-def getBuildRedirectUrl()   		{ "${serverUrl}/oauth/initialize?appId=${app.id}&access_token=${state.accessToken}&apiServerUrl=${shardUrl}" }
-def getApiEndpoint()        		{ "https://developer.lametric.com" }
-def getTokenUrl()					{ "${apiEndpoint}${apiTokenPath}" }
-def getAuthScope() 					{ [ "basic", "devices_read" ] }
-def getSmartThingsClientId() 		{ appSettings.clientId }
-def getSmartThingsClientSecret() 	{ appSettings.clientSecret }
-def getApiTokenPath()				{ "/api/v2/oauth2/token" }
-def getApiUserMeDevicesList()		{ "/api/v2/users/me/devices" }
-
-def toQueryString(Map m) {
-    return m.collect { k, v -> "${k}=${URLEncoder.encode(v.toString())}" }.sort().join("&")
-}
-def composeScope(List scopes)
-{
-    def result = "";
-    scopes.each(){ scope ->
-        result += "${scope} "
-    }
-    if (result.length())
-    return result.substring(0, result.length() - 1);
-    return "";
-}
-
-def authPage() {
-    log.debug "authPage()"
-
-    if(!state.accessToken) { //this is to access token for 3rd party to make a call to connect app
-        state.accessToken = createAccessToken()
-    }
-
-    def description
-    def uninstallAllowed = false
-    def oauthTokenProvided = false
-
-    if(state.authToken) {
-        description = "You are connected."
-        uninstallAllowed = true
-        oauthTokenProvided = true
-    } else {
-        description = "Click to enter LaMetric Credentials"
-    }
-
-    def redirectUrl = buildRedirectUrl
-    log.debug "RedirectUrl = ${redirectUrl}"
-    // get rid of next button until the user is actually auth'd
-    if (!oauthTokenProvided) {
-        return dynamicPage(name: "auth", title: "Login", nextPage: "", uninstall:uninstallAllowed) {
-            section(){
-                paragraph "Tap below to log in to the LaMatric service and authorize SmartThings access. Be sure to scroll down on page 2 and press the 'Allow' button."
-                href url:redirectUrl, style:"embedded", required:true, title:"LaMetric", description:description
-            }
-        }
-    } else {
-        subscribeNetworkEvents()
-        listOfUserRemoteDevices()
-        return deviceDiscovery();
-    }
-}
-
-
-private refreshAuthToken() {
-    log.debug "refreshing auth token"
-
-    if(!state.refreshToken) {
-        log.warn "Can not refresh OAuth token since there is no refreshToken stored"
-    } else {
-        def refreshParams = [
-            method: 'POST',
-            uri   : apiEndpoint,
-            path  : apiTokenPath,
-            body : [grant_type: 'refresh_token', 
-                    refresh_token: "${state.refreshToken}", 
-                    client_id : smartThingsClientId,
-                    client_secret: smartThingsClientSecret,
-                    redirect_uri: callbackUrl],
-        ]
-
-        log.debug refreshParams
-
-        def notificationMessage = "is disconnected from SmartThings, because the access credential changed or was lost. Please go to the LaMetric (Connect) SmartApp and re-enter your account login credentials."
-        //changed to httpPost
-        try {
-            def jsonMap
-            httpPost(refreshParams) { resp ->
-                if(resp.status == 200) {
-                    log.debug "Token refreshed...calling saved RestAction now! $resp.data"
-                    jsonMap = resp.data
-                    if(resp.data) {
-                        state.refreshToken = resp?.data?.refresh_token
-                        state.authToken = resp?.data?.access_token
-                        if(state.action && state.action != "") {
-                            log.debug "Executing next action: ${state.action}"
-
-                            "${state.action}"()
-
-                            state.action = ""
-                        }
-
-                    } else {
-                        log.warn ("No data in refresh token!");
-                    }
-                    state.action = ""
-                }
-            }
-        } catch (groovyx.net.http.HttpResponseException e) {
-            log.error "refreshAuthToken() >> Error: e.statusCode ${e.statusCode}"
-            log.debug e.response.data;
-            def reAttemptPeriod = 300 // in sec
-            if (e.statusCode != 401) { // this issue might comes from exceed 20sec app execution, connectivity issue etc.
-                runIn(reAttemptPeriod, "refreshAuthToken")
-            } else if (e.statusCode == 401) { // unauthorized
-                state.reAttempt = state.reAttempt + 1
-                log.warn "reAttempt refreshAuthToken to try = ${state.reAttempt}"
-                if (state.reAttempt <= 3) {
-                    runIn(reAttemptPeriod, "refreshAuthToken")
-                } else {
-                    sendPushAndFeeds(notificationMessage)
-                    state.reAttempt = 0
-                }
-            }
-        }
-    }
-}
-
-def callback() {
-    log.debug "callback()>> params: $params, params.code ${params.code}"
-
-    def code = params.code
-    def oauthState = params.state
-
-    if (oauthState == state.oauthInitState){
-
-        def tokenParams = [
-            grant_type: "authorization_code",
-            code      : code,
-            client_id : smartThingsClientId,
-            client_secret: smartThingsClientSecret,
-            redirect_uri: callbackUrl
-        ]
-        log.trace tokenParams
-        log.trace tokenUrl
-        try {
-            httpPost(uri: tokenUrl, body: tokenParams) { resp ->
-                log.debug "swapped token: $resp.data"
-                state.refreshToken = resp.data.refresh_token
-                state.authToken = resp.data.access_token
-            }
-        } catch (e)
-        {
-            log.debug "fail ${e}";
-        }
-        if (state.authToken) {
-            success()
-        } else {
-            fail()
-        }
-    } else {
-        log.error "callback() failed oauthState != state.oauthInitState"
-    }
-
-}
-
-def oauthInitUrl() {
-    log.debug "oauthInitUrl with callback: ${callbackUrl}"
-
-    state.oauthInitState = UUID.randomUUID().toString()
-
-    def oauthParams = [
-        response_type: "code",
-        scope: composeScope(authScope),
-        client_id: smartThingsClientId,
-        state: state.oauthInitState,
-        redirect_uri: callbackUrl
-    ]
-    log.debug oauthParams
-    log.debug "${apiEndpoint}/api/v2/oauth2/authorize?${toQueryString(oauthParams)}"
-
-    redirect(location: "${apiEndpoint}/api/v2/oauth2/authorize?${toQueryString(oauthParams)}")
-}
-
-def success() {
-    def message = """
-<p>Your LaMetric Account is now connected to SmartThings!</p>
-<p>Click 'Done' to finish setup.</p>
-"""
-    connectionStatus(message)
-}
-
-def fail() {
-    def message = """
-<p>The connection could not be established!</p>
-<p>Click 'Done' to return to the menu.</p>
-"""
-    connectionStatus(message)
-}
-
-def connectionStatus(message, redirectUrl = null) {
-    def redirectHtml = ""
-    if (redirectUrl) {
-        redirectHtml = """
-<meta http-equiv="refresh" content="3; url=${redirectUrl}" />
-"""
-    }
-
-    def html = """
-<!DOCTYPE html>
-<html lang="en"><head>
-<meta charset="UTF-8">
-<meta content="width=device-width" id="viewport" name="viewport">
-<style>
-@font-face {
-font-family: 'latoRegular';
-src: url("https://developer.lametric.com/assets/fonts/lato-regular-webfont.eot");
-src: url("https://developer.lametric.com/assets/fonts/lato-regular-webfont.eot?#iefix") format("embedded-opentype"),
-url("https://developer.lametric.com/assets/fonts/lato-regular-webfont.woff") format("woff"),
-url("https://developer.lametric.com/assets/fonts/lato-regular-webfont.ttf") format("truetype"),
-url("https://developer.lametric.com/assets/fonts/lato-regular-webfont.svg#latoRegular") format("svg");
-font-style: normal;
-font-weight: normal; }
-.clearfix:after, .mobile .connect:after {
-content: "";
-clear: both;
-display: table; }
-
-.transition {
-transition: all .3s ease 0s; }
-html, body {
-height: 100%;
-}
-body{
-margin: 0;
-padding: 0;
-background: #f0f0f0;
-color: #5c5c5c;
-min-width: 1149px;
-font-family: 'latoRegular', 'Lato';
-}
-.fixed-page #page {
-min-height: 100%;
-background: url(https://developer.lametric.com/assets/smart_things/page-bg.png) 50% 0 repeat-y;
-}
-.mobile {
-min-width: 100%;
-color: #757575; }
-.mobile .wrap {
-margin: 0 auto;
-padding: 0;
-max-width: 640px;
-min-width: inherit; }
-.mobile .connect {
-width: 100%;
-padding-top: 230px;
-margin-bottom: 50px;
-text-align: center; }
-.mobile .connect img {
-max-width: 100%;
-height: auto;
-vertical-align: middle;
-display: inline-block;
-margin-left: 2%;
-border-radius: 15px; }
-.mobile .connect img:first-child {
-margin-left: 0; }
-.mobile .info {
-width: 100%;
-margin: 0 auto;
-margin-top: 50px;
-margin-bottom: 50px; }
-.mobile .info p {
-max-width: 80%;
-margin: 0 auto;
-margin-top: 50px;
-font-size: 28px;
-line-height: 50px;
-text-align: center; }
-
-@media screen and (max-width: 639px) {
-.mobile .connect{
-padding-top: 100px; }
-.mobile .wrap {
-margin: 0 20px; }
-.mobile .connect img {
-width: 16%; }
-.mobile .connect img:first-child, .mobile .connect img:last-child {
-width: 40%; }
-.mobile .info p{
-font-size: 18px;
-line-height: 24px;
-margin-top: 20px; }
-}
-</style>
-</head>
-<body class="fixed-page mobile">
-
-<div id="page">
-<div class="wrap">
-
-<div class="connect">
-<img src="https://developer.lametric.com/assets/smart_things/product.png" width="190" height="190"><img src="https://developer.lametric.com/assets/smart_things/connected.png" width="87" height="19"><img src="https://developer.lametric.com/assets/smart_things/product-1.png" width="192" height="192">
-</div>
-
-<div class="info">
-${message}
-</div>
-</div>
-</div>
-</body></html>
-"""
-    render contentType: 'text/html', data: html
-}
-
-
-
-//******************************************************************************************************************
-//		 					 					 			LOCAL API
-//******************************************************************************************************************
-
-def getLocalApiDeviceInfoPath() 		{ "/api/v2/info" }
-def getLocalApiSendNotificationPath()	{ "/api/v2/device/notifications" }
-def getLocalApiIndexPath()				{ "/api/v2/device" }
-def getLocalApiUser()					{ "dev" }
-
-
-void requestDeviceInfo(localIp, apiKey)
-{
-    if (localIp && apiKey)
-    {
-        log.debug("request info ${localIp}");
-        def command = new physicalgraph.device.HubAction([
-            method: "GET",
-            path: localApiDeviceInfoPath,
-            headers: [
-                HOST: "${localIp}:8080",
-                Authorization: "Basic ${"${localApiUser}:${apiKey}".bytes.encodeBase64()}"
-            ]])
-        log.debug command
-        sendHubCommand(command)
-        command;
-    } else {
-        log.debug ("Unknown api key or ip address ${localIp} ${apiKey}")
-    }
-}
-
-def sendNotificationMessageToDevice(dni, data)
-{
-    log.debug "send something"
-    def device = resolveDNI2Device(dni);
-    def localIp = device?.ipv4_internal;
-    def apiKey = device?.api_key;
-    if (localIp && apiKey)
-    {
-        log.debug "send notification message to device ${localIp}:8080 ${data}"
-        sendHubCommand(new physicalgraph.device.HubAction([
-            method: "POST",
-            path: localApiSendNotificationPath,
-            body: data,
-            headers: [
-                HOST: "${localIp}:8080",
-                Authorization: "Basic ${"${localApiUser}:${apiKey}".bytes.encodeBase64()}",
-                "Content-type":"application/json",
-                "Accept":"application/json"
-            ]]))
-    }
-}
-
-def getAllInfoFromDevice(localIp, apiKey)
-{
-    log.debug "send something"
-    if (localIp && apiKey)
-    {
-    	def hubCommand = new physicalgraph.device.HubAction([
-            method: "GET",
-            path: localApiIndexPath+"?fields=info,wifi,volume,bluetooth,id,name,mode,model,serial_number,os_version",
-            headers: [
-                HOST: "${localIp}:8080",
-                Authorization: "Basic ${"${localApiUser}:${apiKey}".bytes.encodeBase64()}"
-            ]])
-        log.debug "sending request ${hubCommand}"
-        sendHubCommand(hubCommand)
-    }
-}
-//******************************************************************************************************************
-//		 					 					 DEVICE HANDLER COMMANDs API
-//******************************************************************************************************************
-
-def resolveDNI2Device(dni)
-{
-    getDevices().find { it?.value?.dni == dni }?.value;
-}
-
-def requestRefreshDeviceInfo (dni)
-{
-    log.debug "device ${dni} request refresh";
-    //	def devices = getDevices();
-    //    def concreteDevice = devices[dni];
-    //    requestDeviceInfo(conreteDevice);
-}
-
-private poll(dni) {
-    def device = resolveDNI2Device(dni);
-    def localIp = device?.ipv4_internal;
-    def apiKey = device?.api_key;
-    getAllInfoFromDevice(localIp, apiKey);
-}
-
-//******************************************************************************************************************
-//		 					 					 			CLOUD METHODS
-//******************************************************************************************************************
-
-
-void listOfUserRemoteDevices()
-{
-    log.debug "get user device list"
-    def deviceList = []
-    if (state.accessToken)
-    {
-        def deviceListParams = [
-            uri: apiEndpoint,
-            path: apiUserMeDevicesList,
-            headers: ["Content-Type": "text/json", "Authorization": "Bearer ${state.authToken}"]
-        ]
-        log.debug "making request ${deviceListParams}"
-        def result;
-        try {
-            httpGet(deviceListParams){ resp ->
-                if (resp.status == 200)
-                {
-                    deviceList = resp.data
-
-                    def remoteDevices = getDevices();
-                    for (deviceInfo in deviceList) {
-                        if (deviceInfo)
-                        {
-                            def device = remoteDevices."${deviceInfo.id}"?:[:];
-                                log.debug "before list ${device} ${deviceInfo} ${deviceInfo.id} ${remoteDevices[deviceInfo.id]}";
-                            for (it in deviceInfo ) {
-                                device."${it.key}" = it.value;
-                            }
-                            remoteDevices."${deviceInfo.id}" = device;
-                        } else {
-                            log.debug ("empty device info")
-                        }
-                    }
-                    verifyDevices();
-                } else {
-                    log.debug "http status: ${resp.status}"
-                }
-            }
-        } catch (groovyx.net.http.HttpResponseException e)
-        {
-            log.debug("failed to get device list ${e}")
-            def status = e.response.status
-            if (status == 401) {
-                state.action = "refreshDevices"
-                log.debug "Refreshing your auth_token!"
-                refreshAuthToken()
-            }
-            return;
-        }
-    } else {
-        log.debug ("no access token to fetch user device list");
-        return;
-    }
-}

smartapps/com-lametric/lametric-notifier.src/lametric-notifier.groovy

@@ -1,536 +0,0 @@
-/**
- *  Lametric Notifier
- *
- *  Copyright 2016 Smart Atoms Ltd.
- *  Author: Mykola Kirichuk
- *
- *  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.
- *
- */
- import groovy.json.JsonOutput
- 
-definition(
-    name: "LaMetric Notifier",
-    namespace: "com.lametric",
-    author: "Mykola Kirichuk",
-    description: "Allows you to send notifications to your LaMetric Time when something happens in your home to notify the whole family.",
-    category: "Family",
-    iconUrl: "https://developer.lametric.com/assets/smart_things/weather_60.png",
-    iconX2Url: "https://developer.lametric.com/assets/smart_things/weather_120.png",
-    iconX3Url: "https://developer.lametric.com/assets/smart_things/weather_120.png")
-
-
-preferences {
-	page(name: "mainPage", title: "Show a message on your LaMetric when something happens", install: true, uninstall: true)
-	page(name: "timeIntervalInput", title: "Only during a certain time") {
-		section {
-			input "starting", "time", title: "Starting", required: false
-			input "ending", "time", title: "Ending", required: false
-		}
-	}
-}
-
-
-
-           
-def getSoundList() {
-	[	
-    	"none":"No Sound",
-        "car" : "Car",
-        "cash" : "Cash Register",
-        "cat" : "Cat Meow",
-        "dog" : "Dog Bark",
-        "dog2" : "Dog Bark 2",
-        "letter_email" : "The mail has arrived",
-        "knock-knock" : "Knocking Sound",
-        "bicycle" : "Bicycle",
-        "negative1" : "Negative 1",
-        "negative2" : "Negative 2",
-        "negative3" : "Negative 3",
-        "negative4" : "Negative 4",
-        "negative5" : "Negative 5",
-        "lose1" : "Lose 1",
-        "lose2" : "Lose 2",
-        "energy" : "Energy",
-        "water1" : "Water 1",
-        "water2" : "Water 2",
-        "notification" : "Notification 1",
-        "notification2" : "Notification 2",
-        "notification3" : "Notification 3",
-        "notification4" : "Notification 4",
-        "open_door" : "Door unlocked",
-        "win" : "Win",
-        "win2" : "Win 2", 
-        "positive1" : "Positive 1",
-        "positive2" : "Positive 2",
-        "positive3" : "Positive 3",
-        "positive4" : "Positive 4",
-        "positive5" : "Positive 5",
-        "positive6" : "Positive 6",
-        "statistic" : "Page turning",
-        "wind" : "Wind",
-        "wind_short" : "Small Wind",
-    ] 
-}
-
-def getControlToAttributeMap(){
-	[
-        "motion": "motion.active",
-        "contact": "contact.open",
-        "contactClosed": "contact.close",
-        "acceleration": "acceleration.active",
-        "mySwitch": "switch.on",
-        "mySwitchOff": "switch.off",
-        "arrivalPresence": "presence.present",
-        "departurePresence": "presence.not present",
-        "smoke": "smoke.detected",
-        "smoke1": "smoke.tested",
-        "water": "water.wet",
-        "button1": "button.pushed",
-        "triggerModes": "mode",
-        "timeOfDay": "time",
-	]
-}
-                
-def getPriorityList(){
-	[
-    	"warning":"Not So Important (may be ignored at night)",
-        "critical": "Very Important"
-    ]
-}
-
-def getIconsList(){
-	state.icons = state.icons?:["1":"default"]
-}
-
-
-def getIconLabels() {
-	state.iconLabels = state.iconLabels?:["1":"Default Icon"]
-}
-
-def getSortedIconLabels() {
-	state.iconLabels = state.iconLabels?:["1":"Default Icon"]
-    state.iconLabels.sort {a,b -> a.key.toInteger() <=> b.key.toInteger()};
-}
-def getLametricHost() { "https://developer.lametric.com" }
-def getDefaultIconData() { """data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAYAAADED76LAAAAe0lEQVQYlWNUVFBgYGBgYNi6bdt/BiTg7eXFyMDAwMCELBmz7z9DzL7/KBoYr127BpeEgbV64QzfRVYxMDAwMLAgSy5xYoSoeMPAwPkmjOG7yCqIgjf8WVC90xnQAdwKj7OZcMGD8m/hVjDBXLvDGKEbJunt5cXISMibAF0FMibYF7nMAAAAAElFTkSuQmCC""" }
-
-def mainPage() {
-    def iconRequestOptions = [headers: ["Accept": "application/json"],
-						    uri: "${lametricHost}/api/v2/icons", query:["fields":"id,title,type,code", "order":"title"]]
-
-    	def icons = getIconsList();
-        def iconLabels = getIconLabels();
-        if (icons?.size() <= 2)
-        {
-	        log.debug iconRequestOptions
-            try {
-				httpGet(iconRequestOptions) { resp ->
-                   	int i = 2;
-                    resp.data.data.each(){
-                        def iconId = it?.id
-                        def iconType = it?.type
-                        def prefix = "i"
-                        if (iconId)
-                        {
-                            if (iconType == "movie")
-                            {
-                                prefix = "a"
-                            }
-                            def iconurl = "${lametricHost}/content/apps/icon_thumbs/${prefix}${iconId}_icon_thumb_big.png";
-                            icons["$i"] = it.code
-                            iconLabels["$i"] = it.title
-                        } else {
-                        	log.debug "wrong id"
-                        }
-                        ++i;
-                    }
-                }
-            } catch (e)
-            {
-                log.debug "fail ${e}";
-            }
-        }
-	dynamicPage(name: "mainPage") {
-		def anythingSet = anythingSet()
-        def notificationMessage = defaultNotificationMessage();
-        log.debug "set $anythingSet"
-		if (anythingSet) {
-			section("Show message when"){
-				ifSet "motion", "capability.motionSensor", title: "Motion Here", required: false, multiple: true , submitOnChange:true
-				ifSet "contact", "capability.contactSensor", title: "Contact Opens", required: false, multiple: true, submitOnChange:true
-				ifSet "contactClosed", "capability.contactSensor", title: "Contact Closes", required: false, multiple: true, submitOnChange:true
-				ifSet "acceleration", "capability.accelerationSensor", title: "Acceleration Detected", required: false, multiple: true, submitOnChange:true
-				ifSet "mySwitch", "capability.switch", title: "Switch Turned On", required: false, multiple: true, submitOnChange:true
-				ifSet "mySwitchOff", "capability.switch", title: "Switch Turned Off", required: false, multiple: true, submitOnChange:true
-				ifSet "arrivalPresence", "capability.presenceSensor", title: "Arrival Of", required: false, multiple: true, submitOnChange:true
-				ifSet "departurePresence", "capability.presenceSensor", title: "Departure Of", required: false, multiple: true, submitOnChange:true
-				ifSet "smoke", "capability.smokeDetector", title: "Smoke Detected", required: false, multiple: true, submitOnChange:true
-				ifSet "water", "capability.waterSensor", title: "Water Sensor Wet", required: false, multiple: true, submitOnChange:true
-				ifSet "button1", "capability.button", title: "Button Press", required:false, multiple:true //remove from production
-				ifSet "triggerModes", "mode", title: "System Changes Mode", required: false, multiple: true, submitOnChange:true
-				ifSet "timeOfDay", "time", title: "At a Scheduled Time", required: false, submitOnChange:true
-			}
-		}
-		def hideable = anythingSet || app.installationState == "COMPLETE"
-		def sectionTitle = anythingSet ? "Select additional triggers" : "Show message when..."
-
-		section(sectionTitle, hideable: hideable, hidden: true){
-			ifUnset "motion", "capability.motionSensor", title: "Motion Here", required: false, multiple: true, submitOnChange:true
-			ifUnset "contact", "capability.contactSensor", title: "Contact Opens", required: false, multiple: true, submitOnChange:true
-			ifUnset "contactClosed", "capability.contactSensor", title: "Contact Closes", required: false, multiple: true, submitOnChange:true
-			ifUnset "acceleration", "capability.accelerationSensor", title: "Acceleration Detected", required: false, multiple: true, submitOnChange:true
-			ifUnset "mySwitch", "capability.switch", title: "Switch Turned On", required: false, multiple: true, submitOnChange:true
-			ifUnset "mySwitchOff", "capability.switch", title: "Switch Turned Off", required: false, multiple: true, submitOnChange:true
-			ifUnset "arrivalPresence", "capability.presenceSensor", title: "Arrival Of", required: false, multiple: true, submitOnChange:true
-			ifUnset "departurePresence", "capability.presenceSensor", title: "Departure Of", required: false, multiple: true, submitOnChange:true
-			ifUnset "smoke", "capability.smokeDetector", title: "Smoke Detected", required: false, multiple: true, submitOnChange:true
-			ifUnset "water", "capability.waterSensor", title: "Water Sensor Wet", required: false, multiple: true, submitOnChange:true
-			ifUnset "button1", "capability.button", title: "Button Press", required:false, multiple:true //remove from production
-			ifUnset "triggerModes", "mode", title: "System Changes Mode", description: "Select mode(s)", required: false, multiple: true, submitOnChange:true
-			ifUnset "timeOfDay", "time", title: "At a Scheduled Time", required: false, submitOnChange:true
-		}
-
-		section (title:"Select LaMetrics"){
-			input "selectedDevices", "capability.notification", required: true, multiple:true
-		}
-        section (title: "Configure message"){
-        	input "defaultMessage", "bool", title: "Use Default Text:\n\"$notificationMessage\"", required: false, defaultValue: true, submitOnChange:true
-	        def showMessageInput = (settings["defaultMessage"] == null || settings["defaultMessage"] == true) ? false : true;
-			if (showMessageInput)
-        	{
-             	input "customMessage","text",title:"Use Custom Text", defaultValue:"", required:false, multiple: false
-        	}
-        	input "selectedIcon", "enum", title: "With Icon", required: false, multiple: false, defaultValue:"1", options: getSortedIconLabels()
-   			input "selectedSound", "enum", title: "With Sound", required: true, defaultValue:"none" , options: soundList
-			input "showPriority", "enum", title: "Is This Notification Very Important?", required: true, multiple:false, defaultValue: "warning", options: priorityList
-		}
-		section("More options", hideable: true, hidden: true) {
-			href "timeIntervalInput", title: "Only during a certain time", description: timeLabel ?: "Tap to set", state: timeLabel ? "complete" : "incomplete"
-			input "days", "enum", title: "Only on certain days of the week", multiple: true, required: false,
-				options: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-			if (settings.modes) {
-            	input "modes", "mode", title: "Only when mode is", multiple: true, required: false
-            }
-		}
-		section([mobileOnly:true]) {
-			label title: "Assign a name", required: false
-			mode title: "Set for specific mode(s)", required: false
-		}
-	}
-}
-
-private songOptions() {
-		log.trace "song option"
-	// Make sure current selection is in the set
-
-	def options = new LinkedHashSet()
-	if (state.selectedSong?.station) {
-		options << state.selectedSong.station
-	}
-	else if (state.selectedSong?.description) {
-		// TODO - Remove eventually? 'description' for backward compatibility
-		options << state.selectedSong.description
-	}
-
-	// Query for recent tracks
-	def states = sonos.statesSince("trackData", new Date(0), [max:30])
-	def dataMaps = states.collect{it.jsonValue}
-	options.addAll(dataMaps.collect{it.station})
-
-	log.trace "${options.size()} songs in list"
-	options.take(20) as List
-}
-
-private anythingSet() {
-	for (it in controlToAttributeMap) {
-    	log.debug ("key ${it.key} value ${settings[it.key]} ${settings[it.key]?true:false}")
-		if (settings[it.key]) {
-	        log.debug constructMessageFor(it.value, settings[it.key])
-			return true
-		}
-	}
-	return false
-}
-
-def defaultNotificationMessage(){
-	def message = "";
-	for (it in controlToAttributeMap)  {
-		if (settings[it.key]) {
-	        message = constructMessageFor(it.value, settings[it.key])
-            break;
-		}
-	}
-	return message;
-}
-
-def constructMessageFor(group, device)
-{
-	log.debug ("$group $device")
-	def message;
-    def firstDevice;
-    if (device instanceof List)
-    {
-    	firstDevice = device[0];
-    } else {
-    	firstDevice = device;
-    }
-    switch(group)
-    {
-    	case "motion.active":
-        	message = "Motion detected by $firstDevice.displayName at $location.name"
-        break;
-        case "contact.open":
-        	message = "Openning detected by $firstDevice.displayName at $location.name"
-        break;
-		case "contact.closed":
-        	message = "Closing detected by $firstDevice.displayName at $location.name"
-        break;
-        case "acceleration.active":
-        	message = "Acceleration detected by $firstDevice.displayName at $location.name"
-        break;
-        case "switch.on":
-        	message = "$firstDevice.displayName turned on at $location.name"
-        break;
-        case "switch.off":
-        	message = "$firstDevice.displayName turned off at $location.name"
-        break;
-        case "presence.present":
-	        message = "$firstDevice.displayName detected arrival at $location.name"
-        break;
-        case "presence.not present":
-	        message = "$firstDevice.displayName detected departure at $location.name"
-        break;
-        case "smoke.detected":
-        	message = "Smoke detected by $firstDevice.displayName at $location.name"
-        break;
-         case "smoke.tested":
-        	message = "Smoke tested by $firstDevice.displayName at $location.name"
-        break;
-        case "water.wet":
-        	message = "Dampness detected by $firstDevice.displayName at $location.name"
-        break;
-        case "button.pushed":
-	        message = "$firstDevice.displayName pushed at $location.name"
-		break;
-        case "time":
-        break;
-//        case "mode":
-//        	message = "Mode changed to ??? at $location.name"
-        break;
-    }
-    return message;
-}
-
-private ifUnset(Map options, String name, String capability) {
-	if (!settings[name]) {
-		input(options, name, capability)
-	}
-}
-
-private ifSet(Map options, String name, String capability) {
-	if (settings[name]) {
-		input(options, name, capability)
-	}
-}
-
-def installed() {
-
-	log.debug "Installed with settings: ${settings}"
-	subscribeToEvents()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-	unsubscribe()
-	unschedule()
-	subscribeToEvents()
-}
-
-def subscribeToEvents() {
-	log.trace "subscribe to events"
-    log.debug "${contact} ${contactClosed} ${mySwitch} ${mySwitchOff} ${acceleration}${arrivalPresence} ${button1}"
-//	subscribe(app, appTouchHandler)
-	subscribe(contact, "contact.open", eventHandler)
-	subscribe(contactClosed, "contact.closed", eventHandler)
-	subscribe(acceleration, "acceleration.active", eventHandler)
-	subscribe(motion, "motion.active", eventHandler)
-	subscribe(mySwitch, "switch.on", eventHandler)
-	subscribe(mySwitchOff, "switch.off", eventHandler)
-	subscribe(arrivalPresence, "presence.present", eventHandler)
-	subscribe(departurePresence, "presence.not present", eventHandler)
-	subscribe(smoke, "smoke.detected", eventHandler)
-	subscribe(smoke, "smoke.tested", eventHandler)
-	subscribe(smoke, "carbonMonoxide.detected", eventHandler)
-	subscribe(water, "water.wet", eventHandler)
-	subscribe(button1, "button.pushed", eventHandler)
-
-	if (triggerModes) {
-		subscribe(location, modeChangeHandler)
-	}
-
-	if (timeOfDay) {
-		schedule(timeOfDay, scheduledTimeHandler)
-	}
-}
-
-def eventHandler(evt) {
-	log.trace "eventHandler(${evt?.name}: ${evt?.value})"
-    def name = evt?.name;
-    def value = evt?.value;
-    
-	if (allOk) {
-			log.trace "allOk"
- 			takeAction(evt)
-		}
-		else {
-			log.debug "Not taking action because it was already taken today"
-		}
-}
-def modeChangeHandler(evt) {
-	log.trace "modeChangeHandler $evt.name: $evt.value ($triggerModes)"
-	if (evt?.value in triggerModes) {
-		eventHandler(evt)
-	}
-}
-
-def scheduledTimeHandler() {
-	eventHandler(null)
-}
-
-def appTouchHandler(evt) {
-	takeAction(evt)
-}
-
-private takeAction(evt) {
-
-	log.trace "takeAction()"
-	def messageToShow
-    if (defaultMessage)
-    {
-    	messageToShow = constructMessageFor("${evt.name}.${evt.value}", evt.device);
-    } else {
-    	messageToShow = customMessage;
-    }
-	if (messageToShow)
-    {
-    	log.debug "text ${messageToShow}"
-    	def notification = [:];
-        def frame1 = [:];
-        frame1.text = messageToShow;
-        if (selectedIcon != "1")
-        {
-        	frame1.icon = state.icons[selectedIcon];
-        } else {
-        	frame1.icon = defaultIconData;
-        }
-        def soundId = sound;
-        def sound = [:];
-        sound.id = selectedSound;
-        sound.category = "notifications";
-        def frames = [];
-        frames << frame1;
-        def model = [:];
-        model.frames = frames;
-        if (selectedSound != "none")
-        {
-        	model.sound = sound;
-        }
-        notification.model = model;
-        notification.priority = showPriority;
-        def serializedData = new JsonOutput().toJson(notification);
-
-        selectedDevices.each { lametricDevice ->
-            log.trace "send notification to ${lametricDevice} ${serializedData}"
-        	lametricDevice.deviceNotification(serializedData)
-        }
-    } else {
-    	log.debug "No message to show"
-    }
-	
-	log.trace "Exiting takeAction()"
-}
-
-private frequencyKey(evt) {
-	"lastActionTimeStamp"
-}
-
-private dayString(Date date) {
-	def df = new java.text.SimpleDateFormat("yyyy-MM-dd")
-	if (location.timeZone) {
-		df.setTimeZone(location.timeZone)
-	}
-	else {
-		df.setTimeZone(TimeZone.getTimeZone("America/New_York"))
-	}
-	df.format(date)
-}
-
-private oncePerDayOk(Long lastTime) {
-	def result = true
-	if (oncePerDay) {
-		result = lastTime ? dayString(new Date()) != dayString(new Date(lastTime)) : true
-		log.trace "oncePerDayOk = $result"
-	}
-	result
-}
-
-// TODO - centralize somehow
-private getAllOk() {
-	modeOk && daysOk && timeOk
-}
-
-private getModeOk() {
-	def result = !modes || modes.contains(location.mode)
-	log.trace "modeOk = $result"
-	result
-}
-
-private getDaysOk() {
-	def result = true
-	if (days) {
-		def df = new java.text.SimpleDateFormat("EEEE")
-		if (location.timeZone) {
-			df.setTimeZone(location.timeZone)
-		}
-		else {
-			df.setTimeZone(TimeZone.getTimeZone("America/New_York"))
-		}
-		def day = df.format(new Date())
-		result = days.contains(day)
-	}
-	log.trace "daysOk = $result"
-	result
-}
-
-private getTimeOk() {
-	def result = true
-	if (starting && ending) {
-		def currTime = now()
-		def start = timeToday(starting, location?.timeZone).time
-		def stop = timeToday(ending, location?.timeZone).time
-		result = start < stop ? currTime >= start && currTime <= stop : currTime <= stop || currTime >= start
-	}
-	log.trace "timeOk = $result"
-	result
-}
-
-private hhmm(time, fmt = "h:mm a")
-{
-	def t = timeToday(time, location.timeZone)
-	def f = new java.text.SimpleDateFormat(fmt)
-	f.setTimeZone(location.timeZone ?: timeZone(time))
-	f.format(t)
-}
-
-private getTimeLabel()
-{
-	(starting && ending) ? hhmm(starting) + "-" + hhmm(ending, "h:mm a z") : ""
-}

smartapps/smartthings/hue-connect.src/hue-connect.groovy

@@ -30,7 +30,6 @@ definition(
 preferences {
 	page(name:"mainPage", title:"Hue Device Setup", content:"mainPage", refreshTimeout:5)
 	page(name:"bridgeDiscovery", title:"Hue Bridge Discovery", content:"bridgeDiscovery", refreshTimeout:5)
-	page(name:"bridgeDiscoveryFailed", title:"Bridge Discovery Failed", content:"bridgeDiscoveryFailed", refreshTimeout:0)
 	page(name:"bridgeBtnPush", title:"Linking with your Hue", content:"bridgeLinking", refreshTimeout:5)
 	page(name:"bulbDiscovery", title:"Hue Device Setup", content:"bulbDiscovery", refreshTimeout:5)
 }
@@ -54,21 +53,12 @@ def bridgeDiscovery(params=[:])
 	def options = bridges ?: []
 	def numFound = options.size() ?: 0
 
-	if (numFound == 0) {
-		if (state.bridgeRefreshCount == 25) {
-			log.trace "Cleaning old bridges memory"
-			state.bridges = [:]
-			app.updateSetting("selectedHue", "")
-		} else if (state.bridgeRefreshCount > 100) {
-			// five minutes have passed, give up
-			// there seems to be a problem going back from discovey failed page in some instances (compared to pressing next)
-			// however it is probably a SmartThings settings issue
-			state.bridges = [:]
-			app.updateSetting("selectedHue", "")
-			state.bridgeRefreshCount = 0
-			return bridgeDiscoveryFailed()
-		}
-	}
+	if (numFound == 0 && state.bridgeRefreshCount > 25) {
+    	log.trace "Cleaning old bridges memory"
+    	state.bridges = [:]
+        state.bridgeRefreshCount = 0
+        app.updateSetting("selectedHue", "")
+    }
 
 	ssdpSubscribe()
 
@@ -89,13 +79,6 @@ def bridgeDiscovery(params=[:])
 	}
 }
 
-def bridgeDiscoveryFailed() {
-	return dynamicPage(name:"bridgeDiscoveryFailed", title: "Bridge Discovery Failed", nextPage: "bridgeDiscovery") {
-		section("Failed to discover any Hue Bridges. Please confirm that the Hue Bridge is connected to the same network as your SmartThings Hub, and that it has power.") {
-		}
-	}
-}
-
 def bridgeLinking()
 {
 	int linkRefreshcount = !state.linkRefreshcount ? 0 : state.linkRefreshcount as int
@@ -105,15 +88,19 @@ def bridgeLinking()
 	def nextPage = ""
 	def title = "Linking with your Hue"
     def paragraphText
+    def hueimage = null
 	if (selectedHue) {
 		paragraphText = "Press the button on your Hue Bridge to setup a link. "
+        hueimage = "http://huedisco.mediavibe.nl/wp-content/uploads/2013/09/pair-bridge.png"
     } else {
     	paragraphText = "You haven't selected a Hue Bridge, please Press \"Done\" and select one before clicking next."
+        hueimage = null
     }
 	if (state.username) { //if discovery worked
 		nextPage = "bulbDiscovery"
 		title = "Success!"
 		paragraphText = "Linking to your hub was a success! Please click 'Next'!"
+        hueimage = null
 	}
 
 	if((linkRefreshcount % 2) == 0 && !state.username) {
@@ -123,6 +110,8 @@ def bridgeLinking()
 	return dynamicPage(name:"bridgeBtnPush", title:title, nextPage:nextPage, refreshInterval:refreshInterval) {
 		section("") {
 			paragraph """${paragraphText}"""
+            if (hueimage != null)
+            	image "${hueimage}"
 		}
 	}
 }
@@ -146,14 +135,13 @@ def bulbDiscovery() {
 	if((bulbRefreshCount % 5) == 0) {
 		discoverHueBulbs()
 	}
-	def selectedBridge = state.bridges.find { key, value -> value?.serialNumber?.equalsIgnoreCase(selectedHue) }
-	def title = selectedBridge?.value?.name ?: "Find bridges"
 
 	return dynamicPage(name:"bulbDiscovery", title:"Bulb Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 		section("Please wait while we discover your Hue Bulbs. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
 			input "selectedBulbs", "enum", required:false, title:"Select Hue Bulbs (${numFound} found)", multiple:true, options:bulboptions
 		}
 		section {
+			def title = getBridgeIP() ? "Hue bridge (${getBridgeIP()})" : "Find bridges"
 			href "bridgeDiscovery", title: title, description: "", state: selectedHue ? "complete" : "incomplete", params: [override: true]
 
 		}
@@ -360,29 +348,26 @@ def addBulbs() {
 			def newHueBulb
 			if (bulbs instanceof java.util.Map) {
 				newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
-
-				if (newHueBulb != null) {
-					d = addChildBulb(dni, newHueBulb?.value?.type, newHueBulb?.value?.name, newHueBulb?.value?.hub)
+                if (newHueBulb != null) {
+                    d = addChildBulb(dni, newHueBulb?.value?.type, newHueBulb?.value?.name, newHueBulb?.value?.hub)
 					if (d) {
 						log.debug "created ${d.displayName} with id $dni"
-						d.completedSetup = true
 						d.refresh()
 					}
-				} else {
-					log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
-				}
+                } else {
+                	log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
+                }
 			} else {
-			 	//backwards compatable
+            	//backwards compatable
 				newHueBulb = bulbs.find { (app.id + "/" + it.id) == dni }
 				d = addChildBulb(dni, "Extended Color Light", newHueBulb?.value?.name, newHueBulb?.value?.hub)
-				d?.completedSetup = true
 				d?.refresh()
 			}
 		} else {
 			log.debug "found ${d.displayName} with id $dni already exists, type: '$d.typeName'"
 			if (bulbs instanceof java.util.Map) {
 				// Update device type if incorrect
-				def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
+            	def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
 				upgradeDeviceType(d, newHueBulb?.value?.type)
 			}
 		}
@@ -414,7 +399,6 @@ def addBridge() {
             }
         	if (newbridge) {
 				d = addChildDevice("smartthings", "Hue Bridge", selectedHue, vbridge.value.hub)
-				d?.completedSetup = true
  				log.debug "created ${d.displayName} with id ${d.deviceNetworkId}"
                 def childDevice = getChildDevice(d.deviceNetworkId)
                 childDevice.sendEvent(name: "serialNumber", value: vbridge.value.serialNumber)
@@ -502,21 +486,7 @@ void bridgeDescriptionHandler(physicalgraph.device.HubResponse hubResponse) {
 		def bridges = getHueBridges()
 		def bridge = bridges.find {it?.key?.contains(body?.device?.UDN?.text())}
 		if (bridge) {
-			// serialNumber from API is in format of 0017882413ad (mac address), however on the actual bridge only last six
-			// characters are printed on the back so using that to identify bridge
-			def idNumber = body?.device?.serialNumber?.text()
-			if (idNumber?.size() >= 6)
-				idNumber = idNumber[-6..-1].toUpperCase()
-
-			// usually in form of bridge name followed by (ip), i.e. defaults to Philips Hue (192.168.1.2)
-			// replace IP with serial number to make it easier for user to identify
-			def name = body?.device?.friendlyName?.text()
-			def index = name?.indexOf('(')
-			if (index != -1) {
-				name = name.substring(0,index)
-				name += " ($idNumber)"
-			}
-			bridge.value << [name:name, serialNumber:body?.device?.serialNumber?.text(), verified: true]
+			bridge.value << [name:body?.device?.friendlyName?.text(), serialNumber:body?.device?.serialNumber?.text(), verified: true]
 		} else {
 			log.error "/description.xml returned a bridge that didn't exist"
 		}

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

@@ -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) {