MyQ Garage SmartThings device handler

myq.groovy

/**
 *  MyQ Garage Door
 *
 *  Copyright 2018 Yuxuan Wang
 *
 *  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.
 *
 */

// This is a combination of https://github.com/adamheinmiller/ST_MyQ and https://github.com/Einstein42/myq-garage
// adamheinmiller/ST_MyQ by Adam Heinmiller, Apache License
// Einstein42/myq-garage by Einstein42, MIT License

metadata {
	definition (name: "MyQ Garage Door", namespace: "fishy", author: "Yuxuan Wang") {
		capability "Contact Sensor"
		capability "Door Control"
		capability "Garage Door Control"
		capability "Momentary"
		capability "Polling"
		capability "Refresh"
		capability "Switch"

		attribute "lastDoorAction", "string"
		attribute "lastHttpStatus", "enum", ["succeeded", "failed"]
	}

	preferences {
		input(
			name: "username",
			type: "text",
			title: "Username",
			description: "MyQ username (email address)",
		)

		input(
			name: "password",
			type: "password",
			title: "Password",
			description: "MyQ password",
		)

		input(
			name: "door_name",
			type: "text",
			title: "Door Name",
			description: "MyQ Garage Door name (default: \"Garage Door\")",
		)
		input(
			name: "refresh_rate",
			type: "enum",
			title: "State Refresh Rate",
			options: [
				"Every minute",
				"Every 5 minutes",
				"Every 10 minutes",
				"Every 15 minutes",
				"Every 30 minutes",
				"Every hour",
				"Disabled",
			],
			description: "Only disable it if you have another contact sensor hooked on the garage door",
			required: true,
		)
	}

	tiles {
		standardTile("sDoorToggle", "device.door", width: 1, height: 1, canChangeIcon: false) {
			state(
				"default",
				label: "",
			)

			state(
				"unknown",
				label: "Unknown",
				icon: "st.unknown.unknown.unknown",
				action: "refresh.refresh",
				backgroundColor: "#afafaf",
			)

			state(
				"stopped",
				label: "Stopped",
				icon: "st.contact.contact.open",
				action: "close",
				backgroundColor: "#ffdd00",
			)
			state(
				"closed",
				label: "Closed",
				icon: "st.doors.garage.garage-closed",
				action: "open",
				backgroundColor: "#00a0dc",
			)
			state(
				"closing",
				label: "Closing",
				icon: "st.doors.garage.garage-closing",
				backgroundColor: "#ffdd00",
			)
			state(
				"open",
				label: "Open",
				icon: "st.doors.garage.garage-open",
				action: "close",
				backgroundColor: "#ffdd00",
			)
			state(
				"opening",
				label: "Opening",
				icon: "st.doors.garage.garage-opening",
				backgroundColor: "#ffdd00",
			)
			state(
				"moving",
				label: "Moving",
				icon: "st.motion.motion.active",
				action: "refresh.refresh",
				backgroundColor: "#ffdd00",
			)
		}

		standardTile("sRefresh", "device.door", inactiveLabel: false, decoration: "flat") {
			state(
				"default",
				label: "",
				action: "refresh.refresh",
				icon: "st.secondary.refresh",
			)
		}

		standardTile("sContact", "device.contact") {
			state(
				"open",
				label: "${name}",
				icon: "st.contact.contact.open",
				backgroundColor: "#ffa81e",
			)
			state(
				"closed",
				label: "${name}",
				icon: "st.contact.contact.closed",
				backgroundColor: "#79b821",
			)
		}

		valueTile("vLastDoorAction", "device.lastDoorAction", width: 2, height: 1, decoration: "flat") {
			state "default", label: '${currentValue}'
		}

		main(["sDoorToggle"])
		details(["sDoorToggle", "vLastDoorAction", "sRefresh"])
	}
}


