Modifying 'LaMetric Time device handler and smart apps'

Would be great to have the device listed in Displays or similar category.
Device info: http://lametric.com

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

@@ -0,0 +1,126 @@
+/**
+ *  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
+}*/

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

@@ -0,0 +1,839 @@
+/**
+ *  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

@@ -0,0 +1,536 @@
+/**
+ *  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/programmable-thermostat.src/programmable-thermostat.groovy

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

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

@@ -92,22 +92,87 @@ void updateLock() {
 
 private void updateAll(devices) {
 	def command = request.JSON?.command
-	if (command) {
-		devices."$command"()
+	def type = params.param1
+	if (!devices) {
+		httpError(404, "Devices not found")
+	}
+	
+	if (command){
+		devices.each { device ->
+			executeCommand(device, type, command)
+		}
 	}
 }
 
 private void update(devices) {
 	log.debug "update, request: ${request.JSON}, params: ${params}, devices: $devices.id"
 	def command = request.JSON?.command
-	if (command) {
-		def device = devices.find { it.id == params.id }
-		if (!device) {
-			httpError(404, "Device not found")
-		} else {
-			device."$command"()
-		}
+	def type = params.param1
+	def device = devices?.find { it.id == params.id }
+
+	if (!device) {
+		httpError(404, "Device not found")
 	}
+
+	if (command) {
+		executeCommand(device, type, command)
+	}
+}
+
+/**
+ * Validating the command passed by the user based on capability.
+ * @return boolean
+ */
+def validateCommand(device, deviceType, command) {
+	def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
+	def currentDeviceCapability = getCapabilityName(deviceType)
+	if (capabilityCommands[currentDeviceCapability]) {
+		return command in capabilityCommands[currentDeviceCapability] ? true : false
+	} else {
+		// Handling other device types here, which don't accept commands
+		httpError(400, "Bad request.")
+	}
+}
+
+/**
+ * Need to get the attribute name to do the lookup. Only
+ * doing it for the device types which accept commands
+ * @return attribute name of the device type
+ */
+def getCapabilityName(type) {
+    switch(type) {
+		case "switches":
+			return "Switch"
+		case "locks":
+			return "Lock"
+		default:
+			return type
+	}
+}
+
+/**
+ * Constructing the map over here of
+ * supported commands by device capability
+ * @return a map of device capability -> supported commands
+ */
+def getDeviceCapabilityCommands(deviceCapabilities) {
+	def map = [:]
+	deviceCapabilities.collect {
+		map[it.name] = it.commands.collect{ it.name.toString() }
+	}
+	return map
+}
+
+/**
+ * Validates and executes the command
+ * on the device or devices
+ */
+def executeCommand(device, type, command) {
+	if (validateCommand(device, type, command)) {
+		device."$command"()
+	} else {
+		httpError(403, "Access denied. This command is not supported by current capability.")
+	}	
 }
 
 private show(devices, name) {