custom_components/whatsapp_bridge_integration/sensor.py aktualisiert

0.2.2

CHANGELOG.md

@@ -0,0 +1,20 @@
+# CHANGELOG - Whatsapp Bridge Integration
+
+## Release 0.2.2 - 2026-06-15
+- **Architecture Change:** Introduced a dedicated "WhatsApp Bridge Hub" device. This central device acts as a single point of reference for global components, preventing UI clutter.
+- **Fix:** Moved the global live status sensor and the virtual broadcast entity to the new WhatsApp Bridge Hub device. This ensures they remain fully visible and accessible across the Home Assistant UI, automations, and service calls without being duplicated across individual user accounts.
+- **Improvement:** Maintained isolated, clean individual devices for each configured account profile (*Larissa, Rene, Work*).
+
+## Release 0.2.1 - 2026-06-15
+- **Fix:** Resolved device assignment duplication where a single global gateway card duplicated across all account tabs.
+- **Fix:** Globalized the live status sensor and the broadcast entity to instantiate exactly once for the entire integration rather than incorrectly duplicating per account.
+- **Optimization:** Code refactoring within `sensor.py` to prevent entity duplication when utilizing multiple profiles.
+
+## Release 0.2.0 - 2026-06-15
+- **New:** Setup of a main device (WhatsApp Bridge Gateway) in the Home Assistant device registry.
+- **New:** Integrated global service `whatsapp_bridge.send_broadcast`, which operates independently of individual profile entities and can send messages to any number or group ID.
+- **New:** Added status sensor (`sensor.whatsapp_bridge_status`). This queries the add-on's new API and provides the current connection status (`CONNECTED`, `WAITING_FOR_SCAN`, `INITIALIZING`, `OFFLINE`) directly within Home Assistant.
+- **Improved:** The sensor is assigned to the new main device, which significantly simplifies automations (e.g., alert on connection loss).
+
+## Release 0.1.7
+- Previous stable version

README.md

@@ -1,58 +1,58 @@
-# WhatsApp Bridge Integration for Home Assistant 🚀
+# WhatsApp Bridge for Home Assistant
 
-This is the custom integration for the **Bahmcloud WhatsApp Bridge**. It allows you to manage multiple WhatsApp accounts as Home Assistant services, making it incredibly easy to send automated messages via YAML or Node-RED.
+A professional, seamless integration to send WhatsApp messages through the **Bahmcloud Bridge**. This integration supports multiple profiles, dynamic entity-based selection, and broadcast capabilities with native Home Assistant support.
 
----
+## 🚀 Installation
 
-## 🛠️ Installation
-
-### 1. Prerequisite: The Add-on
-Before installing this integration, ensure that the **WhatsApp Bridge Add-on** is installed and running.
-* [Link to your Add-on Repository]
-* Open the Add-on Web UI and scan the QR code to link your WhatsApp account.
+### 1. Install the Add-on
+The **Bahmcloud WhatsApp Bridge Add-on** must be running for the integration to work:
+1. Navigate to **Settings** -> **Add-ons**.
+2. Click **Add-on Store** -> Three dots (top right) -> **Repositories**.
+3. Add your Bahmcloud Repository URL.
+4. Search for "WhatsApp Bridge", click **Install**, and **Start**.
 
 ### 2. Install the Integration
-1.  Copy the folder `whatsapp_bridge_integration` into your Home Assistant `config/custom_components/` directory.
-2.  Restart Home Assistant.
-3.  Go to **Settings** -> **Devices & Services**.
-4.  Click **Add Integration** and search for "WhatsApp Bridge Integration".
+You can install the integration component via three methods:
+
+* **HACS (Recommended):** Add this repository as a "Custom Repository" in HACS and click Install.
+* **BCS (Bahmcloud Store):** Search for "WhatsApp Bridge" in the BCS interface.
+* **Manual:** Copy the `custom_components/whatsapp_bridge_integration` folder into your `/config/custom_components/` directory and restart Home Assistant.
 
 ---
 
