refactor: Create a separate endpoint for device triggers

refactor!: Normalize device action endpoint

BREAKING CHANGE: Endpoint for device action changed location from nodered/device_action to nodered/device/action
It now matches the new device trigger format

Author: zachowj

README.md

@@ -22,7 +22,7 @@ _Companion Component to [node-red-contrib-home-assistant-websocket](https://gith
 
 ## Minimum Requirements
 
-- [node-red-contrib-home-assistant-websocket](https://github.com/zachowj/node-red-contrib-home-assistant-websocket) v0.20+
+- [node-red-contrib-home-assistant-websocket](https://github.com/zachowj/node-red-contrib-home-assistant-websocket) v0.57+
 - [Home Assistant](https://github.com/home-assistant/core) 2023.7.0+
 
 ## Installation

custom_components/nodered/const.py

@@ -20,12 +20,12 @@
 CONF_ENABLED = "enabled"
 CONF_ENTITY_PICTURE = "entity_picture"
 CONF_LAST_RESET = "last_reset"
+CONF_MESSAGE = "message"
 CONF_NAME = "name"
 CONF_NODE_ID = "node_id"
 CONF_NUMBER = "number"
 CONF_OPTIONS = "options"
 CONF_OUTPUT_PATH = "output_path"
-CONF_PAYLOAD = "payload"
 CONF_REMOVE = "remove"
 CONF_SELECT = "select"
 CONF_SENSOR = "sensor"

custom_components/nodered/switch.py

@@ -1,5 +1,4 @@
-"""Sensor platform for nodered."""
-import json
+"""Switch platform for nodered."""
 import logging
 
 from homeassistant.components.websocket_api import event_message
@@ -9,11 +8,9 @@
     CONF_ID,
     CONF_STATE,
     CONF_TYPE,
-    EVENT_HOMEASSISTANT_START,
     EVENT_STATE_CHANGED,
 )
-from homeassistant.core import CoreState, callback
-from homeassistant.helpers import entity_platform, trigger
+from homeassistant.helpers import entity_platform
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import ToggleEntity
@@ -23,30 +20,23 @@
 from .const import (
     CONF_CONFIG,
     CONF_DATA,
-    CONF_DEVICE_TRIGGER,
+    CONF_MESSAGE,
     CONF_OUTPUT_PATH,
-    CONF_PAYLOAD,
-    CONF_REMOVE,
-    CONF_SKIP_CONDITION,
-    CONF_SUB_TYPE,
     CONF_SWITCH,
     CONF_TRIGGER_ENTITY_ID,
-    DOMAIN,
     NODERED_DISCOVERY_NEW,
     SERVICE_TRIGGER,
     SWITCH_ICON,
 )
-from .utils import NodeRedJSONEncoder
 
 _LOGGER = logging.getLogger(__name__)
 
 SERVICE_TRIGGER_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_ENTITY_ID): cv.entity_ids,
         vol.Optional(CONF_TRIGGER_ENTITY_ID): cv.entity_id,
-        vol.Optional(CONF_SKIP_CONDITION): cv.boolean,
         vol.Optional(CONF_OUTPUT_PATH): cv.boolean,
-        vol.Optional(CONF_PAYLOAD): vol.Extra,
+        vol.Optional(CONF_MESSAGE): vol.Extra,
     }
 )
 EVENT_TRIGGER_NODE = "automation_triggered"
@@ -78,11 +68,7 @@ async def async_discover(config, connection):
 async def _async_setup_entity(hass, config, async_add_entities, connection):
     """Set up the Node-RED Switch."""
 
-    switch_type = config.get(CONF_SUB_TYPE, TYPE_SWITCH)
-    switch_class = (
-        NodeRedDeviceTrigger if switch_type == TYPE_DEVICE_TRIGGER else NodeRedSwitch
-    )
-    async_add_entities([switch_class(hass, config, connection)])
+    async_add_entities([NodeRedSwitch(hass, config, connection)])
 
 
 class NodeRedSwitch(NodeRedEntity, ToggleEntity):
@@ -116,11 +102,9 @@ async def async_turn_on(self, **kwargs) -> None:
     async def async_trigger_node(self, **kwargs) -> None:
         """Trigger node in Node-RED."""
         data = {}
-        data[CONF_ENTITY_ID] = kwargs.get(CONF_TRIGGER_ENTITY_ID)
-        data[CONF_SKIP_CONDITION] = kwargs.get(CONF_SKIP_CONDITION, False)
         data[CONF_OUTPUT_PATH] = kwargs.get(CONF_OUTPUT_PATH, True)
