Merge pull request #23 from dcapslock/2.3.5

2.3.5

Author: dcapslock

README.md

@@ -23,10 +23,9 @@ The Phoenix fork of Browser Mod 2 starts with Version 2.3.4. The version was mad
 To use the Phoenix Versoin follow these steps:
 
 1. Uninstall the current HACS version (browser_mod)
-3. Add ```https://github.com/dcapslock/hass-browser_mod``` as a [custom HACS reporistory](https://www.hacs.xyz/docs/faq/custom_repositories/) (Integration)
-4. Download the latest Phoenix version (browser_mod_phx)
-5. Check dashboard resources for any old reference to broswer_mod.js (e.g. /browser_mod.js?automatically-added&2.3.3). Remove if present.
-6. Restart Home Assistant
+2. Add ```https://github.com/dcapslock/hass-browser_mod``` as a [custom HACS reporistory](https://www.hacs.xyz/docs/faq/custom_repositories/) (Integration)
+3. Download the latest Phoenix version (browser_mod_phx). As of v2.3.5, dashboard resource will be correctly updated with latest version.
+4. Restart Home Assistant
 
 # Installation instructions
 

custom_components/browser_mod/browser.py

@@ -166,7 +166,7 @@ def delete(self, hass):
         self.entities = {}
 
         device = dr.async_get_device({(DOMAIN, self.browserID)})
-        dr.async_remove_device(device.id)
+        hass.add_job(removeDevice, hass, self.browserID, device.id)
 
     @property
     def connection(self):
@@ -201,11 +201,41 @@ def getBrowser(hass, browserID, *, create=True):
 
 def deleteBrowser(hass, browserID):
     """Delete a browser by BrowserID."""
+
     browsers = hass.data[DOMAIN][DATA_BROWSERS]
+
     if browserID in browsers:
         browsers[browserID].delete(hass)
         del browsers[browserID]
-
+    else:
+        # Non-reporting Browser
+        dr = device_registry.async_get(hass)
+        er = entity_registry.async_get(hass)
+        _LOGGER.debug("deleteBrowser: Removing non-reporting browser %s", browserID)
+
+        dev = dr.async_get_device({(DOMAIN, browserID)})
+        if dev:
+            # Remove all entities associated with the device
+            for entity in entity_registry.async_entries_for_device(er, dev.id, include_disabled_entities=True):
+                if entity.platform == DOMAIN:
+                    _LOGGER.debug("deleteBrowser: Removing entity %s for browser %s", entity.entity_id, browserID)
+                    er.async_remove(entity.entity_id)
+            
+            hass.add_job(removeDevice, hass, browserID, dev.id)
+        
+def deleteBrowsers(hass, browsers_include, browsers_exclude):
+    """Delete browsers by list of browsers to include and exclude."""    
+    for browserID in browsers_include:
+        _LOGGER.debug("deleteBrowsers: Deleting browser %s (included)", browserID)
+        deleteBrowser(hass, browserID)
+
+    if browsers_exclude:
+        dr = device_registry.async_get(hass)
+        devices = [dev for dev in dr.devices.data.values() if any(identifier for identifier in dev.identifiers if identifier[0] == DOMAIN)]
+        for dev in devices:
+            if dev.identifiers and list(dev.identifiers)[0][1] not in browsers_exclude:
+                _LOGGER.debug("deleteBrowsers: Deleting browser %s (not excluded)", list(dev.identifiers)[0][1])
+                deleteBrowser(hass, list(dev.identifiers)[0][1])
 
 def getBrowserByConnection(hass, connection):
     """Get the browser that has a given connection open."""
@@ -214,3 +244,14 @@ def getBrowserByConnection(hass, connection):
     for k, v in browsers.items():
         if any([c[0] == connection for c in v.connection]):
             return v
+
+@callback
+def removeDevice(hass, browserID, deviceID):
+    """Remove a device by browserID."""
+    dr = device_registry.async_get(hass)
+
+    # Remove the device from the registry
+    dev = dr.async_get(deviceID)
+    if dev:
+        _LOGGER.debug("removeDevice: Removing device %s (%s)", dev.id, browserID)
+        dr.async_remove_device(dev.id)

custom_components/browser_mod/browser_mod.js

@@ -18,7 +18,7 @@
 WS_RECALL_ID = f"{WS_ROOT}/recall_id"
 WS_LOG = f"{WS_ROOT}/log"
 
-BROWSER_MOD_SERVICES = [
+BROWSER_MOD_BROWSER_SERVICES = [
     "sequence",
     "delay",
     "popup",
@@ -31,3 +31,7 @@
     "console",
     "javascript",
 ]
+
+BROWSER_MOD_COMPONENT_SERVICES = [
+    "deregister_browser",
+]

custom_components/browser_mod/browser_mod_panel.js

@@ -10,8 +10,8 @@
     "frontend",
     "lovelace"
   ],
-  "documentation": "https://github.com/dcapslock/hass-browser_mod/blob/2.3.4/README.md",
+  "documentation": "https://github.com/dcapslock/hass-browser_mod/blob/master/README.md",
   "iot_class": "local_push",
   "requirements": [],
-  "version": "2.3.4"
+  "version": "2.3.5"
 }

custom_components/browser_mod/const.py

@@ -2,6 +2,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.components.frontend import add_extra_js_url, async_register_built_in_panel
 from homeassistant.components.http import StaticPathConfig
+from homeassistant.components.lovelace.resources import ResourceStorageCollection
 
 from .const import FRONTEND_SCRIPT_URL, SETTINGS_PANEL_URL
 
@@ -57,6 +58,7 @@ async def async_setup_view(hass: HomeAssistant):
 
     # Also load Browser Mod as a lovelace resource so it's accessible to Cast
     resources = hass.data["lovelace"].resources
+    resourceUrl = FRONTEND_SCRIPT_URL + "?automatically-added" + "&" + version
     if resources:
         if not resources.loaded:
             await resources.async_load()
@@ -66,6 +68,19 @@ async def async_setup_view(hass: HomeAssistant):
         for r in resources.async_items():
             if r["url"].startswith(FRONTEND_SCRIPT_URL):
                 frontend_added = True
+                if not r["url"].endswith(version):
+                    if isinstance(resources, ResourceStorageCollection):
+                        await resources.async_update_item(
+                            r["id"], 
+                            {
+                                "res_type": "module", 
+                                "url": resourceUrl
+                            }
+                        )
+                    else:
+                        # not the best solution, but what else can we do
+                        r["url"] = resourceUrl
+                
                 continue
 
             # While going through the resources, also preload card-mod if it is found
@@ -77,7 +92,7 @@ async def async_setup_view(hass: HomeAssistant):
                 await resources.async_create_item(
                     {
                         "res_type": "module",
-                        "url": FRONTEND_SCRIPT_URL + "?automatically-added" + "&" + version,
+                        "url": resourceUrl,
                     }
                 )
             elif getattr(resources, "data", None) and getattr(
@@ -86,7 +101,7 @@ async def async_setup_view(hass: HomeAssistant):
                 resources.data.append(
                     {
                         "type": "module",
-                        "url": FRONTEND_SCRIPT_URL + "?automatically-added" + "&" + version,
+                        "url": resourceUrl,
 
                     }
-                )
+                )

custom_components/browser_mod/manifest.json

@@ -1,45 +1,51 @@
 import logging
 
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry, template
+from homeassistant.util import dt as dt_util
+from homeassistant.exceptions import ServiceValidationError
 
 from .const import (
-    BROWSER_MOD_SERVICES,
+    BROWSER_MOD_BROWSER_SERVICES,
+    BROWSER_MOD_COMPONENT_SERVICES,
     DOMAIN,
     DATA_BROWSERS,
+    DATA_STORE,
 )
 
+from .browser import deleteBrowsers
+
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_services(hass):
-    def call_service(service, targets, data):
-
-        browsers = hass.data[DOMAIN][DATA_BROWSERS]
-
-        # If no targets were specified, send to all browsers
-        if targets is None:
-            targets = browsers.keys()
-
-        for target in targets:
-            if target not in browsers:
-                continue
-            browser = browsers[target]
-            hass.create_task(browser.send(service, **data))
-
-    def handle_service(call):
-        service = call.service
-        data = {**call.data}
-
-        browsers = data.pop("browser_id", [])
+    def get_browser_ids(data, selectorSuffix=""):
+        browserIDSelector = "browser_id"
+        deviceIDSelector = "device_id"
+        areaIDSelector = "area_id"
+        if selectorSuffix:
+            browserIDSelector += f"_{selectorSuffix}"
+            deviceIDSelector += f"_{selectorSuffix}"
+            areaIDSelector += f"_{selectorSuffix}"
+        
+        browsers = data.pop(browserIDSelector, [])
         if isinstance(browsers, str):
             browsers = [browsers]
 
         # Support service targets
-        browsers.extend(data.pop("device_id", []))
+        deviceIDs = data.pop(deviceIDSelector, [])
+        if isinstance(deviceIDs, str):
+            deviceIDs = [deviceIDs]
+        browsers.extend(deviceIDs)
         dr = device_registry.async_get(hass)
-        for area in data.pop("area_id", []):
+        areaIDs = data.pop(areaIDSelector, [])
+        if isinstance(areaIDs, str):
+            areaIDs = [areaIDs]
+        for area in areaIDs:
             for dev in device_registry.async_entries_for_area(dr, area):
-                browsers.append(list(dev.identifiers)[0][1])
+                for identifier in dev.identifiers:
+                    if identifier[0] == DOMAIN:
+                        browsers.append(identifier[1])
+                        break
 
         browserIDs = None
         if len(browsers):
@@ -52,8 +58,89 @@ def handle_service(call):
                     browserIDs.add(br)
 
             browserIDs = set(browserIDs)
+        
+        return browserIDs
+
+    def call_service(service, targets, data):
+        browserTargets = targets["browsers"]
+        userTargets = targets["users"]
+
+        browsers = hass.data[DOMAIN][DATA_BROWSERS]
+
+        # If no targets were specified, send to all browsers
+        if browserTargets is None and userTargets is None:
+            browserTargets = browsers.keys()
+        elif browserTargets is None and userTargets is not None:
+            browserTargets = []
+
+        if userTargets is not None and len(userTargets):
+            for userId in userTargets:
+                for key, browser in browsers.items():
+                    if browser.data.get("browser", {}).get("userData", {}).get("id") == userId:
+                        browserTargets.append(key)
+
+        for browserTarget in browserTargets:
+            if browserTarget not in browsers:
+                continue
+            browser = browsers[browserTarget]
+            hass.create_task(browser.send(service, **data))
+
+    def handle_browser_service(call):
+        service = call.service
+        data = {**call.data}
+
+        browserIDs = get_browser_ids(data)
+
+        # Support User Targets
+        users = data.pop("user_id", [])
+        if isinstance(users, str):
+            users = [users]
+        
+        userIDs = None
+        if len(users):
+            userIDs = set()
+            for user in users:
+                userId = template.state_attr(hass, user, "user_id")
+                if userId:
+                    userIDs.add(userId)
+                else:
+                    userIDs.add(user)
+
+        targets = {"browsers": browserIDs, "users": userIDs}
+
+        call_service(service, targets, data)
+    
+    # Hanldler for server browser_mod.deregister_browser
+    async def deregister_browser(call):
+        data = {**call.data}
+
+        browserIDs = get_browser_ids(data)
+        if browserIDs is None:
+            browserIDs = set()
+        
+        excludedBrowserIDs = get_browser_ids(data, "exclude")
+        if excludedBrowserIDs is None:
+            excludedBrowserIDs = set()
+
+        if not browserIDs and not excludedBrowserIDs:
+            raise ServiceValidationError(
+                "No browsers to include or exclude"
+            )
+        
+        _LOGGER.debug("browser_mod.deregister_browser: included: %s", browserIDs)
+        _LOGGER.debug("browser_mod.deregister_browser: excluded: %s", excludedBrowserIDs)
+        deleteBrowsers(hass, browserIDs, excludedBrowserIDs)
 
-        call_service(service, browserIDs, data)
+        store = hass.data[DOMAIN][DATA_STORE]
+        await store.cleanup(browserIDs, excludedBrowserIDs)
+    
+    for service in BROWSER_MOD_BROWSER_SERVICES:
+        hass.services.async_register(DOMAIN, service, handle_browser_service)
 
-    for service in BROWSER_MOD_SERVICES:
-        hass.services.async_register(DOMAIN, service, handle_service)
+    handlerFunctions = locals()
+    for service in BROWSER_MOD_COMPONENT_SERVICES:        
+        if service in handlerFunctions:
+            hass.services.async_register(DOMAIN, service, handlerFunctions[service])
+        else:
+            _LOGGER.error("Component handler service %s not found", service)
+