Merge pull request #21 from andrew-dddd/master

Added multi module support and humidity

Author: MichalKrasowski

.gitignore

@@ -1 +1,2 @@
-__pycache__/
+__pycache__/
+.vscode

custom_components/tech/__init__.py

@@ -24,6 +24,7 @@ async def async_setup(hass: HomeAssistant, config: dict):
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
     """Set up Tech Controllers from a config entry."""
     _LOGGER.debug("Setting up component's entry.")
+    _LOGGER.debug("Entry id: " + str(entry.entry_id))
     _LOGGER.debug("Entry -> title: " + entry.title + ", data: " + str(entry.data) + ", id: " + entry.entry_id + ", domain: " + entry.domain)
     # Store an API object for your platforms to access
     hass.data.setdefault(DOMAIN, {})

custom_components/tech/climate.py

@@ -14,6 +14,7 @@
     CURRENT_HVAC_OFF,
     SUPPORT_PRESET_MODE,
     SUPPORT_TARGET_TEMPERATURE,
+    ATTR_CURRENT_HUMIDITY
 )
 from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
 from .const import DOMAIN
@@ -24,32 +25,32 @@
 
 async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up entry."""
-    _LOGGER.debug("Setting up entry, module udid: " + config_entry.data["udid"])
+    udid = config_entry.data["module"]["udid"]
+    _LOGGER.debug("Setting up entry, module udid: " + udid)
     api = hass.data[DOMAIN][config_entry.entry_id]
-    zones = await api.get_module_zones(config_entry.data["udid"])
+    zones = await api.get_module_zones(udid)
+    thermostats = [
+                TechThermostat(
+                    zones[zone],
+                    api,
+                    udid
+                ) 
+                for zone in zones
+            ]
 
-    async_add_entities(
-        [
-            TechThermostat(
-                zones[zone],
-                api,
-                config_entry,
-            )
-            for zone in zones
-        ],
-        True,
-    )
+    async_add_entities(thermostats, True)
 
 
 class TechThermostat(ClimateEntity):
     """Representation of a Tech climate."""
 
-    def __init__(self, device, api, config_entry):
+    def __init__(self, device, api, udid):
         """Initialize the Tech device."""
         _LOGGER.debug("Init TechThermostat...")
-        self._config_entry = config_entry
+        self._udid = udid
         self._api = api
         self._id = device["zone"]["id"]
+        self._unique_id = udid + "_" + str(device["zone"]["id"])
         self.update_properties(device)
 
     def update_properties(self, device):
@@ -62,6 +63,10 @@ def update_properties(self, device):
             self._temperature =  device["zone"]["currentTemperature"] / 10
         else:
             self._temperature = None
+        if device["zone"]["humidity"] is not None:
+            self._humidity = device["zone"]["humidity"]
+        else:
+            self._humidity = None	
         state = device["zone"]["flags"]["relayState"]
         if state == "on":
             self._state = CURRENT_HVAC_HEAT
@@ -78,7 +83,7 @@ def update_properties(self, device):
     @property
     def unique_id(self) -> str:
         """Return a unique ID."""
-        return self._id
+        return self._unique_id
 
     @property
     def name(self):
@@ -116,8 +121,8 @@ def hvac_action(self) -> Optional[str]:
 
     async def async_update(self):
         """Call by the Tech device callback to update state."""
-        _LOGGER.debug("Updating Tech zone: %s, udid: %s, id: %s", self._name, self._config_entry.data["udid"], self._id)
-        device = await self._api.get_zone(self._config_entry.data["udid"], self._id)
+        _LOGGER.debug("Updating Tech zone: %s, udid: %s, id: %s", self._name, self._udid, self._id)
+        device = await self._api.get_zone(self._udid, self._id)
         self.update_properties(device)
 
     @property
@@ -130,6 +135,11 @@ def current_temperature(self):
         """Return the current temperature."""
         return self._temperature
 
+    @property
+    def current_humidity(self):
+        """Return current humidity."""
+        return self._humidity
+
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
@@ -141,13 +151,13 @@ async def async_set_temperature(self, **kwargs):
         if temperature:
             _LOGGER.debug("%s: Setting temperature to %s", self._name, temperature)
             self._temperature = temperature
-            await self._api.set_const_temp(self._config_entry.data["udid"], self._id, temperature)
+            await self._api.set_const_temp(self._udid, self._id, temperature)
 
     async def async_set_hvac_mode(self, hvac_mode):
         """Set new target hvac mode."""
         _LOGGER.debug("%s: Setting hvac mode to %s", self._name, hvac_mode)
         if hvac_mode == HVAC_MODE_OFF:
-            await self._api.set_zone(self._config_entry.data["udid"], self._id, False)
+            await self._api.set_zone(self._udid, self._id, False)
         elif hvac_mode == HVAC_MODE_HEAT:
-            await self._api.set_zone(self._config_entry.data["udid"], self._id, True)
+            await self._api.set_zone(self._udid, self._id, True)
 

custom_components/tech/config_flow.py

@@ -1,16 +1,17 @@
 """Config flow for Tech Sterowniki integration."""
-import logging
+import logging, uuid
 import voluptuous as vol
 from homeassistant import config_entries, core, exceptions
 from homeassistant.helpers import aiohttp_client
+from homeassistant.config_entries import ConfigEntry
 from .const import DOMAIN  # pylint:disable=unused-import
 from .tech import Tech
 
 _LOGGER = logging.getLogger(__name__)
 
 DATA_SCHEMA = vol.Schema({
     vol.Required("username"): str,
-    vol.Required("password"): str
+    vol.Required("password"): str,
 })
 
 
@@ -26,16 +27,14 @@ async def validate_input(hass: core.HomeAssistant, data):
     if not await api.authenticate(data["username"], data["password"]):
         raise InvalidAuth
     modules = await api.list_modules()
-    # Currently only one Tech controller supported
-    module = modules[0]
 
     # If you cannot connect:
     # throw CannotConnect
     # If the authentication is wrong:
     # InvalidAuth
 
     # Return info that you want to store in the config entry.
-    return {"user_id": api.user_id, "token": api.token, "udid": module["udid"], "version": module["version"]}
+    return { "user_id": api.user_id, "token": api.token, "modules": modules }
 
 
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@@ -50,9 +49,19 @@ async def async_step_user(self, user_input=None):
         errors = {}
         if user_input is not None:
             try:
-                info = await validate_input(self.hass, user_input)
+                _LOGGER.debug("Context: " + str(self.context))                
+                validated_input = await validate_input(self.hass, user_input)
 
-                return self.async_create_entry(title=info["version"], data=info)
+                modules = self._create_modules_array(validated_input=validated_input)
+
+                if len(modules) == 0:
+                    return self.async_abort("no_modules")
+
+                if len(modules) > 1:
+                    for module in modules[1:len(modules)]:
+                        await self.hass.config_entries.async_add(self._create_config_entry(module=module))
+                    
+                return self.async_create_entry(title=modules[0]["version"], data=modules[0])
             except CannotConnect:
                 errors["base"] = "cannot_connect"
             except InvalidAuth:
@@ -65,6 +74,30 @@ async def async_step_user(self, user_input=None):
             step_id="user", data_schema=DATA_SCHEMA, errors=errors
         )
 
+    def _create_config_entry(self, module: dict) -> ConfigEntry:
+        return ConfigEntry(
+            data=module,                         
+            title=module["version"], 
+            entry_id=uuid.uuid4().hex,
+            domain=DOMAIN,
+            version=ConfigFlow.VERSION,
+            minor_version=ConfigFlow.MINOR_VERSION,
+            source=ConfigFlow.CONNECTION_CLASS)
+    
+    def _create_modules_array(self, validated_input: dict) -> [dict]:
+        return [
+            self._create_module_dict(validated_input, module_dict)
+            for module_dict in validated_input["modules"]
+        ]
+
+    def _create_module_dict(self, validated_input: dict, module_dict: dict) -> dict:
+        return {   
+            "user_id": validated_input["user_id"],
+            "token": validated_input["token"],
+            "module": module_dict,
+            "version": module_dict["version"] + ": " + module_dict["name"]
+        }
+
 
 class CannotConnect(exceptions.HomeAssistantError):
     """Error to indicate we cannot connect."""

custom_components/tech/translations/en.json

@@ -1,7 +1,8 @@
 {
     "config": {
         "abort": {
-            "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+            "already_configured": "Device already configured",
+            "no_modules": "No modules detected"
         },
         "error": {
             "cannot_connect": "Cannot connect to Tech API.",
@@ -20,4 +21,4 @@
         }
     },
     "title": "Tech Controllers"
-}
+}