Rule Machine 1.9.0a

/**
 *  Rule Machine
 *
 *  Copyright 2015, 2016 Bruce Ravenel
 *
 *  Version 1.9.0a   25 Mar 2016
 *
 *  Version History
 *
 *  1.9.0   24 Mar 2016     Updates for Rule, small bug fixes
 *  1.8.2   9 Mar 2016      Changed startup page for installation
 *  1.8.1   3 Mar 2016      Changed method of getting Rule version
 *  1.8.0   2 Mar 2016      Clean up, added Door control
 *  1.7.6   24 Feb 2016     Added User Guide link, fixed Rule truth mechanism
 *  1.7.5   21 Feb 2016     Improved custom command selection
 *  1.7.4   20 Feb 2016     Added saved command display, UI improvements
 *  1.7.3   14 Feb 2016     Improved Rule Machine initialization, fixed Delete custom commands bug
 *  1.7.2   8 Feb 2016      Added set Boolean for Rules
 *  1.7.1   5 Feb 2016      Added update Rule
 *  1.7.0   31 Jan 2016     Added run Rule actions
 *  1.6.6   10 Jan 2016     Improved method of getting custom device commands
 *  1.6.5   1 Jan 2016      Added version numbers to main page
 *  1.6.4   30 Dec 2015     Multi-commands
 *  1.6.3   26 Dec 2015     UI improvements and icon per Michael Struck
 *  1.6.2   25 Dec 2015     null parameter value patch in expert, maxwell
 *  1.6.1   24 Dec 2015     UI improvement
 *  1.6.0   23 Dec 2015     Added expert commands per Mike Maxwell
 *
 *  This software if free for Private Use. You may use and modify the software without distributing it.
 *
 *  This software and derivatives may not be used for commercial purposes.
 *  You may not modify, distribute or sublicense this software.
 *  You may not grant a sublicense to modify and distribute this software to third parties not included in the license.
 *
 *  Software is provided without warranty and the software author/license owner cannot be held liable for damages.
 *
 */

definition(
    name: "Rule Machine",
    singleInstance: true,
    namespace: "bravenel",
    author: "Bruce Ravenel and Mike Maxwell",
    description: "Rule Machine",
    category: "My Apps",
    iconUrl: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine.png",
    iconX2Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png",
    iconX3Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png"
)

preferences {
    page(name: "mainPage")
    page(name: "firstPage")
    page(name: "removePage")
    //expert pages
    page(name: "customCommandsPAGE")
    page(name: "generalApprovalPAGE")
    page(name: "addCustomCommandPAGE")
    page(name: "customParamsPAGE")
}

def mainPage() {
    if(!state.setup) firstRun()
    else {
        if(state.ruleState) state.ruleState = null  // obsolete
        def nApps = childApps.size()
        dynamicPage(name: "mainPage", title: "Installed Rules, Triggers and Actions " + (nApps > 0 ? "[$nApps]" : ""), install: true, uninstall: false) {
            section {
                app(name: "childRules", appName: "Rule", namespace: "bravenel", title: "Create New Rule...", multiple: true)
            }
            section ("Expert Features") {
                href("customCommandsPAGE", title: null, description: anyCustom() ? "Custom Commands..." : "Tap to create Custom Commands", state: anyCustom())
            }
            section ("Rule Machine User Guide") {
                href url:"https://community.smartthings.com/t/rule-machine-user-guide/40176", style:"embedded", required:false, description:"Tap to view User Guide", title: ""
            }
            section ("Remove Rule Machine"){
                href "removePage", description: "Tap to remove Rule Machine and Rules", title: ""
            }
            section ("Version 1.9.0a/" + (nApps > 0 ? "${childApps[0].appVersion()}" : "---")) { }
        }
    }
}

def removePage() {
    dynamicPage(name: "removePage", title: "Remove Rule Machine And All Rules", install: false, uninstall: true) {
        section ("WARNING!\n\nRemoving Rule Machine also removes all Rules\n") {
        }
    }
}