-## 📖 How to use
+## 👥 Configuration & Profiles
 
-Once installed, the integration provides a new service (action) that you can use in any automation.
+Add your WhatsApp accounts via the Home Assistant UI:
+1. Go to **Settings** -> **Devices & Services**.
+2. Click **Add Integration** and search for **WhatsApp Bridge**.
+3. Follow the setup to add an **Account Name** (e.g., "Work") and your **Phone Number**.
+4. **Repeat** this process for as many accounts as you need.
 
-### Send a Message via YAML
-You can call the service directly in your automations:
+### Resulting Entities
+The integration automatically creates sensors for your UI:
+* `sensor.whatsapp_account_name`: An entity for each individual account.
+* `sensor.whatsapp_broadcast_all`: A global entity to message all accounts at once.
 
+---
+
+## 🛠 Usage
+
+### Action: `send_message`
+This integration registers a service/action to send messages.
+
+**Fields:**
+* **Recipient:** Select an account from the dropdown, choose the "Broadcast" entity, or manually type a phone number.
+* **Message:** The text content you wish to send.
+
+#### YAML Example:
 ```yaml
 action: whatsapp_bridge_integration.send_message
 data:
-  number: "491701234567"
-  message: "The washing machine is finished! 🧺"
+  recipient: "sensor.whatsapp_rene"
+  message: "The garage door is still open!"
 ```
 
-### Use in Node-RED
-Add a Call Service (or Action) node.
-
-Domain: whatsapp_bridge_integration
-
-Service: send_message
-
-Data:
-
-```JSON
-{
-  "number": "491701234567",
-  "message": "{{payload}}"
-}
-```
-
-## 👥 Multi-Account Support (Coming Soon)
-We are currently working on a UI-based configuration flow so you can save "Account Aliases" (like "Dad", "Work", "Security") and select them from a dropdown menu without typing the phone number every time.
-
-##⚠️ Important Notes
+## ⚠️ Important Notes
 Phone Numbers: Always use the international format without + or 00 (e.g., 49... for Germany).
 
 Local Network: The integration communicates locally with the Add-on on port 3000.
@@ -60,3 +60,53 @@ Local Network: The integration communicates locally with the Add-on on port 3000
 Developed by Bahmcloud
 
 ---
+
+## 🤖 Node-RED Integration
+The integration is fully compatible with Node-RED. Since it uses native entities, you can use the standard *Action (Call Service)* node.
+
+### Example: Smart Window Warning
+Notify yourself if a window or door has been left open for 15 minutes.
+
+ 1. *Trigger*: Use a `State Trigger` or `Device` node.
+
+ 2. *Logic (Change Node)*: Use JSONata to create a dynamic message:
+
+  - *Set*: msg.payload
+
+  - *Value (JSONata)*: `payload.to_state.attributes.friendly_name & " has been open for 15 minutes!"`
+
+ 3. WhatsApp Node (Action Node):
+
+  - *Action*: `whatsapp_bridge_integration.send_message`
+
+  - *Data (JSON)*:
+
+```JSON
+{
+   "recipient": "sensor.whatsapp_broadcast_all",
+   "message": "{{payload}}"
+}
+```
+
+### Manual Tool Calling
+To send a message to a number not saved as a profile, simply pass the raw phone number to the recipient field in your Node-RED JSON:
+
+```JSON
+{
+  "recipient": "491701234567",
+  "message": "Direct alert to external number."
+}
+```
+
+---
+
+# ✨ Features
+ - *Dynamic UI*: Accounts are automatically added to the recipient dropdown.
+
+ - *One-Click Broadcast*: Special entity to reach all configured profiles instantly.
+
+ - *Manual Fallback*: Clean UI remains flexible; type any number to bypass profiles.
+
+ - *Developer Friendly*: Designed for easy integration with Node-RED and HA Automations.
+---
+Maintained by Bahmcloud

