Added migration of config entry

Author: OStrama

custom_components/weishaupt_modbus/__init__.py

@@ -4,8 +4,9 @@
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.const import CONF_PREFIX
 
-from .const import CONST
+from .const import CONST, CONF_DEVICE_POSTFIX, CONF_KENNFELD_FILE
 from .modbusobject import ModbusAPI
 
 PLATFORMS: list[str] = [
@@ -33,6 +34,30 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
+async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
+    """Migrate old entry."""
+    warnings.warn("Check if migration of config entries is necessary.")
+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
+    if config_entry.version < 2:
+        warnings.warn("Version 1 detected")
+        new_data = {**config_entry.data}
+        warnings.warn("Minor version 1 detected")
+        new_data[CONF_PREFIX] = CONST.DEF_PREFIX
+        new_data[CONF_DEVICE_POSTFIX] = ""
+        new_data[CONF_KENNFELD_FILE] = CONST.DEF_KENNFELDFILE
+
+        warnings.warn("Update entries")
+
+        hass.config_entries.async_update_entry(
+            config_entry, data=new_data, minor_version=1, version=2
+        )
+
+    return True
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload entry."""
     # This is called when an entry/configured device is to be removed. The class

custom_components/weishaupt_modbus/config_flow.py

@@ -56,7 +56,7 @@ async def validate_input(hass: HomeAssistant, data: dict) -> dict[str, Any]:
 class ConfigFlow(config_entries.ConfigFlow, domain=CONST.DOMAIN):
     """Class config flow."""
 
-    VERSION = 1
+    VERSION = 2
     # Pick one of the available connection classes in homeassistant/config_entries.py
     # This tells HA if it should be asking for updates, or it'll be notified of updates
     # automatically. This example uses PUSH, as the dummy hub will notify HA of
@@ -86,20 +86,6 @@ async def async_step_user(self, user_input=None):
             step_id="user", data_schema=DATA_SCHEMA, errors=errors
         )
 
-    # async def async_step_reconfigure(
-    #    self, user_input: dict[str, Any] | None = None
-    # ) -> ConfigFlowResult:
-    #    """Add reconfigure step to allow to reconfigure a config entry."""
-    #    errors = {}
-    #    reconfigure_entry = self._get_reconfigure_entry()##
-
-    #    return self.async_show_form(
-    #        step_id="reconfigure",
-    #        data_schema=DATA_SCHEMA,
-    #        description_placeholders={"device": reconfigure_entry.title},
-    #        errors=errors,
-    #    )
-
 
 class InvalidHost(exceptions.HomeAssistantError):
     """Error to indicate there is an invalid hostname."""

custom_components/weishaupt_modbus/entities.py

@@ -136,8 +136,6 @@ async def _async_setup(self):
         This method will be called automatically during
         coordinator.async_config_entry_first_refresh.
         """
-        # await self._modbus_api.connect()
-        #    self._device = self._modbus_api.get_device()
         await self.fetch_data()
 
     async def fetch_data(self, idx=None):
@@ -197,8 +195,6 @@ async def _async_update_data(self):
             # Grab active context variables to limit data required to be fetched from API
             # Note: using context is not required if there is no need or ability to limit
             # data retrieved from API.
-            # listening_idx = set(self.async_contexts())
-            # return await self._modbus_api.fetch_data(listening_idx)
             try:
                 listening_idx = set(self.async_contexts())
                 return await self.fetch_data(listening_idx)
@@ -242,23 +238,15 @@ def __init__(self, config_entry, modbus_item, modbus_api) -> None:
         self._attr_name = self._modbus_item.name
 
         dev_postfix = ""
-        try:
-            dev_postfix = "_" + self._config_entry.data[CONF_DEVICE_POSTFIX]
-        except KeyError:
-            warnings.warn("Device postfix not defined, use default: ")
+        dev_postfix = "_" + self._config_entry.data[CONF_DEVICE_POSTFIX]
 
         if dev_postfix == "_":
             dev_postfix = ""
 
         dev_prefix = CONST.DEF_PREFIX
-        try:
-            dev_prefix = self._config_entry.data[CONF_PREFIX]
-        except KeyError:
-            warnings.warn("Device prefix not defined, use default: " + CONST.DEF_PREFIX)
-
-        self._attr_unique_id = (
-            dev_prefix + self._modbus_item.name + dev_postfix
-        )  # CONST.PREFIX + self._modbus_item.name
+        dev_prefix = self._config_entry.data[CONF_PREFIX]
+
+        self._attr_unique_id = dev_prefix + self._modbus_item.name + dev_postfix
         self._dev_device = self._modbus_item.device + dev_postfix
         self._modbus_api = modbus_api
 
@@ -305,20 +293,6 @@ def calc_temperature(self, val: float):
                 # to optimize
                 return int(val) / self._divider
 
-        # if val is None:
-        #    return None
-        # if val == -32768:
-        #    # No Sensor installed
-        #    return -1
-        # if val == -32767:
-        #    # Sensor broken
-        #    return -2
-        # if val == 32768:
-        #    # Dont know. Whats this?
-        #    return None
-        # if val in range(-500, 5000):
-        #    return int(val) / self._divider
-
     def calc_percentage(self, val: float):
         """Calculate percentage."""
         if val is None:
@@ -424,10 +398,6 @@ def _handle_coordinator_update(self) -> None:
         self._attr_native_value = self.translate_val(self._modbus_item.state)
         self.async_write_ha_state()
 
-    # async def async_update(self) -> None:
-    #    # the synching is done by the ModbusObject of the entity
-    #    self._attr_native_value = self.translate_val(0)
-
     def calc_power(self, val, x, y):
         """Calculate heating power from power map."""
         if val is None:
@@ -495,15 +465,10 @@ def _handle_coordinator_update(self) -> None:
 
     async def async_set_native_value(self, value: float) -> None:
         await self.set_translate_val(value)
-        # await self.coordinator.async_request_refresh()
         self._modbus_item.state = int(self.retranslate_val(value))
         self._attr_native_value = self.translate_val(self._modbus_item.state)
         self.async_write_ha_state()
 
-    # async def async_update(self) -> None:
-    #    # the synching is done by the ModbusObject of the entity
-    #    self._attr_native_value = self.translate_val(self._modbus_item.state)
-
     @property
     def device_info(self) -> DeviceInfo:
         """Return device info."""
@@ -543,11 +508,6 @@ def _handle_coordinator_update(self) -> None:
         self._attr_current_option = self.translate_val(self._modbus_item.state)
         self.async_write_ha_state()
 
-    # async def async_update(self) -> None:
-    #    # the synching is done by the ModbusObject of the entity
-    #    await self.coordinator.async_request_refresh()
-    #    self._attr_current_option = self.translate_val(self._modbus_item.state)
-
     @property
     def device_info(self) -> DeviceInfo:
         """Return device info."""

custom_components/weishaupt_modbus/hpconst.py

@@ -226,6 +226,14 @@ class DeviceConstants:
     StatusItem(2, "Pumpe"),
 ]
 
