Bugfix: Electric Kiwi migrate unique id

homeassistant/components/electric_kiwi/__init__.py

@@ -4,12 +4,16 @@
 
 import aiohttp
 from electrickiwi_api import ElectricKiwiApi
-from electrickiwi_api.exceptions import ApiException
+from electrickiwi_api.exceptions import ApiException, AuthException
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_entry_oauth2_flow,
+    entity_registry as er,
+)
 
 from . import api
 from .coordinator import (
@@ -44,7 +48,9 @@
         raise ConfigEntryNotReady from err
 
     ek_api = ElectricKiwiApi(
-        api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
+        api.ConfigEntryElectricKiwiAuth(
+            aiohttp_client.async_get_clientsession(hass), session
+        )
     )
     hop_coordinator = ElectricKiwiHOPDataCoordinator(hass, entry, ek_api)
     account_coordinator = ElectricKiwiAccountDataCoordinator(hass, entry, ek_api)
@@ -53,6 +59,8 @@
         await ek_api.set_active_session()
         await hop_coordinator.async_config_entry_first_refresh()
         await account_coordinator.async_config_entry_first_refresh()
+    except AuthException as err:
+        raise ConfigEntryAuthFailed from err
     except ApiException as err:
         raise ConfigEntryNotReady from err
 
@@ -70,3 +78,53 @@
 ) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: ElectricKiwiConfigEntry
+) -> bool:
+    """Migrate old entry."""
+    if config_entry.version == 1 and config_entry.minor_version == 1:
+        implementation = (
+            await config_entry_oauth2_flow.async_get_config_entry_implementation(
+                hass, config_entry
+            )
+        )
+
+        session = config_entry_oauth2_flow.OAuth2Session(
+            hass, config_entry, implementation
+        )
+
+        ek_api = ElectricKiwiApi(
+            api.ConfigEntryElectricKiwiAuth(
+                aiohttp_client.async_get_clientsession(hass), session
+            )
+        )
+        try:
+            await ek_api.set_active_session()
+            connection_details = await ek_api.get_connection_details()
+        except AuthException:
+            config_entry.async_start_reauth(hass)
+            return False
+        except ApiException:
+            return False
+        unique_id = str(ek_api.customer_number)
+        identifier = ek_api.electricity.identifier
+        hass.config_entries.async_update_entry(
+            config_entry, unique_id=unique_id, minor_version=2
+        )
+        entity_registry = er.async_get(hass)
+        entity_entries = er.async_entries_for_config_entry(
+            entity_registry, config_entry_id=config_entry.entry_id
+        )
+
+        for entity in entity_entries:
+            assert entity.config_entry_id
+            entity_registry.async_update_entity(
+                entity.entity_id,
+                new_unique_id=entity.unique_id.replace(
+                    f"{unique_id}_{connection_details.id}", f"{unique_id}_{identifier}"
+                ),
+            )
+
+    return True

homeassistant/components/electric_kiwi/api.py

@@ -2,17 +2,16 @@
 
 from __future__ import annotations
 
-from typing import cast
-
 from aiohttp import ClientSession
 from electrickiwi_api import AbstractAuth
 
-from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
 
 from .const import API_BASE_URL
 
 