-        if kwargs.get(CONF_PAYLOAD) is not None:
-            data[CONF_PAYLOAD] = kwargs[CONF_PAYLOAD]
+        if kwargs.get(CONF_MESSAGE) is not None:
+            data[CONF_MESSAGE] = kwargs[CONF_MESSAGE]
 
         self._connection.send_message(
             event_message(
@@ -145,87 +129,3 @@ def update_discovery_config(self, msg):
         """Update the entity config."""
         super().update_discovery_config(msg)
         self._attr_icon = msg[CONF_CONFIG].get(CONF_ICON, SWITCH_ICON)
-
-
-class NodeRedDeviceTrigger(NodeRedSwitch):
-    """Node-RED Device Trigger class."""
-
-    def __init__(self, hass, config, connection):
-        """Initialize the switch."""
-        super().__init__(hass, config, connection)
-        self._trigger_config = config[CONF_DEVICE_TRIGGER]
-        self._unsubscribe_device_trigger = None
-
-    @callback
-    def handle_lost_connection(self):
-        """Set remove device trigger when disconnected."""
-        super().handle_lost_connection()
-        self.remove_device_trigger()
-
-    async def add_device_trigger(self):
-        """Add device trigger."""
-
-        if self.hass.state == CoreState.running:
-            await self._attach_triggers()
-        else:
-            self._unsub_start = self.hass.bus.async_listen_once(
-                EVENT_HOMEASSISTANT_START, self._attach_triggers
-            )
-
-    async def _attach_triggers(self, start_event=None) -> None:
-        try:
-            trigger_config = await trigger.async_validate_trigger_config(
-                self.hass, [self._trigger_config]
-            )
-            self._unsubscribe_device_trigger = await trigger.async_initialize_triggers(
-                self.hass,
-                trigger_config,
-                self.forward_trigger,
-                DOMAIN,
-                DOMAIN,
-                _LOGGER.log,
-            )
-        except vol.MultipleInvalid as ex:
-            _LOGGER.error(
-                f"Error initializing device trigger '{self._node_id}': {str(ex)}",
-            )
-
-    @callback
-    def forward_trigger(self, event, context=None):
-        """Forward events to websocket."""
-        message = event_message(
-            self._message_id,
-            {"type": EVENT_DEVICE_TRIGGER, "data": event["trigger"]},
-        )
-        self._connection.send_message(
-            json.dumps(message, cls=NodeRedJSONEncoder, allow_nan=False)
-        )
-
-    def remove_device_trigger(self):
-        """Remove device trigger."""
-        self._trigger_config = None
-        if self._unsubscribe_device_trigger is not None:
-            _LOGGER.info(f"removed device triger - {self._server_id} {self._node_id}")
-            self._unsubscribe_device_trigger()
-            self._unsubscribe_device_trigger = None
-
-    @callback
-    async def handle_discovery_update(self, msg, connection):
-        """Update entity config."""
-        if CONF_REMOVE not in msg and self._trigger_config != msg[CONF_DEVICE_TRIGGER]:
-            self.remove_device_trigger()
-            self._trigger_config = msg[CONF_DEVICE_TRIGGER]
-            await self.add_device_trigger()
-
-        super().handle_discovery_update(msg, connection)
-
-    async def async_added_to_hass(self):
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-
-        await self.add_device_trigger()
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        self.remove_device_trigger()
-        await super().async_will_remove_from_hass()

custom_components/nodered/websocket.py

@@ -36,7 +36,11 @@
     CONF_WEBHOOK_ID,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    trigger,
+)
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.entity_registry import async_entries_for_device, async_get
 from homeassistant.helpers.typing import HomeAssistantType
@@ -58,6 +62,7 @@
     NODERED_ENTITY,
     VERSION,
 )
+from .utils import NodeRedJSONEncoder
 
 CONF_ALLOWED_METHODS = "allowed_methods"
 CONF_LOCAL_ONLY = "local_only"
@@ -70,6 +75,7 @@ def register_websocket_handlers(hass: HomeAssistantType):
 
     async_register_command(hass, websocket_device_action)
     async_register_command(hass, websocket_device_remove)
+    async_register_command(hass, websocket_device_trigger)
     async_register_command(hass, websocket_discovery)
     async_register_command(hass, websocket_entity)
     async_register_command(hass, websocket_config_update)
@@ -81,7 +87,7 @@ def register_websocket_handlers(hass: HomeAssistantType):
 @require_admin
 @websocket_command(
     {
-        vol.Required(CONF_TYPE): "nodered/device_action",
+        vol.Required(CONF_TYPE): "nodered/device/action",
         vol.Required("action"): cv.DEVICE_ACTION_SCHEMA,
     }
 )