custom_components/whatsapp_bridge_integration/__init__.py

@@ -1,36 +1,55 @@
-async def handle_send_message(call: ServiceCall):
-            message = call.data.get("message")
-            recipient = call.data.get("recipient")
-            use_manual = call.data.get("use_manual_number", False)
-            target_number = call.data.get("number")
+import logging
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from .const import DOMAIN
 
-            entries = hass.config_entries.async_entries(DOMAIN)
-            targets = []
+_LOGGER = logging.getLogger(__name__)
 
-            # Logik-Prüfung
-            if use_manual and target_number:
-                # Fall A: Manuelle Nummer
-                targets.append(target_number)
-            elif recipient == "all_accounts":
-                # Fall B: Rundruf
-                for e in entries:
-                    targets.append(e.data.get(CONF_PHONE_NUMBER))
-            elif recipient:
-                # Fall C: Spezifisches Profil (Recipient Name)
-                for e in entries:
-                    if e.title.lower() == recipient.lower():
-                        targets.append(e.data.get(CONF_PHONE_NUMBER))
+async def async_setup(hass: HomeAssistant, config: dict):
+    return True
 
-            # Senden (wie gehabt)
-            for num in targets:
-                url = "http://866fd2eb-whatsapp-bridge:3000/send"
-                try:
-                    await hass.async_add_executor_job(
-                        lambda: requests.post(url, json={
-                            "number": num,
-                            "message": message
-                        }, timeout=10)
-                    )
-                    _LOGGER.info("WhatsApp sent to %s", num)
-                except Exception as e:
-                    _LOGGER.error("Error sending to %s: %s", num, str(e))
+async def async_setup_entry(hass: HomeAssistant, entry):
+    """Set up entry, create specific contact device, central hub and forward to platforms."""
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = entry.data
+
+    device_registry = dr.async_get(hass)
+
+    # 1. Eigenes Gerät SPEZIFISCH für diesen Account/Kontakt anlegen
+    device_registry.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        identifiers={(DOMAIN, entry.entry_id)},  # Einzigartig pro Eintrag
+        name=f"WhatsApp {entry.title}",
+        manufacturer="Bahmcloud",
+        model="Kontakt-Endpunkt",
+        sw_version="0.2.2",
+    )
+
+    # 2. Zentralen System-Hub NUR EINMALIG anlegen (wird an den ersten geladenen Account gekoppelt)
+    if not hass.data[DOMAIN].get("hub_device_created"):
+        device_registry.async_get_or_create(
+            config_entry_id=entry.entry_id,
+            identifiers={(DOMAIN, "global_bridge_hub")},
+            name="WhatsApp Bridge Hub",
+            manufacturer="Bahmcloud",
+            model="Bridge Server",
+            sw_version="0.2.2",
+        )
+        hass.data[DOMAIN]["hub_device_created"] = True
+
+    # Forward the setup to the sensor platform to create entities
+    await hass.config_entries.async_forward_entry_setups(entry, ["sensor"])
+    
+    # Registriere den Service (nur beim ersten Mal)
+    if not hass.services.has_service(DOMAIN, "send_message"):
+        from .services import async_setup_services
+        await async_setup_services(hass)
+
+    return True
+
+async def async_unload_entry(hass: HomeAssistant, entry):
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, ["sensor"])
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+    return unload_ok

custom_components/whatsapp_bridge_integration/manifest.json

@@ -4,7 +4,7 @@
   "documentation": "https://git.bahmcloud.de/bahmcloud/Whatsapp-Bridge-Integration",
   "dependencies": [],
   "codeowners": ["@bahmcloud"],
-  "version": "0.1.3",
+  "version": "0.2.2",
   "iot_class": "local_polling",
   "config_flow": true
 }

custom_components/whatsapp_bridge_integration/sensor.py

