Refresh access token during sensor startup (#8)

* Refresh access token during sensor startup

* chore: address linting errors

* Copy HomeAssistant config before rewriting it

* Handle changed passwords and signal broken sensors

Author: unlobito

custom_components/hildebrandglow/config_flow.py

@@ -13,14 +13,8 @@
 DATA_SCHEMA = vol.Schema({"app_id": str, "username": str, "password": str})
 
 
-async def validate_input(hass: core.HomeAssistant, data: dict) -> Dict[str, Any]:
-    """Validate the user input allows us to connect.
-
-    Data has the keys from DATA_SCHEMA with values provided by the user.
-    """
-    glow = await Glow.authenticate(data["app_id"], data["username"], data["password"])
-
-    # Return some info we want to store in the config entry.
+def config_object(data: dict, glow: Dict[str, Any]) -> Dict[str, Any]:
+    """Prepare a ConfigEntity with authentication data and a temporary token."""
     return {
         "name": glow["name"],
         "app_id": data["app_id"],
@@ -31,6 +25,19 @@ async def validate_input(hass: core.HomeAssistant, data: dict) -> Dict[str, Any]
     }
 
 
+async def validate_input(hass: core.HomeAssistant, data: dict) -> Dict[str, Any]:
+    """Validate the user input allows us to connect.
+
+    Data has the keys from DATA_SCHEMA with values provided by the user.
+    """
+    glow = await hass.async_add_executor_job(
+        Glow.authenticate, data["app_id"], data["username"], data["password"]
+    )
+
+    # Return some info we want to store in the config entry.
+    return config_object(data, glow)
+
+
 class DomainConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Hildebrand Glow."""
 

custom_components/hildebrandglow/glow.py

@@ -17,9 +17,7 @@ def __init__(self, app_id: str, token: str):
         self.token = token
 
     @classmethod
-    async def authenticate(
-        cls, app_id: str, username: str, password: str
-    ) -> Dict[str, Any]:
+    def authenticate(cls, app_id: str, username: str, password: str) -> Dict[str, Any]:
         """
         Attempt to authenticate with Glowmarkt.
 
@@ -42,7 +40,7 @@ async def authenticate(
             pprint(data)
             raise InvalidAuth
 
-    async def retrieve_resources(self) -> List[Dict[str, Any]]:
+    def retrieve_resources(self) -> List[Dict[str, Any]]:
         """Retrieve the resources known to Glowmarkt for the authenticated user."""
         url = f"{self.BASE_URL}/resource"
         headers = {"applicationId": self.app_id, "token": self.token}
@@ -58,7 +56,7 @@ async def retrieve_resources(self) -> List[Dict[str, Any]]:
         data = response.json()
         return data
 
-    async def current_usage(self, resource: Dict[str, Any]) -> Dict[str, Any]:
+    def current_usage(self, resource: Dict[str, Any]) -> Dict[str, Any]:
         """Retrieve the current usage for a specified resource."""
         url = f"{self.BASE_URL}/resource/{resource}/current"
         headers = {"applicationId": self.app_id, "token": self.token}

custom_components/hildebrandglow/sensor.py

@@ -1,25 +1,52 @@
 """Platform for sensor integration."""
 from typing import Any, Callable, Dict, Optional
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import DEVICE_CLASS_POWER, POWER_WATT
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import Entity
 
+from .config_flow import config_object
 from .const import DOMAIN
-from .glow import Glow
+from .glow import Glow, InvalidAuth
 
 
 async def async_setup_entry(
-    hass: HomeAssistant, config: Dict[str, Any], async_add_entities: Callable
+    hass: HomeAssistant, config: ConfigEntry, async_add_entities: Callable
 ) -> bool:
     """Set up the sensor platform."""
     new_entities = []
 
+    async def handle_failed_auth(config: ConfigEntry, hass: HomeAssistant) -> None:
+        glow_auth = await hass.async_add_executor_job(
+            Glow.authenticate,
+            config.data["app_id"],
+            config.data["username"],
+            config.data["password"],
+        )
+
+        current_config = dict(config.data.copy())
+        new_config = config_object(current_config, glow_auth)
+        hass.config_entries.async_update_entry(entry=config, data=new_config)
+
+        glow = Glow(config.data["app_id"], glow_auth["token"])
+        hass.data[DOMAIN][config.entry_id] = glow
+
     for entry in hass.data[DOMAIN]:
         glow = hass.data[DOMAIN][entry]
 
-        resources = await glow.retrieve_resources()
+        resources: dict = dict()
 
+        try:
+            resources = await hass.async_add_executor_job(glow.retrieve_resources)
+        except InvalidAuth:
+            try:
+                await handle_failed_auth(config, hass)
+            except InvalidAuth:
+                return False
+
+            glow = hass.data[DOMAIN][entry]
+            resources = await hass.async_add_executor_job(glow.retrieve_resources)
         for resource in resources:
             if resource["resourceTypeId"] in GlowConsumptionCurrent.resourceTypeId:
                 sensor = GlowConsumptionCurrent(glow, resource)
@@ -33,11 +60,15 @@ async def async_setup_entry(
 class GlowConsumptionCurrent(Entity):
     """Sensor object for the Glowmarkt resource's current consumption."""
 
+    hass: HomeAssistant
+
     resourceTypeId = [
         "ea02304a-2820-4ea0-8399-f1d1b430c3a0",  # Smart Meter, electricity consumption
         "672b8071-44ff-4f23-bca2-f50c6a3ddd02",  # Smart Meter, gas consumption
     ]
 
+    available = True
+
     def __init__(self, glow: Glow, resource: Dict[str, Any]):
         """Initialize the sensor."""
         self._state: Optional[Dict[str, Any]] = None
@@ -103,4 +134,11 @@ async def async_update(self) -> None:
 
         This is the only method that should fetch new data for Home Assistant.
         """
-        self._state = await self.glow.current_usage(self.resource["resourceId"])
+        try:
+            self._state = await self.hass.async_add_executor_job(
+                self.glow.current_usage, self.resource["resourceId"]
+            )
+        except InvalidAuth:
+            # TODO: Trip the failed auth logic above somehow
+            self.available = False
+            pass