MSA-1985: SmartThingsToStart

Rolling down staging to master

devicetypes/littlegumsmarthome/opengarage-io-handler.src/opengarage-io-handler.groovy

@@ -1,212 +0,0 @@
-/**
- *  Copyright 2017 Ian Lindsay
- *
- *  Code snippets taken from Tim Slagle
- *  https://community.smartthings.com/u/tslagle13
- *  here:
- *  https://community.smartthings.com/t/generic-camera-device-using-local-connection-new-version-now-available/3269/75?u=l0kiscot
- *
- *
- *  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.
- *
- */
-
-preferences {
-  input("devicekey", "text",     title: "Device Key",   description: "Your OpenGarage.io device key")
-  input("ipadd",       "text",     title: "IP address", description: "The IP address of your OpenGarage.io unit")
-  input("port",     "text",     title: "Port",       description: "The port of your OpenGarage.io unit")
-}
-
-metadata {
-  definition (name: "OpenGarage.io Handler", namespace: "littlegumSmartHome", author: "Ian Lindsay") {
-		capability "Door Control"
-		capability "Garage Door Control"
-		capability "Refresh"
-	}
-
-	tiles (scale: 2){
-        standardTile("garagedoor", "device.garagedoor", width: 6, height: 4) {
-  			state "open", label: '${name}', action: "close", icon: "st.doors.garage.garage-open", backgroundColor: "#e54444"
-  			state "closed", label: '${name}', action: "open", icon: "st.doors.garage.garage-closed", backgroundColor: "#79b821"
-		}
-		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 6, height: 2) {
-			state "default", action: "refresh.refresh", icon: "st.secondary.refresh"
-		}
-
-		main("garagedoor")
-		details(["garagedoor", "refresh"])
-	}
-    simulator {
-        // simulator metadata
-    }
-}
-
-def installed() {
-    initialize()
-}
-
-def initialize() {
-	log.debug "initialize triggered"
-    // initialize state
-    state.doorStatus =  1 // 1 means open, 0 means closed
-	api("getstatus", [])
-}
-
-def open() {
-    log.debug "Executing 'close'"
-    api("openclose", [])
-}
-
-def close() {
-	log.debug "Executing 'close'"
-    api("openclose", [])
-}
-
-def refresh() {
-	log.debug "Refreshing Values "
-    
-    api("getstatus", [])
-}
-
-def api(method, args = [], success = {}) {
-  def methods = [
-    "getstatus": [gdipadd: "${ipadd}", gdport:"${port}", gdpath:"/jc", gdtype: "get"],
-    "openclose": [gdipadd: "${ipadd}", gdport:"${port}", gdpath:"/cc?dkey=${devicekey}&click=1", gdtype: "get"]
-  ]
-
-  def request = methods.getAt(method)
-
-  doRequest(request.gdipadd, request.gdport, request.gdpath, request.gdtype, success)
-}
-
-private doRequest(gdipadd, gdport, gdpath, gdtype, success) {
-  log.debug(gdipadd)
-
-  //if(type == "post") {
-  //  httpPost(uri , "", success)
-  //}
-
-  //else if(type == "get") {
-  //  httpGet(uri, success)
-  //}
-  
-    def host = gdipadd
-    def hosthex = convertIPToHex(host)
-    def porthex = Long.toHexString(Long.parseLong((gdport)))
-    if (porthex.length() < 4) { porthex = "00" + porthex }
-    
-    //log.debug "Port in Hex is $porthex"
-    //log.debug "Hosthex is : $hosthex"
-    device.deviceNetworkId = "$hosthex:$porthex" 
-    
-     //log.debug "The device id configured is: $device.deviceNetworkId"
-
-    //def path = gdpath //"/SnapshotJPEG?Resolution=640x480&Quality=Clarity"
-    log.debug "path is: $gdpath"
-    
-    def headers = [:] //"HOST:" + getHostAddress() + ""
-    headers.put("HOST", "$host:$gdport")
-  
-  try {
-        def hubAction = new physicalgraph.device.HubAction(
-        	method: method,
-        	path: gdpath,
-        	headers: headers
-            )  
-    }
-    catch (Exception e) 
-    {
-        log.debug "Hit Exception on $hubAction"
-        log.debug e
-    }
-  
-}
-
-def parse(description) {
-
-    def msg = parseLanMessage(description)
-	
-    log.debug msg
-    
-    def headersAsString = msg.header // => headers as a string
-    def headerMap = msg.headers      // => headers as a Map
-    def body = msg.body              // => request body as a string
-    def status = msg.status          // => http status code of the response
-    //def json = msg.json              // => any JSON included in response body, as a data structure of lists and maps
-    //def xml = msg.xml                // => any XML included in response body, as a document tree structure
-    //def data = msg.data              // => either JSON or XML in response body (whichever is specified by content-type header in response)
-	
-    def slurper = new groovy.json.JsonSlurper()
- 	def json = slurper.parseText(msg.body)
- 
-    log.debug json
-    
-    def result
-	log.debug "before state.doorStatus: $state.doorStatus"
-    
-    // open / close event
-	if(json.result){
-    	if(state.doorStatus){
-        	log.debug "door open - so closing"
-        	state.doorStatus = 0
-            result = createEvent(name: "garagedoor", value: "closed")
-        } else {
-        	log.debug "door closed - so opening"
-        	state.doorStatus = 1
-            result = createEvent(name: "garagedoor", value: "open")
-        }
-     }
-    //status update request
-    if(json.mac){
-    	if(json.door){
-        	log.debug "door is open - refreshing setting"
-        	state.doorStatus = 1
-            result = createEvent(name: "garagedoor", value: "open")
-        } else {
-        	log.debug "door is closed - refreshing setting"
-        	state.doorStatus = 0
-            result = createEvent(name: "garagedoor", value: "closed")
-        }
-    }
-    
-    log.debug "after state.doorStatus: $state.doorStatus"
-    
-    return result
-}
-
-private Long converIntToLong(ipAddress) {
-	long result = 0
-	def parts = ipAddress.split("\\.")
-    for (int i = 3; i >= 0; i--) {
-        result |= (Long.parseLong(parts[3 - i]) << (i * 8));
-    }
-
-    return result & 0xFFFFFFFF;
-}
-
-private String convertIPToHex(ipAddress) {
-	return Long.toHexString(converIntToLong(ipAddress));
-}
-
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
-}
-private String convertHexToIP(hex) {
-log.debug("Convert hex to ip: $hex") //	a0 00 01 6
-	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
-}
-
-private getHostAddress() {
-	def parts = device.deviceNetworkId.split(":")
-    log.debug device.deviceNetworkId
-	def ip = convertHexToIP(parts[0])
-	def port = convertHexToInt(parts[1])
-	return ip + ":" + port
-}