def installed() {
}

def updated() {
}

def firstRun() {
    state.setup = true
    state.ruleSubscribers = [:]
    dynamicPage(name: "firstPage", title: "Hit Done to install Rule Machine", install: true, uninstall: false) { }
}

def childVersion() {
    def result = "---"
    if(childApps.size() > 0) result = childApps[0].appVersion()
    return result
}

def ruleList(appLabel) {
    def result = []
    childApps.each { child ->
        if(child.name == "Rule" && child.label != appLabel) result << child.label
    }
    return result
}

def subscribeRule(appLabel, ruleName, ruleTruth, childMethod) {
//  log.debug "subscribe: $appLabel, $ruleName, $ruleTruth, $childMethod"
    ruleName.each {name ->
        state.ruleSubscribers[name].each {if(it == appLabel) return}
        if(state.ruleSubscribers[name] == null) state.ruleSubscribers[name] = ["$appLabel":ruleTruth]
        else state.ruleSubscribers[name] << ["$appLabel":ruleTruth]
    }
}

def setRuleTruth(appLabel, ruleTruth) {
//  log.debug "setRuleTruth: $appLabel, $ruleTruth, ${state.ruleState[appLabel]}"
    def thisList = state.ruleSubscribers[appLabel]
    thisList.each {
        if(it.value == null || "$it.value" == "$ruleTruth") {
            childApps.each { child ->
                if(child.label == it.key) child.ruleHandler(appLabel, ruleTruth)
            }
        }
    }
}

def setRuleBoolean(rule, ruleBoolean, appLabel) {
//  log.debug "setRuleBoolean: $appLabel, $ruleBoolean"
    childApps.each { child ->
        rule.each {
            if(child.label == it) child.setBoolean(ruleBoolean, appLabel)
        }
    }
}

def currentRule(appLabel) {
    def result
    childApps.each { child ->
        if(child.label == appLabel) result = child.revealSuccess()
    }
    return result
}

def childUninstalled() {
//  log.debug "childUninstalled called"
}

def removeChild(appLabel) {
//  log.debug "removeChild: $appLabel"
    unSubscribeRule(appLabel)
    if(state.ruleSubscribers[appLabel] != null) state.ruleSubscribers.remove(appLabel)
}

def unSubscribeRule(appLabel) {
//  log.debug "unSubscribeRule: $appLabel"
    state.ruleSubscribers.each { rule ->
        def newList = [:]
        rule.value.each {list ->
            if(list.key != appLabel) newList << list
        }
        rule.value = newList
    }
}

def runRule(rule, appLabel) {
//  log.debug "runRule: $rule, $appLabel"
    childApps.each { child ->
        rule.each {
            if(child.label == it) child.ruleEvaluator(appLabel)
        }
    }
}

def runRuleAct(rule, appLabel) {
//  log.debug "runRuleAct: $rule, $appLabel"
    childApps.each { child ->
        rule.each {
            if(child.label == it) child.ruleActions(appLabel)
        }
    }
}

def runUpdate(rule) {
//  log.debug "runUpdate: $rule"
    childApps.each { child ->
        rule.each {
            if(child.label == it) child.updated()
        }
    }
}

/*****custom command specific pages *****/
def generalApprovalPAGE(params){
    def title = params.title
    def method = params.method
    def result
    dynamicPage(name: "generalApprovalPAGE", title: title ){
        section() {
            if (method) {
                result = app."${method}"()
                paragraph "${result}"
            }
        }
    }
}