@@ -97,13 +103,15 @@ async def websocket_device_action(
 
     try:
         await platform.async_call_action_from_config(hass, msg["action"], {}, context)
-        connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+        connection.send_message(result_message(msg[CONF_ID]))
     except InvalidDeviceAutomationConfig as err:
         connection.send_message(error_message(msg[CONF_ID], "invalid_config", str(err)))
     except DeviceNotFound as err:
         connection.send_message(
             error_message(msg[CONF_ID], "device_not_found", str(err))
         )
+    except Exception as err:
+        connection.send_message(error_message(msg[CONF_ID], "unknown_error", str(err)))
 
 
 @require_admin
@@ -131,7 +139,7 @@ async def websocket_device_remove(
 
         device_registry.async_remove_device(device.id)
 
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
 
 
 @require_admin
@@ -157,7 +165,7 @@ def websocket_discovery(
     async_dispatcher_send(
         hass, NODERED_DISCOVERY.format(msg[CONF_COMPONENT]), msg, connection
     )
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
 
 
 @require_admin
@@ -178,7 +186,7 @@ def websocket_entity(
     async_dispatcher_send(
         hass, NODERED_ENTITY.format(msg[CONF_SERVER_ID], msg[CONF_NODE_ID]), msg
     )
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
 
 
 @require_admin
@@ -198,7 +206,7 @@ def websocket_config_update(
     async_dispatcher_send(
         hass, NODERED_CONFIG_UPDATE.format(msg[CONF_SERVER_ID], msg[CONF_NODE_ID]), msg
     )
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
 
 
 @require_admin
@@ -260,7 +268,7 @@ def remove_webhook() -> None:
             pass
 
         _LOGGER.info(f"Webhook removed: {webhook_id[:15]}..")
-        connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+        connection.send_message(result_message(msg[CONF_ID]))
 
     try:
         hass.components.webhook.async_register(
@@ -270,13 +278,16 @@ def remove_webhook() -> None:
             handle_webhook,
             allowed_methods=allowed_methods,
         )
-    except ValueError:
-        connection.send_message(result_message(msg[CONF_ID], {"success": False}))
+    except ValueError as err:
+        connection.send_message(error_message(msg[CONF_ID], "value_error", str(err)))
+        return
+    except Exception as err:
+        connection.send_message(error_message(msg[CONF_ID], "unknown_error", str(err)))
         return
 
     _LOGGER.info(f"Webhook created: {webhook_id[:15]}..")
     connection.subscriptions[msg[CONF_ID]] = remove_webhook
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
 
 
 @require_admin
@@ -322,10 +333,78 @@ def remove_trigger() -> None:
         assert isinstance(default_agent, DefaultAgent)
 
         _remove_trigger = default_agent.register_trigger(sentences, handle_trigger)
-    except ValueError:
-        connection.send_message(result_message(msg[CONF_ID], {"success": False}))
+    except ValueError as err:
+        connection.send_message(error_message(msg[CONF_ID], "value_error", str(err)))
+        return
+    except Exception as err:
+        connection.send_message(error_message(msg[CONF_ID], "unknown_error", str(err)))
         return
 
     _LOGGER.info(f"Sentence trigger created: {sentences}")
     connection.subscriptions[msg[CONF_ID]] = remove_trigger
-    connection.send_message(result_message(msg[CONF_ID], {"success": True}))
+    connection.send_message(result_message(msg[CONF_ID]))
+
+
+@require_admin
+@websocket_command(
+    {
+        vol.Required(CONF_TYPE): "nodered/device/trigger",
+        vol.Required(CONF_NODE_ID): cv.string,
+        vol.Required(CONF_DEVICE_TRIGGER, default={}): dict,
+    }
+)
+@async_response
+async def websocket_device_trigger(
+    hass: HomeAssistant, connection: ActiveConnection, msg: dict[str, Any]
+) -> None:
+    """Create device trigger."""
+    node_id = msg[CONF_NODE_ID]
+    trigger_data = msg[CONF_DEVICE_TRIGGER]
+
+    def forward_trigger(event, context=None):
+        """Forward events to websocket."""
+        message = event_message(
+            msg[CONF_ID],
+            {"type": "device_trigger", "data": event["trigger"]},
+        )
+        connection.send_message(
+            json.dumps(message, cls=NodeRedJSONEncoder, allow_nan=False)
+        )
+
+    def unsubscribe() -> None:
+        """Remove device trigger."""
+        remove_trigger()
+        _LOGGER.info(f"Device trigger removed: {node_id}")
+
+    try:
+        trigger_config = await trigger.async_validate_trigger_config(
+            hass, [trigger_data]
+        )
+        remove_trigger = await trigger.async_initialize_triggers(
+            hass,
+            trigger_config,
+            forward_trigger,
+            DOMAIN,
+            DOMAIN,
+            _LOGGER.log,
+        )
+
+    except vol.MultipleInvalid as err:
+        _LOGGER.error(
+            f"Error initializing device trigger '{node_id}': {str(err)}",
+        )
+        connection.send_message(
+            error_message(msg[CONF_ID], "invalid_trigger", str(err))
+        )
+        return
+    except Exception as err:
+        _LOGGER.error(
+            f"Error initializing device trigger '{node_id}': {str(err)}",
+        )
+        connection.send_message(error_message(msg[CONF_ID], "unknown_error", str(err)))
+        return
+
+    _LOGGER.info(f"Device trigger created: {node_id}")
+    _LOGGER.debug(f"Device trigger config for {node_id}: {trigger_data}")
+    connection.subscriptions[msg[CONF_ID]] = unsubscribe
+    connection.send_message(result_message(msg[CONF_ID]))