devicetypes/smartthings/smartalert-siren.src/README.md

@@ -4,7 +4,7 @@ Cloud Execution
 
 Works with:
 
-* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-valve)
+* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/products/fortrezz-siren-strobe-alarm)
 
 ## Table of contents
 

devicetypes/smartthings/zigbee-dimmer.src/zigbee-dimmer.groovy

@@ -25,6 +25,7 @@ metadata {
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart A19 Soft White"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM 10 Year", deviceJoinName: "SYLVANIA Smart 10-Year A19"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FF00", outClusters: "0019", manufacturer: "MRVL", model: "MZ100", deviceJoinName: "Wemo Bulb"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B05", outClusters: "0019", manufacturer: "OSRAM SYLVANIA", model: "iQBR30", deviceJoinName: "Sylvania Ultra iQ"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY PAR38 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart PAR38 Soft White"

smartapps/gideon-api/gideon-smart-home.src/gideon-smart-home.groovy

@@ -765,7 +765,6 @@ def turnOffSwitch() {
         } else {
             
             device.off();
-                  
             return [Device_id: params.id, result_action: "200"]
         }
 }
@@ -789,6 +788,7 @@ def getTempSensorsStatus(id) {
             return []
         } else {
         	def bat = getBatteryStatus(device.id)
-        	return [temperature: device.currentValue('temperature')] + bat
+            def scale = [Scale: location.temperatureScale]
+        	return [temperature: device.currentValue('temperature')] + bat + scale
    		}