def customCommandsPAGE() {
    if (!state.lastCmdIDX) state.lastCmdIDX = 0
    def savedCommands = getMyCommands()
    dynamicPage(name: "customCommandsPAGE", title: "Custom Commands", uninstall: false, install: false) {
        def hasCommands = savedCommands.size() != 0
        def result = ""
        if (hasCommands){
            def cmdMaps = state.customCommands ?: []
            cmdMaps.each{ cmd ->
                def cont = cmd.value.text.size() > 30 ? "..." : ""
                result = result + "\n\t" + cmd.value.text.take(30) + cont
            }
        } else state.lastCmdIDX = 0
        section(hasCommands ? "Saved commands:\n" + result : "") {
            if (hasCommands) {
                input(
                    name            : "deleteCmds"
                    ,title          : "Delete saved commands"
                    ,multiple       : true
                    ,required       : false
                    ,description    : ""
                    ,type           : "enum"
                    ,options        : savedCommands
                    ,submitOnChange : true
                )
                if (isValidCommand(deleteCmds)){
                    href( "generalApprovalPAGE"
                        ,title          : "Delete commands now"
                        ,description    : ""
                        ,state          : null
                        ,params         : [method:"deleteCommands",title:"Delete commands"]
                        ,submitOnChange : true
                    )
                }
                paragraph("")
            }
            getCapab()
            if(myCapab) getDevs()
            if(devices && hasCommands) {
                input(
                    name            : "testCmd"
                    ,title          : "Test saved command on\n$devices"
                    ,multiple       : false
                    ,required       : false
                    ,description    : ""
                    ,type           : "enum"
                    ,options        : savedCommands
                    ,submitOnChange : true
                )
                def res = execCommand(settings.testCmd)
                if (res) paragraph("${result}")
            }
        }
        section(){
            if (devices){
                href( "addCustomCommandPAGE"
                    ,title      : "New custom command..."
                    ,description: ""
                    ,state      : null
                )
            }
        }
    }
}

def getCapab() {
    def myOptions = ["Acceleration", "Actuator", "Button", "Carbon monoxide detector", "Contact", "Dimmer", "Door", "Energy meter", "Garage door", "Humidity", "Illuminance",
        "Lock", "Motion", "Power meter", "Presence", "Smoke detector", "Switch", "Temperature", "Thermostat", "Water sensor", "Music player"]
    def result = input "myCapab", "enum", title: "Select capability for test device", required: false, options: myOptions.sort(), submitOnChange: true
}

def getDevs() {
    def multi = false
    def thisName = ""
    def thisCapab = ""
    switch(myCapab) {
        case "Switch":
            thisName = "switch"
            thisCapab = "switch"
            break
        case "Actuator":
            thisName = "actuator"
            thisCapab = "actuator"
            break
        case "Motion":
            thisName = "motion sensor"
            thisCapab = "motionSensor"
            break
        case "Button":
            thisName = "button device"
            thisCapab = "button"
            break
        case "Acceleration":
            thisName = "acceleration sensor"
            thisCapab = "accelerationSensor"
            break
        case "Contact":
            thisName = "contact sensor"
            thisCapab = "contactSensor"
            break
        case "Presence":
            thisName = "presence sensor"
            thisCapab = "presenceSensor"
            break
        case "Garage door":
            thisName = "garage door"
            thisCapab = "garageDoorControl"
            break
        case "Door":
            thisName = "door"
            thisCapab = "doorControl"
            break
        case "Lock":
            thisName = "lock"
            thisCapab = "lock"
            break
        case "Dimmer":
            thisName = "dimmer" + (multi ? "s" : "")
            thisCapab = "switchLevel"
            break
        case "Temperature":
            thisName = "temperature sensor" + (multi ? "s" : "")
            thisCapab = "temperatureMeasurement"
            break
        case "Thermostat":
            thisName = "thermostat" + (multi ? "s" : "")
            thisCapab = "thermostat"
            break
        case "Humidity":
            thisName = "humidity sensor" + (multi ? "s" : "")
            thisCapab = "relativeHumidityMeasurement"
            break
        case "Illuminance":
            thisName = "illuminance sensor" + (multi ? "s" : "")
            thisCapab = "illuminanceMeasurement"
            break
        case "Energy meter":
            thisName = "energy meter" + (multi ? "s" : "")
            thisCapab = "energyMeter"
            break
        case "Power meter":
            thisName = "power meter" + (multi ? "s" : "")
            thisCapab = "powerMeter"
            break
        case "Carbon monoxide detector":
            thisName = "CO detector" + (multi ? "s" : "")
            thisCapab = "carbonMonoxideDetector"
            break
        case "Smoke detector":
            thisName = "smoke detector" + (multi ? "s" : "")
            thisCapab = "smokeDetector"
            break
        case "Water sensor":
            thisName = "water sensor"
            thisCapab = "waterSensor"
            break
        case "Music player":
            thisName = "music player"
            thisCapab = "musicPlayer"
            break
    }
    def result = input "devices", "capability.$thisCapab", title: "Select $thisName to test for commands", required: false, multiple: multi, submitOnChange: true
}