@@ -0,0 +1,157 @@
+import logging
+import async_timeout
+import aiohttp
+from datetime import timedelta
+
+from homeassistant.components.sensor import SensorEntity
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=15)
+
+async def async_setup_entry(hass, entry, async_add_entities):
+    """Add sensors for WhatsApp accounts, live status, and a global broadcast sensor."""
+    
+    # Coordinator für den echten Live-Status vom Add-on einrichten
+    async def _async_update_data():
+        url = "http://866fd2eb-whatsapp-bridge:3000/api/status"
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with async_timeout.timeout(5):
+                    async with session.get(url) as response:
+                        if response.status != 200:
+                            raise UpdateFailed(f"API meldet Fehler {response.status}")
+                        return await response.json()
+            except Exception as err:
+                raise UpdateFailed(f"Add-on nicht erreichbar: {err}")
+
+    coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name="whatsapp_bridge_status",
+        update_method=_async_update_data,
+        update_interval=SCAN_INTERVAL,
+    )
+
+    try:
+        await coordinator.async_config_entry_first_refresh()
+    except UpdateFailed:
+        _LOGGER.warning("Erster Status-Abruf fehlgeschlagen. Add-on läuft eventuell noch an.")
+
+    # Jeder Account bekommt immer seine eigene Entität
+    entities = [WhatsAppAccountEntity(entry)]
+    
+    # Globale Entitäten (Status & Broadcast) NUR EINMALIG für die gesamte Integration anlegen
+    if not hass.data[DOMAIN].get("global_entities_registered"):
+        entities.append(WhatsAppStatusSensor(coordinator))
+        entities.append(WhatsAppBroadcastEntity())
+        hass.data[DOMAIN]["global_entities_registered"] = True
+        
+    async_add_entities(entities, True)
+
+
+class WhatsAppAccountEntity(SensorEntity):
+    """Individual Account (e.g., Rene, Work)."""
+    def __init__(self, entry):
+        self._entry = entry
+        self._attr_name = f"WhatsApp {entry.title}"
+        self._attr_unique_id = f"{entry.entry_id}_status"
+        self._attr_icon = "mdi:whatsapp"
+        self._attr_extra_state_attributes = {
+            "phone_number": entry.data.get("phone_number"),
+            "is_broadcast": False
+        }
+
+    @property
+    def state(self):
+        return "Ready"
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Ordnet diesen Sensor seinem spezifischen Personen-Gerät zu."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._entry.entry_id)},
+        )
+
+
+class WhatsAppBroadcastEntity(SensorEntity):
+    """Virtual 'All Accounts' Entity, geordnet unter dem zentralen Hub."""
+    def __init__(self):
+        self._attr_name = "WhatsApp Broadcast (All)"
+        self._attr_unique_id = "whatsapp_bridge_broadcast_all"
+        self._attr_icon = "mdi:whatsapp-arrow-up"
+        self._attr_extra_state_attributes = {
+            "is_broadcast": True
+        }
+
+    @property
+    def state(self):
+        return "Global"
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Ordnet diese Entität dem zentralen Hub-Gerät zu."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, "global_bridge_hub")},
+        )
+
+
+class WhatsAppStatusSensor(SensorEntity):
+    """Echter Live-Status-Sensor, geordnet unter dem zentralen Hub."""
+
+    def __init__(self, coordinator):
+        self.coordinator = coordinator
+        self._attr_name = "WhatsApp Bridge Status"
+        self._attr_unique_id = "whatsapp_bridge_live_status_global"
+        self._attr_icon = "mdi:whatsapp"
+
+    @property
+    def should_poll(self) -> bool:
+        return False
+
+    @property
+    def available(self) -> bool:
+        return self.coordinator.last_update_success
+
+    @property
+    def state(self):
+        """Gibt den dynamischen Status aus der Add-on API zurück."""
+        data = self.coordinator.data
+        if not data:
+            return "OFFLINE"
+        
+        if data.get("isReady"):
+            return "CONNECTED"
+        elif data.get("hasQr"):
+            return "WAITING_FOR_SCAN"
+        elif data.get("isInitializing"):
+            return "INITIALIZING"
+        
+        return "UNKNOWN"
+
+    @property
+    def extra_state_attributes(self):
+        """Zusätzliche Attribute für erweitertes Debugging."""
+        data = self.coordinator.data
+        if data:
+            return {
+                "client_state": data.get("clientState", "UNKNOWN"),
+                "has_qr_code": data.get("hasQr", False)
+            }
+        return {}
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Ordnet diese Entität dem zentralen Hub-Gerät zu."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, "global_bridge_hub")},
+        )
+
+    async def async_added_to_hass(self):
+        """Registrieren beim Live-Coordinator."""
+        self.async_on_remove(
+            self.coordinator.async_add_listener(self.async_write_ha_state)
+        )

