Add OZW node config parameters websocket commands

.coveragerc

@@ -1032,6 +1032,7 @@ omit =
     homeassistant/components/zwave/util.py
     homeassistant/components/ozw/__init__.py
     homeassistant/components/ozw/entity.py
+    homeassistant/components/ozw/node.py
     homeassistant/components/ozw/services.py
 
 [report]

homeassistant/components/ozw/const.py

@@ -37,6 +37,14 @@
 ATTR_SCENE_VALUE_ID = "scene_value_id"
 ATTR_SCENE_VALUE_LABEL = "scene_value_label"
 
+# Config parameter specific
+ATTR_LABEL = "label"
+ATTR_MAX = "max"
+ATTR_MIN = "min"
+ATTR_OPTIONS = "options"
+ATTR_TYPE = "type"
+ATTR_VALUE = "value"
+
 # Service specific
 SERVICE_ADD_NODE = "add_node"
 SERVICE_REMOVE_NODE = "remove_node"

homeassistant/components/ozw/node.py

@@ -0,0 +1,190 @@
+"""Node methods and classes for OpenZWave."""
+from openzwavemqtt.const import CommandClass, ValueType
+
+from homeassistant.components.websocket_api.const import (
+    ERR_NOT_FOUND,
+    ERR_NOT_SUPPORTED,
+)
+
+from .const import (
+    ATTR_CONFIG_PARAMETER,
+    ATTR_LABEL,
+    ATTR_MAX,
+    ATTR_MIN,
+    ATTR_OPTIONS,
+    ATTR_TYPE,
+    ATTR_VALUE,
+)
+
+
+class OZWValidationResponse:
+    """Class to hold response for validating an action."""
+
+    def __init__(self, success, payload=None, err_type=None, err_msg=None):
+        """Initialize OZWValidationResponse."""
+        self.success = success
+        self.payload = payload
+        self.err_type = err_type
+        self.err_msg = err_msg
+
+    @staticmethod
+    def process_fail(err_type, err_msg):
+        """Process an invalid request."""
+        return OZWValidationResponse(False, err_type=err_type, err_msg=err_msg)
+
+    @staticmethod
+    def process_fail_on_type(value, new_value):
+        """Process an invalid request that fails type validation."""
+        return OZWValidationResponse.process_fail(
+            ERR_NOT_SUPPORTED,
+            (
+                f"Configuration parameter type {value.type} does "
+                f"not match the value type {type(new_value)}"
+            ),
+        )
+
+    @staticmethod
+    def process_success(payload):
+        """Process a valid request."""
+        return OZWValidationResponse(True, payload=payload)
+
+
+def set_config_parameter(manager, instance_id, node_id, parameter_index, new_value):
+    """Set config parameter to a node."""
+    instance = manager.get_instance(instance_id)
+    if not instance:
+        return OZWValidationResponse.process_fail(
+            ERR_NOT_FOUND, "OZW Instance not found"
+        )
+
+    node = instance.get_node(node_id)
+    if not node:
+        return OZWValidationResponse.process_fail(ERR_NOT_FOUND, "OZW Node not found")
+
+    value = node.get_value(CommandClass.CONFIGURATION, parameter_index)
+    if not value:
+        return OZWValidationResponse.process_fail(
+            ERR_NOT_FOUND,
+            "Configuration parameter for OZW Node Instance not found",
+        )
+
+    # Bool can be passed in as string or bool
+    if value.type == ValueType.BOOL:
+        if isinstance(new_value, bool):
+            value.send_value(new_value)
+            return OZWValidationResponse.process_success(new_value)
+        if isinstance(new_value, str):
+            if new_value.lower() in ("true", "false"):
+                payload = new_value.lower() == "true"
+                value.send_value(payload)
+                return OZWValidationResponse.process_success(payload)
+
+            return OZWValidationResponse.process_fail(
+                ERR_NOT_SUPPORTED,
+                "Configuration parameter requires true of false",
+            )
+
+        return OZWValidationResponse.process_fail_on_type(value, new_value)
+
+    # List value can be passed in as string or int
+    if value.type == ValueType.LIST:
+        try:
+            new_value = int(new_value)
+        except ValueError:
+            pass
+        if not isinstance(new_value, str) and not isinstance(new_value, int):
+            return OZWValidationResponse.process_fail_on_type(value, new_value)
+
+        for option in value.value["List"]:
+            if new_value not in (option["Label"], option["Value"]):
+                continue
+            payload = int(option["Value"])
+            value.send_value(payload)
+            return OZWValidationResponse.process_success(payload)
+
+        return OZWValidationResponse.process_fail(
+            ERR_NOT_SUPPORTED,
+            f"Invalid value {new_value} for parameter {parameter_index}",
+        )
+
+    # Int, Byte, Short are always passed as int, Decimal should be float
+    if value.type in (
+        ValueType.INT,
+        ValueType.BYTE,
+        ValueType.SHORT,
+        ValueType.DECIMAL,
+    ):
+        try:
+            if value.type == ValueType.DECIMAL:
+                new_value = float(new_value)
+            else:
+                new_value = int(new_value)
+        except ValueError:
+            return OZWValidationResponse.process_fail_on_type(value, new_value)
+        if (value.max and new_value > value.max) or (
+            value.min and new_value < value.min
+        ):
+            return OZWValidationResponse.process_fail(
+                ERR_NOT_SUPPORTED,
+                (
+                    f"Value {new_value} out of range for parameter "
+                    f"{parameter_index} (Min: {value.min} Max: {value.max})"
+                ),
+            )
+        value.send_value(new_value)
+        return OZWValidationResponse.process_success(new_value)
+
+    # This will catch BUTTON, STRING, and UNKNOWN ValueTypes
+    return OZWValidationResponse.process_fail(
+        ERR_NOT_SUPPORTED,
+        f"Value type of {value.type} for parameter {parameter_index} not supported",
+    )
+
+
+def get_config_parameters(node):
+    """Get config parameter from a node."""
+    command_class = node.get_command_class(CommandClass.CONFIGURATION)
+    if not command_class:
+        return OZWValidationResponse.process_fail(
+            ERR_NOT_FOUND, "Configuration parameters for OZW Node Instance not found"
+        )
+
+    values = []
+
+    for value in command_class.values():
+        value_to_return = {}
+        # BUTTON types aren't supported yet, and STRING and UNKNOWN
+        # are not valid config parameter types
+        if value.read_only or value.type in (
+            ValueType.BUTTON,
+            ValueType.STRING,
+            ValueType.UNKNOWN,
+        ):
+            continue
+
+        value_to_return = {
+            ATTR_LABEL: value.label,
+            ATTR_TYPE: value.type.value,
+            ATTR_CONFIG_PARAMETER: value.index.value,
+        }
+
+        if value.type == ValueType.BOOL:
+            value_to_return[ATTR_VALUE] = value.value
+
+        elif value.type == ValueType.LIST:
+            value_to_return[ATTR_VALUE] = value.value["Selected"]
+            value_to_return[ATTR_OPTIONS] = value.value["List"]
+
+        elif value.type in (
+            ValueType.INT,
+            ValueType.BYTE,
+            ValueType.SHORT,
+            ValueType.DECIMAL,
+        ):
+            value_to_return[ATTR_VALUE] = int(value.value)
+            value_to_return[ATTR_MAX] = value.max
+            value_to_return[ATTR_MIN] = value.min
+
+        values.append(value_to_return)
+
+    return OZWValidationResponse.process_success(values)

homeassistant/components/ozw/services.py

@@ -1,13 +1,13 @@
 """Methods and classes related to executing Z-Wave commands and publishing these to hass."""
 import logging
 
-from openzwavemqtt.const import CommandClass, ValueType
 import voluptuous as vol
 
 from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 from . import const
+from .node import set_config_parameter
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -53,7 +53,7 @@ def async_register(self):
                     vol.Required(const.ATTR_NODE_ID): vol.Coerce(int),
                     vol.Required(const.ATTR_CONFIG_PARAMETER): vol.Coerce(int),
                     vol.Required(const.ATTR_CONFIG_VALUE): vol.Any(
-                        vol.Coerce(int), cv.string
+                        bool, vol.Coerce(float), cv.string
                     ),
                 }
             ),
@@ -66,62 +66,19 @@ def async_set_config_parameter(self, service):
         node_id = service.data[const.ATTR_NODE_ID]
         param = service.data[const.ATTR_CONFIG_PARAMETER]
         selection = service.data[const.ATTR_CONFIG_VALUE]
-        payload = None
 
-        value = (
-            self._manager.get_instance(instance_id)
-            .get_node(node_id)
-            .get_value(CommandClass.CONFIGURATION, param)
+        resp = set_config_parameter(
+            self._manager, instance_id, node_id, param, selection
         )
 
-        if value.type == ValueType.BOOL:
-            payload = selection == "True"
+        if not resp.success:
+            raise ValueError(resp.err_msg)
 
-        if value.type == ValueType.LIST:
-            # accept either string from the list value OR the int value
-            for selected in value.value["List"]:
-                if selection not in (selected["Label"], selected["Value"]):
-                    continue
-                payload = int(selected["Value"])
-
-            if payload is None:
-                _LOGGER.error(
-                    "Invalid value %s for parameter %s",
-                    selection,
-                    param,
-                )
-                return
-
-        if value.type == ValueType.BUTTON:
-            # Unsupported at this time
-            _LOGGER.info("Button type not supported yet")
-            return
-
-        if value.type == ValueType.STRING:
-            payload = selection
-
-        if (
-            value.type == ValueType.INT
-            or value.type == ValueType.BYTE
-            or value.type == ValueType.SHORT
-        ):
-            if selection > value.max or selection < value.min:
-                _LOGGER.error(
-                    "Value %s out of range for parameter %s (Min: %s Max: %s)",
-                    selection,
-                    param,
-                    value.min,
-                    value.max,
-                )
-                return
-            payload = int(selection)
-
-        value.send_value(payload)  # send the payload
         _LOGGER.info(
             "Setting configuration parameter %s on Node %s with value %s",
             param,
             node_id,
-            payload,
+            resp.payload,
         )
 
     @callback