def addCustomCommandPAGE(){
    def cmdLabel = getCmdLabel()
    def complete = ""
    def test = false
    def rest = getDeviceCommands()
    rest = "$rest"[1..-2]
    def pageTitle = "Create new custom command from\n\n${devices}\n\nAvailable commands:\n\n" + rest
    if (cmdLabel){
        complete = "complete"
        test = true
    }
    dynamicPage(name: "addCustomCommandPAGE", title: pageTitle, uninstall: false, install: false) {
        section(){
            input(
                name            : "cCmd"
                ,title          : "Select custom command"
                ,multiple       : false
                ,required       : false
                ,type           : "enum"
                ,options        : getDeviceCommands()
                ,submitOnChange : true
            )
            href( "customParamsPAGE"
                ,title: "Parameters"
                ,description: parameterLabel()
                ,state: null
            )
        }
        if (cCmd){
            def result = execTestCommand()
            section("Configured command: ${cmdLabel}\n${result}"){
                if (result == "succeeded"){
                    if (!commandExists(cmdLabel)){
                        href( "generalApprovalPAGE"
                            ,title      : "Save command now"
                            ,description: ""
                            ,state      : null
                            ,params     : [method:"addCommand",title:"Add Command"]
                        )
                    }
                }
            }
        }
    }
}

def customParamsPAGE(p){
    def ct = settings.findAll{it.key.startsWith("cpType_")}
    state.howManyP = ct.size() + 1
    def howMany = state.howManyP
    dynamicPage(name: "customParamsPAGE", title: "Select parameters", uninstall: false) {
        if(howMany) {
            for (int i = 1; i <= howMany; i++) {
                def thisParam = "cpType_" + i
                def myParam = ct.find {it.key == thisParam}
                section("Parameter #${i}") {
                    getParamType(thisParam, i != howMany)
                    if(myParam) {
                        def pType = myParam.value
                        getPvalue(pType, i)
                    }
                }
            }
        }
    }
}

/***** child specific methods *****/

def getCommandMap(cmdID){
    return state.customCommands["${cmdID}"]
}


/***** local custom command specific methods *****/
def anyCustom(){
    def result = null
    if (getCommands()) result = "complete"
    return result
}

def getParamType(myParam,isLast){
    def myOptions = ["string", "number", "decimal"]
    def result = input (
                    name            : myParam
                    ,type           : "enum"
                    ,title          : "parameter type"
                    ,required       : isLast
                    ,options        : myOptions
                    ,submitOnChange : true
                )
    return result
}

def getPvalue(myPtype, n){
    def myVal = "cpVal_" + n
    def result = null
    if (myPtype == "string"){
        result = input(
                    name        : myVal
                    ,title      : "string value"
                    ,type       : "text"
                    ,required   : false
                )
    } else if (myPtype == "number"){
        result = input(
                    name        : myVal
                    ,title      : "integer value"
                    ,type       : "number"
                    ,required   : false
                )
    } else if (myPtype == "decimal"){
        result = input(
                    name        : myVal
                    ,title      : "decimal value"
                    ,type       : "decimal"
                    ,required   : false
                )
    }
    return result
}

def getCmdLabel(){
    def cmd
    if (settings.cCmd) cmd = settings.cCmd.value
    def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
    def result = null
    if (cmd) {
        result = "${cmd}("
        if (cpTypes.size() == 0){
            result = result + ")"
        } else {
            def r = getParams(cpTypes)
            if (r == "") result = r
            else result = "${result}${r})"
        }
    }
    return result
}

def getParams(cpTypes){
    def result = ""
    def cpValue
    def badParam = false
    cpTypes.each{ cpType ->
        def i = cpType.key.replaceAll("cpType_","")
        def cpVal = settings.find{it.key == "cpVal_${i}"}
        if (cpVal){
            cpValue = cpVal.value
            if (cpType.value == "string"){
                result = result + "'${cpValue}',"
            } else {
                if (cpValue.isNumber()){
                    result = result + "${cpValue},"
                } else {
                    result = result + "[${cpValue}]: is not a number,"
                }
            }
        } else {
            badParam = true
        }
    }
    if (badParam) result = ""
    else result = result[0..-2]
    return result
}

def parameterLabel(){
    def howMany = (state.howManyP ?: 1) - 1
    def result = ""
    if (howMany) {
        for (int i = 1; i <= howMany; i++) {
            result = result + parameterLabelN(i) + "\n"
        }
        result = result[0..-2]
    }
    return result
}

def parameterLabelN(i){
    def result = ""
    def cpType = settings.find{it.key == "cpType_${i}"}
    def cpVal = settings.find{it.key == "cpVal_${i}"}
    def cpValue
    if (cpVal) cpValue = cpVal.value
    else cpValue = "missing value"
    if (cpType){
        result = "p${i} - type:${cpType.value}, value:${cpValue}"
    }
    return result
}

def getParamsAsList(cpTypes){
    def result = []
    cpTypes.each{ cpType ->
        def i = cpType.key.replaceAll("cpType_","")
        def cpVal = settings.find{it.key == "cpVal_${i}"}
        if (cpVal){
            if (cpType.value == "string"){
                result << "${cpVal.value}"
            } else if (cpType.value == "decimal"){
                result << cpVal.value.toBigDecimal()
            } else { // if (cpType.value == "number" && cpVal.value.isInteger()){
                result << cpVal.value.toInteger()
            }
        } else {
            result << "missing value"
        }
    }
    return result
}

def getCommands(){
    def result = []
    def cmdMaps = state.customCommands ?: []
    cmdMaps.each{ cmd ->
        def option = [(cmd.key):([cmd.value.text, cmd.value.capab == null ? "actuator" : cmd.value.capab])]
        result.push(option)
    }
    return result
}

def getMyCommands(){
    def result = []
    def cmdMaps = state.customCommands ?: []
    cmdMaps.each{ cmd ->
        def option = [(cmd.key):(cmd.value.text)]
        result.push(option)
    }
    return result
}

def isValidCommand(cmdIDS){
    def result = false
    cmdIDS.each{ cmdID ->
        def cmd = state.customCommands["${cmdID}"]
        if (cmd) result = true
    }
    return result
}