-   }
+   }

smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy

@@ -162,6 +162,17 @@ def registerAllDeviceSubscriptions() {
 	registerChangeHandler(inputs)
 }
 
+//Subscribe to events from a list of devices
+def registerChangeHandler(myList) {
+	myList.each { myDevice ->
+		def theAtts = myDevice.supportedAttributes
+		theAtts.each { att ->
+			subscribe(myDevice, att.name, deviceEventHandler)
+			log.info "Registering for ${myDevice.displayName}.${att.name}"
+		}
+	}
+}
+
 //Endpoints function: Subscribe to events from a specific device
 def registerDeviceChange() {
 	def subscriptionEndpt = params.subscriptionURL

smartapps/torick-net/smartthingstostart.src/smartthingstostart.groovy

@@ -0,0 +1,373 @@
+/**
+ *  SmartThingsToStart REST Api
+ *
+ *  Copyright 2017 Dr1rrb
+ *
+ *  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: "SmartThingsToStart",
+	namespace: "torick.net",
+	author: "Dr1rrb",
+	description: "SmartThingsToStart REST Api",
+	category: "My Apps",
+	iconUrl: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo.png",
+	iconX2Url: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo@2X.png",
+	iconX3Url: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo@3X.png",
+	oauth: true)
+
+
+preferences {
+	section("Control these devices") {
+		input "switches", "capability.switch", title: "Select switches", multiple: true, required: false
+		input "bubls", "capability.bulb", title: "Select bubls", hideWhenEmpty: true, multiple: true, required: false
+		input "lights", "capability.light", title: "Select lights", hideWhenEmpty: true, multiple: true, required: false
+		input "outlets", "capability.outlet", title: "Select outlets", hideWhenEmpty: true, multiple: true, required: false
+		input "relaySwitches", "capability.relaySwitch", title: "Select relay switches", hideWhenEmpty: true, multiple: true, required: false
+	}
+}
+
+mappings {
+	path("/infos") {
+		action: [GET: "retreiveServerInfos"]
+  	}
+    path("/items") {
+		action: [GET: "retreiveDevicesAndRoutines"]
+  	}
+	path("/device/:id") {
+		action: [GET: "retreiveDevice"]
+	}
+	path("/device/:id/subscription/:subscriptionId") {
+		action: [
+			PUT: "updateOrCreateSubscription",
+			POST: "updateOrCreateSubscription",
+		]
+	}
+    // TODO
+	//path("/device/:id/unsubscribe") {
+	//	action: [POST: "unsubscribeFromDevice"]
+	//}
+	path("/device/:id/:command") {
+		action: [ PUT: "updateDevice" ]
+	}
+    path("/routine/:id/execute") {
+		action: [PUT: "executeRoutine"]
+	}
+}
+
+// Region: App lifecycle
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+
+	initialize()
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	unsubscribe()
+    //state.pushChannels = [:]
+	initialize()
+}
+
+def initialize() {
+	def channels = state.pushChannels = state.pushChannels ?: [:];
+	channels.each 
+	{ 
+		def device = findDevice(it.key);
+		if (device != null)
+		{
+			subscribeToDevice(device);
+		}
+	}
+}
+
+
+// Region: Http request handlers
+def retreiveServerInfos()
+{
+	return [version: 1]
+}
+
+def retreiveDevicesAndRoutines() {
+	def details = params.details == "true" ? true : false;
+
+	return [
+		devices: getDevices().collect { getDeviceInfos(it, details) }, 
+		routines: location.helloHome?.getPhrases().collect { getRoutineInfos(it, details) }
+	];
+}
+
+def retreiveDevice() {
+	def device = getDevice(params.id);
+	def details = params.details == "true" ? true : false;
+	
+	return getDeviceInfos(device, details);
+}
+
+def updateOrCreateSubscription() {
+	def device = getDevice(params.id);
+	def channelUri = notNull("channelUri", request.JSON?.channelUri);
+	def token = notNull("token", request.JSON?.token);
+	
+	log.debug "Subscribing to device '${device.id}' (target: '${channelUri}' / token: '${token}')"
+
+	// Get or create the push notification channel from / into the local state
+	def subscriptionId = params.subscriptionId ?: UUID.randomUUID().toString() ;
+	def allSubscriptions = state.pushChannels ?: (state.pushChannels = [:]);
+	def deviceSubscriptions = allSubscriptions[device.id] ?: (allSubscriptions[device.id] = []);
+	def subscription = deviceSubscriptions.find { it.id == subscriptionId };
+	if (subscription == null)
+	{
+		deviceSubscriptions << [
+			id: subscriptionId,
+			deviceId: device.id,
+			channelUri: channelUri,
+			token: token
+		];
+	}
+	else
+	{
+		subscription["channelUri"] = channelUri;
+		subscription["token"]  = token;
+	}
+	
+	log.debug "Active subscriptions: \n" + state.pushChannels.collect { "** Device ${it.key} **\n" + it.value.collect{c -> "- - - > ${c.channelUri} : ${c.token.substring(0, 10)}..."}.join('\n') + "\n***************************" }.join('\n\n')
+	
+	// (Re)create the subscription(s)
+	subscribeToDevice(device)
+
+	return [subscriptionId: subscriptionId];
+}
+
+def subscribeToDevice(device)
+{
+	log.debug "Subscribing to device '${device.id}'"
+
+	unsubscribe(device);
+	subscribe(device, "switch", switchStateChanged)
+
+	if (device.hasCapability("Color Control"))
+	{
+		log.debug "Device '${device.id}' has also the color capability. Subscribe to it."
+		subscribe(device, "color", colorStateChanged)
+	}
+}
+
+def switchStateChanged(eventArgs) { sendPushNotification("switch", eventArgs) }
+def colorStateChanged(eventArgs) { sendPushNotification("color", eventArgs) }
+
+def updateDevice() {
+	def device = getDevice(params.id)
+	def command = notNull("command", params.command)
+	
+	log.debug "Executing '${command}' on device '${device.id}'."
+	
+	switch(command) {
+		case "on":
+		case "On":
+			device.on()
+			break
+
+		case "off":
+		case "Off":
+			device.off()
+			break
+
+		case "toggle":
+		case "Toggle":
+			if (device.currentSwitch == "on")
+				device.off();
+			else
+				device.on();
+			break;
+
+		default:
+			httpError(501, "'${command}' is not a valid command for '${device.id}'")
+	}
+	
+	return getDeviceInfos(device);
+}
+
+def executeRoutine() {
+	def routine = getRoutine(params.id);
+    log.debug "Executing routine '${routine.id}' (${routine.label})"
+    
+    location.helloHome?.execute(routine.id)
+}
+
+// Region: Get device
+def getDevices()
+{
+	return switches
+		+ bubls
+		+ lights
+		+ outlets
+		+ relaySwitches;
+}
+
+def findDevice(deviceId)
+{
+	notNull("deviceId", deviceId);
+	
+	return getDevices().find { it.id == deviceId };
+}
+
+def getDevice(deviceId)
+{
+	def device = findDevice(deviceId);
+	if (device == null)
+	{
+		httpError(404, "Device '${deviceId}' not found.")
+	}
+	return device;
+}
+
+// Region: Get routine
+def findRoutine(routineId)
+{
+	return location.helloHome?.getPhrases().find{ it.id == routineId};
+}
+
+def getRoutine(routineId)
+{
+	def routine = findRoutine(routineId);
+	if (routine == null)
+	{
+		httpError(404, "Routine '${routineId}' not found.")
+	}
+	return routine;
+}
+
+// Region: Parameters assertion helpers
+def notNull(parameterName, value)
+{
+	if(value == null || value == "")
+	{
+		httpError(404, "Missing parameter '${parameterName}'.")
+	}
+	return value;
+}
+
+// Region: Get infos
+def getDeviceInfos(device, details = false)
+{
+   	def infos = [
+		id: device.id,
+		name: device.displayName,
+		state: device.currentValue("switch"),
+        color: device.currentValue("color"),
+        hue: device.currentValue("hue"),
+        saturation: device.currentValue("saturation"),
+		capabilities: device.capabilities.collect { getCapabilityInfos(it, details) }
+	]
+	
+	if (details)
+	{
+		infos["attributes"] = device.supportedAttributes.collect { getAttributeInfos(it, details) }
+		infos["commands"] = device.supportedCommands.collect { getCommandInfos(it, details) }
+	}
+	
+	return infos;
+}
+
+def getCapabilityInfos(capablity, details = false)
+{
+	def infos = [name: capablity.name]
+	
+	if(details)
+	{
+		infos["attributes"] = capablity.attributes.collect { getAttributeInfos(it, details) }
+		infos["commands"] = capablity.commands.collect { getCommandInfos(it, details) }
+	}
+	
+	return infos;
+}
+
+def getCommandInfos(command, details = false)
+{
+	return [
+		name: command.name, 
+		arguments: command.arguments
+	]
+}
+
+def getAttributeInfos(attribute, details = false)
+{
+	return [
+		name: attribute.name, 
+		arguments: attribute.dataType,
+		values: attribute.values
+	]
+}
+
+def getRoutineInfos(routine, details = false)
+{
+	def infos = [
+    	id: routine.id,
+        name: routine.label
+	];
+    
+    if (details)
+    {
+    	infos["hasSecureActions"] = routine.hasSecureActions;
+        infos["action"] = routine.action;
+    }
+    
+    return infos;
+}
+
+// Region: Push notification
+def sendPushNotification(capability, eventArgs)
+{
+	def deviceId = eventArgs.deviceId;
+	log.debug "Received notification for '${capability}' for device '${deviceId}'.";
+	
+	def subscriptions = state.pushChannels.get(deviceId);
+	if (subscriptions == null || subscriptions.empty)
+	{
+		log.error "No subscription found for device ${deviceId}, unsubscribing!";
+		unsubscribe(eventArgs.device);
+		
+		return;
+	}
+
+	subscriptions.groupBy { it.channelUri }.each { sendPushNotification(capability, eventArgs, it.key, it.value) }
+}
+
+def sendPushNotification(capability, eventArgs, channelUri, subscriptions)
+{
+	try {
+		def request = [
+			uri: channelUri,
+			//headers: [name: "Authorization", value: "Bearer ${subscription.token}"],
+			body: [
+				location: [
+					id: eventArgs.locationId,
+				],
+				device: getDeviceInfos(eventArgs.device),
+				event: [
+					source: capability, 
+					date: eventArgs.isoDate, 
+					value: eventArgs.value,
+					name: eventArgs.name,
+				],
+				subscriptions: subscriptions.collect { [id: it.id, token: it.token] }
+			]
+		]
+		
+		// Async post is still in beta stage ...
+		httpPostJson(request) { resp -> log.debug "response: ${resp.status}." }
+		
+	} catch (e) {
+		log.error "Failed to push notification: ${e}"
+	}
+}