def installed() {
	log.debug "Installing MyQ Garage Door"

	state.Login = [ Expiration: 0 ]
	state.DeviceID = 0
	
	checkLogin(settings, state)
	checkRefresh(settings)
}

def updated() {
	log.debug "Updating MyQ Garage Door"
	
	state.Login = [ Expiration: 0 ]
	//state.Login.Expiration = 0
	state.DeviceID = 0
	
	checkLogin(settings, state)
	checkRefresh(settings)
}

// parse events into attributes
def parse(String description) {
	log.debug "Parsing '${description}'"
	// TODO: handle 'contact' attribute
	// TODO: handle 'switch' attribute

}

// handle commands
def push() {
	log.debug "Executing 'push'"

	checkLogin(settings, state)

	def dInitStatus
	getDoorStatus(state) { status -> dInitStatus = status }


	if (dInitStatus == "closed" || dInitStatus == "closing" || dInitStatus == "stopped" || dInitStatus == "moving") {
		log.debug "Door is in a closed status, opening"
		
		open()
	} else if (dInitStatus == "open" || dInitStatus == "opening") {
		log.debug "Door is in an open status, closing"
		
		close()
	} else if (dInitStatus == "unknown") {
		log.debug "Door is in an unknown state, doing nothing"
	}
}

def poll() {
	log.debug "MyQ Garage door Polling"
	
	refresh()
}

def refresh() {
	doRefresh()
}

def checkRefresh(settings) {
	switch (settings.refresh_rate.toLowerCase()) {
	case "disabled":
		unschedule(doRefresh)
		doRefresh()
		break
	case "every 5 minutes":
		runEvery5Minutes(doRefresh)
		break
	case "every 10 minutes":
		runEvery10Minutes(doRefresh)
		break
	case "every 15 minutes":
		runEvery15Minutes(doRefresh)
		break
	case "every 30 minutes":
		runEvery30Minutes(doRefresh)
		break
	case "every hour":
		runEvery1Hour(doRefresh)
		break
	case "every minute":
	default:
		runEvery1Minute(doRefresh)
		break
	}
}

def doRefresh() {
	log.debug "Refreshing Door State"

	checkLogin(settings, state)

	getDoorStatus(state) { status ->
		setDoorState(status)
		log.debug "Door Status: $status"
	}
}

def afterForceRefresh(status, startTime) {
	def time = (now() - startTime) / 1000
	log.debug "Final Door Status: $status, took $time seconds"
	setDoorState(status)
}

def forceRefreshUntil(data) {
	def timestamp = now()
	def target = data.targetStatus
	log.debug "forceRefreshUntil: ${new Date()}, timestamp: $timestamp, stops at ${data.stopAt}, target status: $target"
	def scheduleNext = true
	if (timestamp >= data.stopAt) {
		log.debug "Stopping refreshing..."
		getDoorStatus(state) { status ->
			afterForceRefresh(status, data.startTime)
		}
		scheduleNext = false
		return
	}
	getDoorStatus(state) { status ->
		log.debug "forceRefreshUntil: get door status: $status"
		if (status == target) {
			log.debug "Got target status $status, stopping refreshing..."
			afterForceRefresh(status, data.startTime)
			scheduleNext = false
			return
		}
	}
	if (scheduleNext) {
		def options = [
			overwrite: true,
			data: data,
		]
		runIn(3, forceRefreshUntil, options)
	} else {
		unschedule(forceRefreshUntil)
	}
}

def refreshUntil(target) {
	log.debug "refreshUntil: $target"
	def maxMin = 5
	def timestamp = now() + 60 * 1000 * maxMin
	def data = [
		startTime: now(),
		stopAt: timestamp,
		targetStatus: target,
	]
	forceRefreshUntil(data)
}

def on() {
	log.debug "Executing 'on'"

	open()
}

def off() {
	log.debug "Executing 'off'"

	close()
}