-class AsyncConfigEntryAuth(AbstractAuth):
+class ConfigEntryElectricKiwiAuth(AbstractAuth):
     """Provide Electric Kiwi authentication tied to an OAuth2 based config entry."""
 
     def __init__(
@@ -29,4 +28,21 @@
         """Return a valid access token."""
         await self._oauth_session.async_ensure_token_valid()
 
-        return cast(str, self._oauth_session.token["access_token"])
+        return str(self._oauth_session.token["access_token"])
+
+
+class ConfigFlowElectricKiwiAuth(AbstractAuth):
+    """Provide Electric Kiwi authentication tied to an OAuth2 based config flow."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        token: str,
+    ) -> None:
+        """Initialize ConfigFlowFitbitApi."""
+        super().__init__(aiohttp_client.async_get_clientsession(hass), API_BASE_URL)
+        self._token = token
+
+    async def async_get_access_token(self) -> str:
+        """Return the token for the Electric Kiwi API."""
+        return self._token

homeassistant/components/electric_kiwi/config_flow.py

@@ -6,9 +6,14 @@
 import logging
 from typing import Any
 
-from homeassistant.config_entries import ConfigFlowResult
+from electrickiwi_api import ElectricKiwiApi
+from electrickiwi_api.exceptions import ApiException
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.const import CONF_NAME
 from homeassistant.helpers import config_entry_oauth2_flow
 
+from . import api
 from .const import DOMAIN, SCOPE_VALUES
 
 
@@ -17,6 +22,8 @@ class ElectricKiwiOauth2FlowHandler(
 ):
     """Config flow to handle Electric Kiwi OAuth2 authentication."""
 
+    VERSION = 1
+    MINOR_VERSION = 2
     DOMAIN = DOMAIN
 
     @property
@@ -40,12 +47,30 @@ async def async_step_reauth_confirm(
     ) -> ConfigFlowResult:
         """Dialog that informs the user that reauth is required."""
         if user_input is None:
-            return self.async_show_form(step_id="reauth_confirm")
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                description_placeholders={CONF_NAME: self._get_reauth_entry().title},
+            )
         return await self.async_step_user()
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an entry for Electric Kiwi."""
-        existing_entry = await self.async_set_unique_id(DOMAIN)
-        if existing_entry:
-            return self.async_update_reload_and_abort(existing_entry, data=data)
-        return await super().async_oauth_create_entry(data)
+        ek_api = ElectricKiwiApi(
+            api.ConfigFlowElectricKiwiAuth(self.hass, data["token"]["access_token"])
+        )
+
+        try:
+            session = await ek_api.get_active_session()
+        except ApiException:
+            return self.async_abort(reason="connection_error")
+
+        unique_id = str(session.data.customer_number)
+        await self.async_set_unique_id(unique_id)
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch(reason="wrong_account")
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(), data=data
+            )
+
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(title=unique_id, data=data)

homeassistant/components/electric_kiwi/const.py

@@ -8,4 +8,4 @@
 OAUTH2_TOKEN = "https://welcome.electrickiwi.co.nz/oauth/token"
 API_BASE_URL = "https://api.electrickiwi.co.nz"
 
-SCOPE_VALUES = "read_connection_detail read_billing_frequency read_account_running_balance read_consumption_summary read_consumption_averages read_hop_intervals_config read_hop_connection save_hop_connection read_session"
+SCOPE_VALUES = "read_customer_details read_connection_detail read_connection read_billing_address get_bill_address read_billing_frequency read_billing_details read_billing_bills read_billing_bill read_billing_bill_id read_billing_bill_file read_account_running_balance read_customer_account_summary read_consumption_summary download_consumption_file read_consumption_averages get_consumption_averages read_hop_intervals_config read_hop_intervals read_hop_connection read_hop_specific_connection save_hop_connection save_hop_specific_connection read_outage_contact get_outage_contact_info_for_icp read_session read_session_data_login"

homeassistant/components/electric_kiwi/coordinator.py

@@ -10,7 +10,7 @@
 
 from electrickiwi_api import ElectricKiwiApi
 from electrickiwi_api.exceptions import ApiException, AuthException
-from electrickiwi_api.model import AccountBalance, Hop, HopIntervals
+from electrickiwi_api.model import AccountSummary, Hop, HopIntervals
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -34,7 +34,7 @@
 type ElectricKiwiConfigEntry = ConfigEntry[ElectricKiwiRuntimeData]
 
 
-class ElectricKiwiAccountDataCoordinator(DataUpdateCoordinator[AccountBalance]):
+class ElectricKiwiAccountDataCoordinator(DataUpdateCoordinator[AccountSummary]):
     """ElectricKiwi Account Data object."""
 
     def __init__(
@@ -51,13 +51,13 @@
             name="Electric Kiwi Account Data",
             update_interval=ACCOUNT_SCAN_INTERVAL,
         )
-        self._ek_api = ek_api
+        self.ek_api = ek_api
 
-    async def _async_update_data(self) -> AccountBalance:
+    async def _async_update_data(self) -> AccountSummary:
         """Fetch data from Account balance API endpoint."""
         try:
             async with asyncio.timeout(60):