def deleteCommands(){
    def result
    def cmdMaps = state.customCommands
    if (deleteCmds.size() == 1) result = "Command removed"
    else result = "Commands removed"
    deleteCmds.each{ it ->
        cmdMaps.remove(it)
    }
    return result
}
def commandExists(cmd){
    def result = false
    if (state.customCommands){
        result = state.customCommands.find{ it.value.text == "${cmd}" }
    }
    return result
}
def addCommand(){
    def capabs = [  "Acceleration" :                "accelerationSensor",
                    "Button" :                      "button",
                    "Carbon monoxide detector" :    "carbonMonoxideDetector",
                    "Contact" :                     "contactSensor",
                    "Dimmer" :                      "switchLevel",
                    "Door" :                        "doorControl",
                    "Energy meter" :                "energyMeter",
                    "Garage door" :                 "garageDoorControl",
                    "Humidity" :                    "humiditySensor",
                    "Illuminance" :                 "illuminanceSensor",
                    "Lock" :                        "lock",
                    "Motion" :                      "motionSensor",
                    "Power meter" :                 "powerMeter",
                    "Presence" :                    "presenceSensor",
                    "Smoke detector" :              "smokeDetector",
                    "Switch" :                      "switch",
                    "Temperature" :                 "temperatureMeasurement",
                    "Thermostat" :                  "thermostat",
                    "Water sensor" :                "waterSensor",
                    "Music player" :                "musicPlayer",
                    "Actuator" :                    "actuator"]
    def result
    def newCmd = getCmdLabel()
    def found = commandExists(newCmd)
    def cmdMaps = state.customCommands
    //only update if not found...
    if (!found) {
        state.lastCmdIDX = state.lastCmdIDX + 1
        def nextIDX = state.lastCmdIDX
        def cmd = [text:"${newCmd}",cmd:"${cCmd}"]
        def params = [:]
        def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
        cpTypes.each{ cpType ->
            def i = cpType.key.replaceAll("cpType_","")
            def cpVal = settings.find{it.key == "cpVal_${i}"}
            def param = ["type":"${cpType.value}","value":"${cpVal.value}"]
            params.put(i, param)
        }
        cmd.put("params",params)
        if(myCapab) cmd.put("capab", capabs[myCapab]) else cmd.put("capab", "actuator")
        if (cmdMaps) cmdMaps.put((nextIDX),cmd)
        else state.customCommands = [(nextIDX):cmd]
        result = "command: ${newCmd} was added"
    } else {
        result = "command: ${newCmd} was not added, it already exists."
    }
    return result
}

def execTestCommand(){
    def result
    def cTypes = settings.findAll{it.key.startsWith("cpType_")}
    def p = getParamsAsList(cTypes.sort()) as Object[]
    devices.each { device ->
        try {
            device."${cCmd}"(p)
            result = "succeeded"
        }
        catch (IllegalArgumentException e){
            def em = e as String
            def ems = em.split(":")
            ems = ems[2].replace(" [","").replace("]","")
            ems = ems.replaceAll(", ","\n")
//          result = "failed, valid commands:\n${ems}"
            result = "failed"
        }
        catch (e){
            result = "failed with:\n${e}"
        }
    }
    return result
}

def execCommand(cmdID){
    def result = ""
    def pList = []
    if (cmdID){
        def cmdMap = state.customCommands["${cmdID}"]
        if (testCmd && cmdMap) {
            def params = cmdMap.params.sort()
            params.each{ p ->
                if (p.value.type == "string"){
                    pList << "${p.value.value}"
                } else if (p.value.type == "decimal"){
                    pList << p.value.value.toBigDecimal()
                } else {
                    pList << p.value.value.toInteger()
                }
            }
            def p = pList as Object[]
            devices.each { device ->
                try {
                    device."${cmdMap.cmd}"(p)
                    result = "Command succeeded"
                }
                catch (IllegalArgumentException e){
                    def em = e as String
                    def ems = em.split(":")
                    ems = ems[2].replace(" [","").replace("]","")
                    ems = ems.replaceAll(", ","\n")
                    result = "Command failed, valid commands:\n${ems}"
                }
                catch (e){
                    result = "failed with:\n${e}"
                }
            }
            return result
        }
    }
}

def getDeviceCommands(){
    def result = ""
    devices.each { device ->
        result = device.supportedCommands.collect{ it as String }
        //log.debug "supportedCommands:${result}"
    }
    return result
}

def isExpert(){
    return getCommands().size() > 0
}