custom_components/whatsapp_bridge_integration/services.py

@@ -0,0 +1,44 @@
+import requests
+import logging
+from homeassistant.core import HomeAssistant, ServiceCall
+from .const import DOMAIN, CONF_PHONE_NUMBER
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_services(hass: HomeAssistant):
+    async def handle_send_message(call: ServiceCall):
+        message = call.data.get("message")
+        recipient = call.data.get("recipient")
+        
+        targets = []
+        entries = hass.config_entries.async_entries(DOMAIN)
+
+        # 1. Prüfen, ob es eine Entity-ID ist
+        if recipient.startswith("sensor."):
+            state = hass.states.get(recipient)
+            if state:
+                # Ist es die 'All Accounts' Entität?
+                if state.attributes.get("is_broadcast"):
+                    for e in entries:
+                        targets.append(e.data.get(CONF_PHONE_NUMBER))
+                else:
+                    # Es ist ein einzelner Account
+                    targets.append(state.attributes.get("phone_number"))
+        
+        # 2. Fallback: Manuelle Nummer (wenn keine sensor-ID übergeben wurde)
+        else:
+            targets.append(recipient)
+
+        # Senden
+        for num in targets:
+            if not num: continue
+            url = "http://866fd2eb-whatsapp-bridge:3000/send"
+            try:
+                await hass.async_add_executor_job(
+                    lambda: requests.post(url, json={"number": num, "message": message}, timeout=10)
+                )
+                _LOGGER.info("WhatsApp sent to %s", num)
+            except Exception as e:
+                _LOGGER.error("Error sending to %s: %s", num, str(e))
+
+    hass.services.async_register(DOMAIN, "send_message", handle_send_message)

custom_components/whatsapp_bridge_integration/services.yaml

@@ -1,33 +1,21 @@
 send_message:
   name: Send Message
-  description: Sends a WhatsApp message via the Bahmcloud Bridge.
+  description: Sends a WhatsApp message via the Bridge.
   fields:
     recipient:
       name: Recipient
-      description: Select a saved profile or choose "Broadcast to all".
+      description: Select an Account, the Broadcast entity, or type a manual number.
       required: true
       selector:
-        select:
-          options:
-            - label: "Broadcast to all"
-              value: "all_accounts"
-          # Dieser Teil sorgt dafür, dass HA die Namen deiner Accounts anzeigt
-          custom_value: true 
+        # Dies zeigt nun "WhatsApp Rene", "WhatsApp Work" UND "WhatsApp Broadcast (All)" an.
+        entity:
+          filter:
+            integration: whatsapp_bridge_integration
+            domain: sensor
     message:
       name: Message
-      description: The content of your WhatsApp message.
+      description: Your message text.
       required: true
       selector:
         text:
           multiline: true
-    use_manual_number:
-      name: Use Manual Number
-      description: Enable this to ignore the recipient and use the number field below.
-      default: false
-      selector:
-        boolean:
-    number:
-      name: Manual Number
-      description: "Direct phone number (e.g., 491701234567)."
-      selector:
-        text: