Merge pull request #10 from rospogrigio/login_and_retrieve_tokenset

Login and retrieve tokenset

Author: rospogrigio

README.md

@@ -9,24 +9,27 @@ Alternatively, you can install daikin_residential through HACS by adding this re
 
 # Usage:
 
-**NOTE: You must have your Daikin Cloud token set stored as a tokenset.json file in your /config folder (the same where configuration.yaml is). For instructions on how to retrieve this file, follow the guide at https://github.com/Apollon77/daikin-controller-cloud/blob/main/PROXY.md .**
+**NOTE: since v.2.0.x, the tokenset.json file is no longer needed because the integration can connect and retrieve the tokens autonomously. When installing v.2.0.x from a previous one, the integration must be deleted and re-added.**
 
 The integration can be configured in two ways:
 
 # 1. YAML config files
 
-Just add the following line to your configuration.yaml file, and the Daikin devices connected to your cloud account will be created.
+Just add the following lines to your configuration.yaml file specifying the email and password used in the Daikin Residential App, and the Daikin devices connected to your cloud account will be created.
 
 ```
 daikin_residential:
+  email: [your_email]
+  password: [your_pwd]
+
 ```
 
 
 # 2. Using config flow
 
 Start by going to Configuration - Integration and pressing the "+ ADD INTEGRATION" button to create a new Integration, then select Daikin Residential Controller in the drop-down menu.
 
-Follow the instruction, you have actually nothing to configure, just make sure your tokenset.json fine is in the HA config folder. After pressing the "Submit" button, the integration will be added, and the Daikin devices connected to your cloud account will be created.
+Follow the instructions, you just have to type the email and password used in the Daikin Residential App. After pressing the "Submit" button, the integration will be added, and the Daikin devices connected to your cloud account will be created.
 
 
 # To-do list:
@@ -36,4 +39,4 @@ Follow the instruction, you have actually nothing to configure, just make sure y
 
 # Thanks to:
 
-This code is based on @Apollon77 's great work, in finding a way to retrieve the token set, and to send the HTTP commands over the cloud. This integration would not exist without his precious job.
+This code is based on @Apollon77 's great work, in finding a way to retrieve the token set, and to send the HTTP commands over the cloud. This integration would not exist without his precious job, my job was just to find a way to port his code from nodeJS to python, and then create the integration.

custom_components/daikin_residential/__init__.py

@@ -5,10 +5,10 @@
 import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
-
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, SERVICE_RELOAD
 from homeassistant.helpers.typing import HomeAssistantType
 
-from .const import DOMAIN, DAIKIN_API, DAIKIN_DEVICES
+from .const import DOMAIN, DAIKIN_API, DAIKIN_DEVICES, CONF_TOKENSET
 
 from .daikin_api import DaikinApi
 
@@ -31,11 +31,39 @@
 COMPONENT_TYPES = ["climate", "sensor", "switch"]
 
 
-CONFIG_SCHEMA = vol.Schema(vol.All({DOMAIN: vol.Schema({})}), extra=vol.ALLOW_EXTRA)
+CONFIG_SCHEMA = vol.Schema(
+    vol.All(
+        {
+            DOMAIN: vol.Schema(
+                {vol.Required(CONF_EMAIL): str, vol.Required(CONF_PASSWORD): str}
+            )
+        }
+    ),
+    extra=vol.ALLOW_EXTRA,
+)
 
 
 async def async_setup(hass, config):
-    """Establish connection with Daikin."""
+    """Setup the Daikin Residential component."""
+
+    async def _handle_reload(service):
+        """Handle reload service call."""
+        _LOGGER.info("Reloading integration: retrieving new TokenSet.")
+        try:
+            daikin_api = hass.data[DOMAIN][DAIKIN_API]
+            data = daikin_api._config_entry.data.copy()
+            await daikin_api.retrieveAccessToken(data[CONF_EMAIL], data[CONF_PASSWORD])
+            data[CONF_TOKENSET] = daikin_api.tokenSet
+            hass.config_entries.async_update_entry(
+                entry=daikin_api._config_entry, data=data
+            )
+        except Exception as e:
+            _LOGGER.error("Failed to reload integration: %s", e)
+
+    hass.helpers.service.async_register_admin_service(
+        DOMAIN, SERVICE_RELOAD, _handle_reload
+    )
+
     if DOMAIN not in config:
         return True
 