-                return await self._ek_api.get_account_balance()
+                return await self.ek_api.get_account_summary()
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:
@@ -85,7 +85,7 @@
             # Polling interval. Will only be polled if there are subscribers.
             update_interval=HOP_SCAN_INTERVAL,
         )
-        self._ek_api = ek_api
+        self.ek_api = ek_api
         self.hop_intervals: HopIntervals | None = None
 
     def get_hop_options(self) -> dict[str, int]:
@@ -100,7 +100,7 @@
     async def async_update_hop(self, hop_interval: int) -> Hop:
         """Update selected hop and data."""
         try:
-            self.async_set_updated_data(await self._ek_api.post_hop(hop_interval))
+            self.async_set_updated_data(await self.ek_api.post_hop(hop_interval))
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:
@@ -118,7 +118,7 @@
         try:
             async with asyncio.timeout(60):
                 if self.hop_intervals is None:
-                    hop_intervals: HopIntervals = await self._ek_api.get_hop_intervals()
+                    hop_intervals: HopIntervals = await self.ek_api.get_hop_intervals()
                     hop_intervals.intervals = OrderedDict(
                         filter(
                             lambda pair: pair[1].active == 1,
@@ -127,7 +127,7 @@
                     )
 
                     self.hop_intervals = hop_intervals
-                return await self._ek_api.get_hop()
+                return await self.ek_api.get_hop()
         except AuthException as auth_err:
             raise ConfigEntryAuthFailed from auth_err
         except ApiException as api_err:

homeassistant/components/electric_kiwi/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/electric_kiwi",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "requirements": ["electrickiwi-api==0.8.5"]
+  "requirements": ["electrickiwi-api==0.9.12"]
 }

homeassistant/components/electric_kiwi/select.py

@@ -53,8 +53,8 @@ def __init__(
         """Initialise the HOP selection entity."""
         super().__init__(coordinator)
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
         self.values_dict = coordinator.get_hop_options()

homeassistant/components/electric_kiwi/sensor.py

@@ -6,7 +6,7 @@
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
-from electrickiwi_api.model import AccountBalance, Hop
+from electrickiwi_api.model import AccountSummary, Hop
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -39,7 +39,15 @@
 class ElectricKiwiAccountSensorEntityDescription(SensorEntityDescription):
     """Describes Electric Kiwi sensor entity."""
 
-    value_func: Callable[[AccountBalance], float | datetime]
+    value_func: Callable[[AccountSummary], float | datetime]
+
+
+def _get_hop_percentage(account_balance: AccountSummary) -> float:
+    """Return the hop percentage from account summary."""
+    if power := account_balance.services.get("power"):
+        if connection := power.connections[0]:
+            return float(connection.hop_percentage)
+    return 0.0
 
 
 ACCOUNT_SENSOR_TYPES: tuple[ElectricKiwiAccountSensorEntityDescription, ...] = (
@@ -72,9 +80,7 @@
         translation_key="hop_power_savings",
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        value_func=lambda account_balance: float(
-            account_balance.connections[0].hop_percentage
-        ),
+        value_func=_get_hop_percentage,
     ),
 )
 
@@ -165,8 +171,8 @@
         super().__init__(coordinator)
 
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
 
@@ -194,8 +200,8 @@
         super().__init__(coordinator)
 
         self._attr_unique_id = (
-            f"{coordinator._ek_api.customer_number}"  # noqa: SLF001
-            f"_{coordinator._ek_api.connection_id}_{description.key}"  # noqa: SLF001
+            f"{coordinator.ek_api.customer_number}"
+            f"_{coordinator.ek_api.electricity.identifier}_{description.key}"
         )
         self.entity_description = description
 

homeassistant/components/electric_kiwi/strings.json

@@ -21,7 +21,8 @@
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
       "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
-      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]"
+      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "connection_error": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"

tests/components/electric_kiwi/__init__.py

@@ -1 +1,13 @@
 """Tests for the Electric Kiwi integration."""
+
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def init_integration(hass: HomeAssistant, entry: MockConfigEntry) -> None:
+    """Fixture for setting up the integration with args."""
+    entry.add_to_hass(hass)
+
+    await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()