def open() {
	log.debug "Opening Door"


	checkLogin(settings, state)


	def dInitStatus
	def dCurrentStatus = "opening"

	getDoorStatus(state) { status -> dInitStatus = status }
				
	if (dInitStatus == "opening" || dInitStatus == "open" || dInitStatus == "moving") { return }


	setDoorState("opening")
	openDoor(state)
	refreshUntil("open")
}

def close() {
	log.debug "Closing Door"


	checkLogin(settings, state)


	def dInitStatus
	def dCurrentStatus = "closing"
	def dTotalSleep = 0

	getDoorStatus(state) { status -> dInitStatus = status }
				
	if (dInitStatus == "closing" || dInitStatus == "closed" || dInitStatus == "moving") { return }


	setDoorState("closing")
	closeDoor(state)
	refreshUntil("closed")
}


def checkLogin(settings, state) {
	//log.debug "Checking Login Credentials"

	def logins = state.Login
	log.debug "login: $logins"

	if (state.Login.Expiration <= new Date().getTime()) {
		def now = new Date().getTime()
		def expiration = state.Login.Expiration
		log.debug "expiration: $expiration, now: $now"
		login(settings, state)
	}


	if (state.DeviceID == 0) {
		getDevice(settings, state)
	}
}


def login(settings, state) {
	log.debug "Logging In to Webservice"

	def logins = state.Login
	log.debug "login: $logins"

	def body = [
		username: settings.username,
		password: settings.password,
	]

	callApiPost(state, "api/v4/User/Validate", body) { response ->

		log.debug "response: $response"

		state.Login = [

			BrandID: response.data.BrandName,
			UserID: response.data.UserId,
			SecToken: response.data.SecurityToken,
			Expiration: (new Date()).getTime() + 600000
		]

		log.debug "Sec Token: $state.Login.SecToken"
	}
}

def getDevice(settings, state) {
	log.debug "Getting MyQ Devices"

	callApiGet(state, "api/v4/userdevicedetails/get") { response ->

		def garageDevices = response.getData().Devices.findAll{ it.MyQDeviceTypeId == 2 }

		if (garageDevices.isEmpty() == true) {
			log.debug "Device Discovery found no supported door devices"
			sendEvent(
				name: "lastHttpStatus",
				value: "failed",
				displayed: true,
				descriptionText: "Device Discovery found no supported door devices",
			)
			return
		}

		state.DeviceID = 0

		def doorName = "garage door"
		if (settings.door_name != null) {
			doorName = settings.door_name.toLowerCase()
		}

		garageDevices.each { pDevice ->

			log.debug "device = $pDevice"

			def doorAttrib = pDevice.Attributes.find{ it.AttributeDisplayName == "desc" }

			if (doorAttrib.Value.toLowerCase() == doorName) {
				log.debug "Door ID: $pDevice.MyQDeviceId"
				state.DeviceID = pDevice.MyQDeviceId
			}
		}


		if (state.DeviceID == 0) {
			log.debug "Supported door devices were found but none matched name '$settings.door_name'"
		}

	}

}


def getDoorStatus(state, initialStatus = null, callback) {

	callApiGet(state, "api/v4/userdevicedetails/get") { response ->
		def garageDevices = response.getData().Devices.findAll{ it.MyQDeviceId == state.DeviceID }

		if (garageDevices.isEmpty() == true) {
			log.debug "Cannot find the garage door"
			return
		}

		garageDevices.each { pDevice ->
			def stateAttrib = pDevice.Attributes.find{ it.AttributeDisplayName == "doorstate" }
			def doorState = translateDoorStatus( stateAttrib.Value, initialStatus )
			calcLastActivityTime(stateAttrib.UpdatedTime.toLong(), doorState)
			callback(doorState)
		}
	}
}