@@ -46,13 +74,14 @@ async def async_setup(hass, config):
                 DOMAIN, context={"source": SOURCE_IMPORT}, data=conf
             )
         )
+
     return True
 
 
 async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry):
     """Establish connection with Daikin."""
 
-    daikin_api = DaikinApi(hass)
+    daikin_api = DaikinApi(hass, entry)
     await daikin_api.getCloudDeviceDetails()
 
     devices = await daikin_api.getCloudDevices()

custom_components/daikin_residential/config_flow.py

@@ -4,9 +4,10 @@
 import voluptuous as vol
 
 from homeassistant import config_entries
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
 
 from .daikin_api import DaikinApi
-from .const import DOMAIN
+from .const import DOMAIN, CONF_TOKENSET
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,7 +17,7 @@ class FlowHandler(config_entries.ConfigFlow):
     """Handle a config flow."""
 
     VERSION = 1
-    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
 
     def __init__(self):
         """Initialize the Daikin config flow."""
@@ -25,9 +26,11 @@ def __init__(self):
     @property
     def schema(self):
         """Return current schema."""
-        return vol.Schema({})
+        return vol.Schema(
+            {vol.Required(CONF_EMAIL): str, vol.Required(CONF_PASSWORD): str}
+        )
 
-    async def _create_entry(self):
+    async def _create_entry(self, email, password, tokenSet):
         """Register new entry."""
         # if not self.unique_id:
         #    await self.async_set_unique_id(password)
@@ -37,27 +40,41 @@ async def _create_entry(self):
 
         await self.async_set_unique_id("DaikinResidentialController")
 
-        return self.async_create_entry(title="Daikin", data={})
+        return self.async_create_entry(
+            title="Daikin",
+            data={CONF_EMAIL: email, CONF_PASSWORD: password, CONF_TOKENSET: tokenSet},
+        )
 
-    async def _attempt_connection(self):
+    async def _attempt_connection(self, email, password):
         """Create device."""
         try:
-            daikin_api = DaikinApi(self.hass)
-        except Exception:
-            return self.async_abort(reason="missing_config")
+            daikin_api = DaikinApi(self.hass, None)
+        except Exception as e:
+            _LOGGER.error("Failed to initialize DaikinApi: %s", e)
+            return self.async_abort(reason="init_failed")
+        try:
+            await daikin_api.retrieveAccessToken(email, password)
+        except Exception as e:
+            _LOGGER.error("Failed to retrieve Access Token: %s", e)
+            return self.async_abort(reason="token_retrieval_failed")
         try:
             await daikin_api.getApiInfo()
-        except Exception:
+        except Exception as e:
+            _LOGGER.error("Failed to connect to DaikinApi: %s", e)
             return self.async_abort(reason="cannot_connect")
 
-        return await self._create_entry()
+        return await self._create_entry(email, password, daikin_api.tokenSet)
 
     async def async_step_user(self, user_input=None):
         """User initiated config flow."""
         if user_input is None:
             return self.async_show_form(step_id="user", data_schema=self.schema)
-        return await self._attempt_connection()
+        return await self._attempt_connection(
+            user_input.get(CONF_EMAIL), user_input.get(CONF_PASSWORD)
+        )
 
     async def async_step_import(self, user_input):
-        """Import a config entry."""
-        return await self._create_entry()
+        """Import a config entry from YAML."""
+        return await self._attempt_connection(
+            user_input.get(CONF_EMAIL), user_input.get(CONF_PASSWORD)
+        )

custom_components/daikin_residential/const.py

@@ -2,6 +2,7 @@
 
 from homeassistant.const import (
     CONF_DEVICE_CLASS,
+    CONF_TOKEN,
     CONF_ICON,
     CONF_NAME,
     CONF_TYPE,
@@ -13,6 +14,8 @@
 
 DOMAIN = "daikin_residential"
 
+CONF_TOKENSET = CONF_TOKEN + "set"
+
 DAIKIN_DATA = "daikin_data"
 DAIKIN_API = "daikin_api"
 DAIKIN_DEVICES = "daikin_devices"