+HP_KONFIGURATION = [
+    StatusItem(0, "Ncht konfiguriert"),
+    StatusItem(1, "Heizen verfügbar"),
+    StatusItem(2, "Heizen, Kühlen verfügbar"),
+    StatusItem(3, "Heizen, Kühlen, Warmwasser verfügbar"),
+    StatusItem(4, "Heizen, Warmwasser verfügbar"),
+]
+
 WW_PUSH = [
     StatusItem(0, "AUS"),
 ]
@@ -350,7 +358,7 @@ class DeviceConstants:
     ModbusItem( 33103, "Wärmeleistung", FORMATS.POWER, TYPES.SENSOR_CALC, DEVICES.WP, RANGE_CALCPOWER),
     ModbusItem( 33104, "Vorlauftemperatur", FORMATS.TEMPERATUR, TYPES.SENSOR, DEVICES.WP, TEMPRANGE_STD),
     ModbusItem( 33105, "Rücklauftemperatur", FORMATS.TEMPERATUR, TYPES.SENSOR,  DEVICES.WP, TEMPRANGE_STD),
-    ModbusItem( 43101, "Konfiguration ", FORMATS.NUMBER, TYPES.NUMBER_RO, DEVICES.WP),
+    ModbusItem( 43101, "Konfiguration ", FORMATS.STATUS, TYPES.NUMBER_RO, DEVICES.WP, HP_KONFIGURATION),
     ModbusItem( 43102, "Ruhemodus", FORMATS.STATUS, TYPES.NUMBER_RO, DEVICES.WP, HP_RUHEMODUS),
     ModbusItem( 43103, "Pumpe Einschaltart", FORMATS.NUMBER, TYPES.NUMBER_RO, DEVICES.WP ),
     ModbusItem( 43104, "Pumpe Leistung Heizen", FORMATS.PERCENTAGE, TYPES.NUMBER_RO, DEVICES.WP, RANGE_PERCENTAGE),

custom_components/weishaupt_modbus/modbusobject.py

@@ -97,7 +97,6 @@ def __init__(self, modbus_api: ModbusAPI, modbus_item: ModbusItem) -> None:
         """
         self._modbus_item = modbus_item
         self._modbus_client = modbus_api.get_device()
-        # await self._modbus_client.connect()
 
     def check_valid(self, val):
         """Checks if item is available and valid"""
@@ -122,10 +121,8 @@ def check_temperature(self, val):
                 self._modbus_item.is_invalid = True
             case 32768:
                 # Dont know. Whats this?
-                # print("Sensor not installed: " + self._modbus_item.name)
                 self._modbus_item.is_invalid = True
             case _:
-                # print("Sensor OK " + self._modbus_item.name + " " + str(val))
                 self._modbus_item.is_invalid = False
 
     def check_percentage(self, val):