def calcLastActivityTime(lastActivity, doorState) {
	def currentTime = new Date().getTime()
	def diffTotal = currentTime - lastActivity

	def lastActLabel = ""

	//diffTotal = (86400000 * 12) + (3600000 * 2) + (60000 * 1)

	def diffDays = (diffTotal / 86400000) as long
	def diffHours = (diffTotal % 86400000 / 3600000) as long
	def diffMinutes = (diffTotal % 86400000 % 3600000 / 60000) as long
	def diffSeconds = (diffTotal % 86400000 % 3600000 % 60000 / 1000) as long


	if (diffDays == 1) lastActLabel += "${diffDays} Day"
	else if (diffDays > 1) lastActLabel += "${diffDays} Days"

	if (diffDays > 0 && diffHours > 0) lastActLabel += ", "

	if (diffHours == 1) lastActLabel += "${diffHours} Hour"
	else if (diffHours > 1) lastActLabel += "${diffHours} Hours"

	if (diffDays == 0 && diffHours > 0 && diffMinutes > 0) lastActLabel += ", "

	if (diffDays == 0 && diffMinutes == 1) lastActLabel += "${diffMinutes} Minute"
	if (diffDays == 0 && diffMinutes > 1) lastActLabel += "${diffMinutes} Minutes"

	if (diffTotal < 60000) lastActLabel = "${diffSeconds} Seconds"

	sendEvent(
		name: "lastDoorAction",
		value: lastActLabel,
		displayed: true,
		descriptionText: "$doorState time is $lastActLabel",
	)
}


def openDoor(state) {	
	def value = "1"

	callApiPut(state, "api/v4/DeviceAttribute/PutDeviceAttribute", value) { response ->

		// if error, do something?
	}
}


def closeDoor(state) {	
	def value = "0"

	callApiPut(state, "api/v4/DeviceAttribute/PutDeviceAttribute", value) { response ->

		// if error, do something?
	}
}


def setContactSensorState(status) {
	// Sync contact sensor
	if (status == "open" || status == "opening" || status == "stopped" || status == "closing") {
		sendEvent(
			name: "contact",
			value: "open",
			displayed: true,
			descriptionText: "Contact is open",
		)
		sendEvent(
			name: "switch",
			value: "on",
			displayed: true,
			descriptionText: "Switch is on",
		)
	} else if (status == "closed") {
		sendEvent(
			name: "contact",
			value: "closed",
			displayed: true,
			descriptionText: "Contact is closed",
		)
		sendEvent(
			name: "switch",
			value: "off",
			displayed: true,
			descriptionText: "Switch is off",
		)
	}
}


def setDoorState(status) {
	sendEvent(
		name: "door",
		value: status,
		displayed: true,
		descriptionText: "Door is $status",
	)
	setContactSensorState(status)
}


def translateDoorStatus(status, initStatus = null) {
	def dReturn = "unknown"

	if (status == "2") dReturn = "closed"
	else if (status == "1" || status == "9") dReturn = "open"
	else if (status == "4" || (status == "8" && initStatus == "closed")) dReturn = "opening"
	else if (status == "5" || (status == "8" && initStatus == "open")) dReturn = "closing"
	else if (status == "3") dReturn = "stopped"
	else if (status == "8" && initStatus == null) dReturn = "moving"

	if (dReturn == "unknown") { log.debug "Unknown Door Status ID: $status" }

	log.debug "state = $dReturn"
	return dReturn
}


def getVarParams() {
	def dParams = [
		BaseURL: "https://myqexternal.myqdevice.com/",
		AppId: "NWknvuBd7LoFHfXmKNMBcgajXtZEgKUh4V7WNzMidrpUUluDpVYVZx+xT4PCM5Kx",
		BrandId: "2",
		UserAgent: "Chamberlain/3.73",
		ApiVersion: "4.1",
		Culture: "en",
	]

	return dParams
}


def callApiPut(state, apipath, value, callback = {}) {

	def finalHeaders = [
		"User-Agent": getVarParams().UserAgent,
		"BrandId": getVarParams().BrandId,
		"ApiVersion": getVarParams().ApiVersion,
		"Culture": getVarParams().Culture,
		"MyQApplicationId": getVarParams().AppId,
		"SecurityToken": state.Login.SecToken,
	]

	def query = [
		"appId": getVarParams().AppId,
		"SecurityToken": state.Login.SecToken,
	]

	def body = [
		"MyQDeviceId": state.DeviceID,
		"SecurityToken": state.Login.SecToken,
		"ApplicationId": getVarParams().AppId,
		"AttributeValue": value,
		"AttributeName": "desireddoorstate",
		"format": "json",
		"nojsoncallback": "1",
	]

	def finalParams = [
		uri: getVarParams().BaseURL,
		path: apipath,
		query: query,
		headers: finalHeaders,
		body: body,
	]

	//log.debug finalParams

	try {
		httpPutJson(finalParams) { response ->
			log.debug response.data

			if (response.data.ErrorMessage) {

				log.debug "API Error: $response.data"
			}

			sendEvent(
				name: "lastHttpStatus",
				value: "succeeded",
				displayed: true,
				descriptionText: "HTTP request succeeded",
			)

			callback(response)
		}

	} catch (Error e) {
		// setDoorState("unknown")
		sendEvent(
			name: "lastHttpStatus",
			value: "failed",
			displayed: true,
			descriptionText: "HTTP request failed",
		)

		log.debug "API Error: $e"
	}

}


def callApiGet(state, apipath, callback = {}) {

	def finalHeaders = [
		"User-Agent": getVarParams().UserAgent,
		"BrandId": getVarParams().BrandId,
		"ApiVersion": getVarParams().ApiVersion,
		"Culture": getVarParams().Culture,
		"MyQApplicationId": getVarParams().AppId,
		"SecurityToken": state.Login.SecToken,
	]

	def finalQParams = [
		"appId": getVarParams().AppId,
		"SecurityToken": state.Login.SecToken,
		"filterOn": "true",
		"format": "json",
		"nojsoncallback": "1",
	]


	def finalParams = [
		uri: getVarParams().BaseURL,
		path: apipath,
		headers: finalHeaders,
		query: finalQParams,
	]

	log.debug finalParams

	try {
		httpGet(finalParams) { response ->

			if (response.data.ErrorMessage) {
				log.debug "API Error: $response.data"
			}

			sendEvent(
				name: "lastHttpStatus",
				value: "succeeded",
				displayed: true,
				descriptionText: "HTTP request succeeded",
			)

			callback(response)
		}
	} catch (Error e) {
		// setDoorState("unknown")
		sendEvent(
			name: "lastHttpStatus",
			value: "failed",
			displayed: true,
			descriptionText: "HTTP request failed",
		)

		log.debug "API Error: $e"
	}
}

def callApiPost(state, apipath, body, callback = {}) {

	def finalHeaders = [
		"User-Agent": getVarParams().UserAgent,
		"BrandId": getVarParams().BrandId,
		"ApiVersion": getVarParams().ApiVersion,
		"Culture": getVarParams().Culture,
		"MyQApplicationId": getVarParams().AppId,
	]

	def finalParams = [
		uri: getVarParams().BaseURL,
		path: apipath,
		headers: finalHeaders,
		body: body,
	]

	log.debug "final params: $finalParams"

	try {
		httpPostJson(finalParams) { response ->

			if (response.data.ErrorMessage) {

				log.debug "API Error: $response.data"
			}

			log.debug "Login succeed: $response.data"

			sendEvent(
				name: "lastHttpStatus",
				value: "succeeded",
				displayed: true,
				descriptionText: "HTTP request succeeded",
			)

			callback(response)
		}
	} catch (Error e) {
		// setDoorState("unknown")
		sendEvent(
			name: "lastHttpStatus",
			value: "failed",
			displayed: true,
			descriptionText: "HTTP request failed",
		)

		log.debug "API Error: $e"
	}
}