qolsys-controller 0.0.44__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/panel.py

@@ -1,6 +1,13 @@
-from hmac import new
+from __future__ import annotations
+
+import base64
 import json
 import logging
+from typing import TYPE_CHECKING, Any
+
+from qolsys_controller.adc_device import QolsysAdcDevice
+from qolsys_controller.zwave_energy_clamp import QolsysEnergyClamp
+from qolsys_controller.zwave_thermometer import QolsysThermometer
 
 from .database.db import QolsysDB
 from .enum import (
@@ -11,10 +18,9 @@ from .enum import (
 from .observable import QolsysObservable
 from .partition import QolsysPartition
 from .scene import QolsysScene
-from .settings import QolsysSettings
-from .state import QolsysState
+from .users import QolsysUser
+from .weather import QolsysForecast, QolsysWeather
 from .zone import QolsysZone
-from .zwave_device import QolsysZWaveDevice
 from .zwave_dimmer import QolsysDimmer
 from .zwave_generic import QolsysGeneric
 from .zwave_lock import QolsysLock
@@ -22,12 +28,14 @@ from .zwave_thermostat import QolsysThermostat
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+    from .zwave_device import QolsysZWaveDevice
 
-class QolsysPanel(QolsysObservable):
-    def __init__(self, settings: QolsysSettings, state: QolsysState) -> None:
 
-        self._state = state
-        self._settings = settings
+class QolsysPanel(QolsysObservable):
+    def __init__(self, controller: QolsysController) -> None:
+        self._controller = controller
         self._db = QolsysDB()
 
         # Partition settings
@@ -37,73 +45,108 @@ class QolsysPanel(QolsysObservable):
         # Panel settings
         self.settings_panel_observer = QolsysObservable()
         self.settings_panel = [
-            "PANEL_TAMPER_STATE", "AC_STATUS", "BATTERY_STATUS", "FAIL_TO_COMMUNICATE", "SECURE_ARMING", "AUTO_BYPASS",
-            "AUTO_STAY", "AUTO_ARM_STAY", "AUTO_EXIT_EXTENSION", "FINAL_EXIT_DOOR_ARMING", "NO_ARM_LOW_BATTERY",
-            "TEMPFORMAT", "LANGUAGE", "COUNTRY", "SYSTEM_TIME", "GSM_CONNECTION_STATUS", "GSM_SIGNAL_STRENGTH",
-            "ANDROID_VERSION", "HARDWARE_VERSION", "TIMER_NORMAL_ENTRY_DELAY", "TIMER_NORMAL_EXIT_DELAY",
-            "TIMER_LONG_ENTRY_DELAY", "TIMER_LONG_EXIT_DELAY", "ZWAVE_CONTROLLER", "ZWAVE_CARD", "POLICE_PANIC_ENABLED",
-            "FIRE_PANIC_ENABLED", "AUXILIARY_PANIC_ENABLED", "NIGHTMODE_SETTINGS", "NIGHT_SETTINGS_STATE", "PARTITIONS",
-            "SIX_DIGIT_USER_CODE", "SHOW_SECURITY_SENSORS", "SYSTEM_LOGGED_IN_USER", "PANEL_SCENES_SETTING", "CONTROL_4",
-            "ZWAVE_FIRM_WARE_VERSION", "FINAL_EXIT_DOOR_ARMING", "NO_ARM_LOW_BATTERY", "MAC_ADDRESS",
+            "PANEL_TAMPER_STATE",
+            "AC_STATUS",
+            "BATTERY_STATUS",
+            "FAIL_TO_COMMUNICATE",
+            "SECURE_ARMING",
+            "AUTO_BYPASS",
+            "AUTO_STAY",
+            "AUTO_ARM_STAY",
+            "AUTO_EXIT_EXTENSION",
+            "FINAL_EXIT_DOOR_ARMING",
+            "NO_ARM_LOW_BATTERY",
+            "TEMPFORMAT",
+            "LANGUAGE",
+            "COUNTRY",
+            "SYSTEM_TIME",
+            "GSM_CONNECTION_STATUS",
+            "GSM_SIGNAL_STRENGTH",
+            "ANDROID_VERSION",
+            "HARDWARE_VERSION",
+            "TIMER_NORMAL_ENTRY_DELAY",
+            "TIMER_NORMAL_EXIT_DELAY",
+            "TIMER_LONG_ENTRY_DELAY",
+            "TIMER_LONG_EXIT_DELAY",
+            "ZWAVE_CONTROLLER",
+            "ZWAVE_CARD",
+            "POLICE_PANIC_ENABLED",
+            "FIRE_PANIC_ENABLED",
+            "AUXILIARY_PANIC_ENABLED",
+            "NIGHTMODE_SETTINGS",
+            "NIGHT_SETTINGS_STATE",
+            "PARTITIONS",
+            "SIX_DIGIT_USER_CODE",
+            "SHOW_SECURITY_SENSORS",
+            "SYSTEM_LOGGED_IN_USER",
+            "PANEL_SCENES_SETTING",
+            "CONTROL_4",
+            "ZWAVE_FIRM_WARE_VERSION",
+            "FINAL_EXIT_DOOR_ARMING",
+            "NO_ARM_LOW_BATTERY",
+            "MAC_ADDRESS",
             "LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N",
         ]
 
-        self._PANEL_TAMPER_STATE = ""
-        self._AC_STATUS = ""
-        self._BATTERY_STATUS = ""
-        self._FAIL_TO_COMMUNICATE = ""
-        self._SECURE_ARMING = ""
-        self._AUTO_BYPASS = ""
-        self._AUTO_STAY = ""
-        self._AUTO_ARM_STAY = ""
-        self._AUTO_EXIT_EXTENSION = ""
-        self._FINAL_EXIT_DOOR_ARMING = ""
-        self._NO_ARM_LOW_BATTERY = ""
-        self._TEMPFORMAT = ""
-        self._LANGUAGE = ""
-        self._COUNTRY = ""
-        self._SYSTEM_TIME = ""
-        self._GSM_CONNECTION_STATUS = ""
-        self._GSM_SIGNAL_STRENGTH = ""
-        self._ANDROID_VERSION = ""
-        self._HARDWARE_VERSION = ""
-        self._TIMER_NORMAL_ENTRY_DELAY = ""
-        self._TIMER_NORMAL_EXIT_DELAY = ""
-        self._TIMER_LONG_ENTRY_DELAY = ""
-        self._TIMER_LONG_EXIT_DELAY = ""
-        self._ZWAVE_FIRM_WARE_VERSION = ""
-        self._ZWAVE_CONTROLLER = ""
-        self._ZWAVE_CARD = ""
-        self._POLICE_PANIC_ENABLED = ""
-        self._FIRE_PANIC_ENABLED = ""
-        self._AUXILIARY_PANIC_ENABfLED = ""
-        self._NIGHTMODE_SETTINGS = ""
-        self._NIGHT_SETTINGS_STATE = ""
-        self._PARTITIONS = ""
-        self._SIX_DIGIT_USER_CODE = ""
-        self._SHOW_SECURITY_SENSORS = ""
-        self._CONTROL_4 = ""
-        self._MAC_ADDRESS = ""
-        self._SYSTEM_LOGGED_IN_USER = ""
-        self._PANEL_SCENES_SETTING = ""
-        self._LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N = ""
-
-        self._users = []
-        self._unique_id = ""
-
-        self._imei = ""
-        self._product_type = ""
+        self._PANEL_TAMPER_STATE: str = ""
+        self._AC_STATUS: str = ""
+        self._BATTERY_STATUS: str = ""
+        self._FAIL_TO_COMMUNICATE: str = ""
+        self._SECURE_ARMING: str = ""
+        self._AUTO_BYPASS: str = ""
+        self._AUTO_STAY: str = ""
+        self._AUTO_ARM_STAY: str = ""
+        self._AUTO_EXIT_EXTENSION: str = ""
+        self._FINAL_EXIT_DOOR_ARMING: str = ""
+        self._NO_ARM_LOW_BATTERY: str = ""
+        self._TEMPFORMAT: str = ""
+        self._LANGUAGE: str = ""
+        self._COUNTRY: str = ""
+        self._SYSTEM_TIME: str = ""
+        self._GSM_CONNECTION_STATUS: str = ""
+        self._GSM_SIGNAL_STRENGTH: str = ""
+        self._ANDROID_VERSION: str = ""
+        self._HARDWARE_VERSION: str = ""
+        self._TIMER_NORMAL_ENTRY_DELAY: str = ""
+        self._TIMER_NORMAL_EXIT_DELAY: str = ""
+        self._TIMER_LONG_ENTRY_DELAY: str = ""
+        self._TIMER_LONG_EXIT_DELAY: str = ""
+        self._ZWAVE_FIRM_WARE_VERSION: str = ""
+        self._ZWAVE_CONTROLLER: str = ""
+        self._ZWAVE_CARD: str = ""
+        self._POLICE_PANIC_ENABLED: str = ""
+        self._FIRE_PANIC_ENABLED: str = ""
+        self._AUXILIARY_PANIC_ENABfLED: str = ""
+        self._NIGHTMODE_SETTINGS: str = ""
+        self._NIGHT_SETTINGS_STATE: str = ""
+        self._PARTITIONS: str = ""
+        self._SIX_DIGIT_USER_CODE: str = ""
+        self._SHOW_SECURITY_SENSORS: str = ""
+        self._CONTROL_4: str = ""
+        self._MAC_ADDRESS: str = ""
+        self._SYSTEM_LOGGED_IN_USER: str = ""
+        self._PANEL_SCENES_SETTING: str = ""
+        self._LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N: str = ""
+
+        self._users: list[QolsysUser] = []
+        self._unique_id: str = ""
+
+        self._imei: str = ""
+        self._product_type: str = ""
 
     def read_users_file(self) -> bool:
         # Loading user_code data from users.conf file if exists
-        if self._settings.users_file_path.is_file():
+        if self._controller.settings.users_file_path.is_file():
             try:
-                path = self._settings.users_file_path
+                path = self._controller.settings.users_file_path
                 with path.open("r", encoding="utf-8") as file:
                     try:
                         users = json.load(file)
                         for user in users:
-                            self._users.append(user)
+                            qolsys_user = QolsysUser()
+                            qolsys_user.id = user.get("id")
+                            qolsys_user.user_code = user.get("user_code")
+                            self._users.append(qolsys_user)
 
                     except json.JSONDecodeError:
                         LOGGER.exception("users.conf file json error")
@@ -343,22 +386,66 @@ class QolsysPanel(QolsysObservable):
         self._PANEL_SCENES_SETTING = self.db.get_setting_panel("PANEL_SCENES_SETTING")
         return self.PANEL_SCENES_SETTING
 
-    def load_database(self, database: dict) -> None:
+    def load_database(self, database: list[dict[str, Any]]) -> None:
         self.db.load_db(database)
-        self._state.sync_partitions_data(self.get_partitions_from_db())
-        self._state.sync_zones_data(self.get_zones_from_db())
-        self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
-        self._state.sync_scenes_data(self.get_scenes_from_db())
+        self._controller.state.sync_partitions_data(self.get_partitions_from_db())
+        self._controller.state.sync_zones_data(self.get_zones_from_db())
+        self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+        self._controller.state.sync_adc_devices_data(self.get_adc_devices_from_db())
+        self._controller.state.sync_scenes_data(self.get_scenes_from_db())
+        self._controller.state.sync_weather_data(self.get_weather_from_db())
+
+        # Validate all local user match a Qolsys Panel user
+        qolsys_users = self.db.get_users()
+        qolsys_user_list = []
+        for qolsys_user in qolsys_users:
+            try:
+                userid = int(qolsys_user.get("userid", ""))
+            except ValueError:
+                LOGGER.error("Invalid userid in panel database: %s", qolsys_user.get("userid", ""))
+                userid = -1
+
+            qolsys_user_list.append(userid)
+
+        for local_user in self._users:
+            if local_user.id not in qolsys_user_list:
+                LOGGER.error("ID %s from users.conf file not found in panel database", local_user.id)
+
+        # Check associated zone_id in iqremotesettins table
+        LOGGER.debug("Checking iqremotesettings table for zone_id matching panel MAC address")
+        iqremote_settings_list = self.db.get_iqremote_settings()
+        for iqremote in iqremote_settings_list:
+            if (
+                self._controller.settings.random_mac.replace(":", "").lower()
+                == iqremote.get("mac_address", "").replace(":", "").lower()
+            ):
+                self._controller._zone_id = iqremote.get("zone_id", "")
+                LOGGER.debug("Found matching zone_id: %s", self._controller._zone_id)
+                break
+
+    # Parse Z-Wave message
+    def parse_zwave_message(self, data: dict[str, Any]) -> None:
+        zwave = data.get("ZWAVE_RESPONSE", "")
+        payload = base64.b64decode(zwave.get("ZWAVE_PAYLOAD", "")).hex()
+        # LOGGER.debug(
+        #    "Z-Wave Response: Node(%s) - Status(%s) - Payload(%s)",
+        #    zwave.get("NODE_ID", ""),
+        #    zwave.get("ZWAVE_COMMAND_STATUS", ""),
+        #    payload,
+        # )
+
+        node_id: str = str(zwave.get("NODE_ID", 0))
+        node = self._controller.state.zwave_device(node_id)
+        if node is not None:
+            node.update_raw(bytes.fromhex(payload))
 
     # Parse panel update to database
-    def parse_iq2meid_message(self, data: dict) -> bool:  # noqa: C901, PLR0912, PLR0915
-
+    def parse_iq2meid_message(self, data: dict[str, Any]) -> None:  # noqa: C901, PLR0912, PLR0915
         eventName = data.get("eventName")
-        dbOperation = data.get("dbOperation","")
+        dbOperation = data.get("dbOperation", "")
         uri = data.get("uri")
 
         match eventName:
-
             case "stopScreenCapture":
                 pass
 
@@ -366,16 +453,13 @@ class QolsysPanel(QolsysObservable):
                 LOGGER.info("Main Panel Disconnect")
 
             case "dbChanged":
-
                 match dbOperation:
-
                     case "update":
-                        content_values = data.get("contentValues")
+                        content_values = data.get("contentValues", "")
                         selection = data.get("selection")
                         selection_argument = data.get("selectionArgs")
 
                         match uri:
-
                             # Update Settings Content Provider
                             case self.db.table_qolsyssettings.uri:
                                 name = content_values.get("name", "")
@@ -391,7 +475,7 @@ class QolsysPanel(QolsysObservable):
                                 # Update Partition setting - Send notification if setting has changed
                                 if name in self.settings_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "SYSTEM_STATUS":
@@ -407,7 +491,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.update(selection, selection_argument, content_values)
                                 zoneid = content_values.get("zoneid", "")
-                                zone = self._state.zone(zone_id=zoneid)
+                                zone = self._controller.state.zone(zone_id=zoneid)
                                 if zone is not None:
                                     zone.update(content_values)
 
@@ -419,7 +503,7 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_state.update(selection, selection_argument, content_values)
 
                                 if name in self.state_partition:
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "ALARM_STATE":
@@ -428,36 +512,32 @@ class QolsysPanel(QolsysObservable):
                             # Update heat_map
                             case self.db.table_heat_map.uri:
                                 self.db.table_heat_map.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update master_slave
                             case self.db.table_master_slave.uri:
                                 self.db.table_master_slave.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update dashboard_msgs
                             case self.db.table_dashboard_msgs.uri:
                                 self.db.table_dashboard_msgs.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update PartitionContentProvider
                             case self.db.table_partition.uri:
                                 self.db.table_partition.update(selection, selection_argument, content_values)
                                 partition_id = content_values.get("partition_id", "")
-                                partition = self._state.partition(partition_id)
+                                partition = self._controller.state.partition(partition_id)
                                 if partition is not None:
                                     partition.update_partition(content_values)
 
                             # Update History Content Provider
                             case self.db.table_history.uri:
                                 self.db.table_history.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update DimmerLightsContentProvider
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysDimmer):
                                     node.update_dimmer(content_values)
 
@@ -465,7 +545,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysThermostat):
                                     node.update_thermostat(content_values)
 
@@ -473,7 +553,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysLock):
                                     node.update_lock(content_values)
 
@@ -481,19 +561,17 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None:
                                     node.update_base(content_values)
 
                             # Update Z-Wave History Content Provier
                             case self.db.table_zwave_history.uri:
                                 self.db.table_zwave_history.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update AutomationDeviceContentProvider
                             case self.db.table_automation.uri:
                                 self.db.table_automation.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update Alarmed Sensor Content Provider
                             case self.db.table_alarmedsensor.uri:
@@ -502,35 +580,56 @@ class QolsysPanel(QolsysObservable):
                             # Update IQ Remote Settings Content Provider
                             case self.db.table_iqremotesettings.uri:
                                 self.db.table_iqremotesettings.update(selection, selection_argument, content_values)
-                                # No action needed
 
                             # Update Scene Content Provider
                             case self.db.table_scene.uri:
                                 self.db.table_scene.update(selection, selection_argument, content_values)
                                 scene_id = content_values.get("scene_id", "")
-                                scene = self._state.scene(scene_id)
-                                if scene is not None and isinstance(node, QolsysScene):
+                                scene = self._controller.state.scene(scene_id)
+                                if scene is not None and isinstance(scene, QolsysScene):
                                     scene.update(content_values)
 
                             # Update Trouble Conditions
                             case self.db.table_trouble_conditions.uri:
-                                self.db.table_trouble_conditions.update(selection,selection_argument,content_values)
-                                # No action needed
+                                self.db.table_trouble_conditions.update(selection, selection_argument, content_values)
 
                             # Update EU_EVENT:
                             case self.db.table_eu_event.uri:
-                                self.db.table_eu_event.update(selection,selection_argument,content_values)
-                                # No action needed
+                                self.db.table_eu_event.update(selection, selection_argument, content_values)
 
                             # Update PowerG Device
                             case self.db.table_powerg_device.uri:
-                                self.db.table_powerg_device.update(selection,selection_argument,content_values)
+                                self.db.table_powerg_device.update(selection, selection_argument, content_values)
                                 short_id = content_values.get("shortID", "")
-                                zone = self._state.zone_from_short_id(short_id)
+                                zone = self._controller.state.zone_from_short_id(short_id)
                                 if zone is not None:
-                                    LOGGER.debug("iq2meid updating powerg device for zoneid(%s):%s", zone.zone_id,content_values)
                                     zone.update_powerg(content_values)
 
+                            # Update Weather
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.update(selection, selection_argument, content_values)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
+
+                            # Update Zwave Association Group
+                            case self.db.table_zwave_association_goup.uri:
+                                self.db.table_zwave_association_goup.update(selection, selection_argument, content_values)
+
+                            # Update Zwave Other
+                            case self.db.table_zwave_other.uri:
+                                self.db.table_zwave_other.update(selection, selection_argument, content_values)
+
+                            # Country Locale
+                            case self.db.table_country_locale.uri:
+                                self.db.table_country_locale.update(selection, selection_argument, content_values)
+
+                            # Virtual device
+                            case self.db.table_virtual_device.uri:
+                                self.db.table_virtual_device.update(selection, selection_argument, content_values)
+                                adc_id = content_values.get("device_id", "")
+                                adc_device = self._controller.state.adc_device(adc_id)
+                                if adc_device is not None:
+                                    adc_device.update_adc_device(content_values)
+
                             case _:
                                 LOGGER.debug("iq2meid updating unknow uri:%s", uri)
                                 LOGGER.debug(data)
@@ -540,87 +639,89 @@ class QolsysPanel(QolsysObservable):
                         selection_argument = data.get("selectionArgs")
 
                         match uri:
-
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.delete(selection, selection_argument)
-                                self._state.sync_zones_data(self.get_zones_from_db())
-                                # Notify delete zone
+                                self._controller.state.sync_zones_data(self.get_zones_from_db())
 
                             case self.db.table_iqremotesettings.uri:
                                 self.db.table_iqremotesettings.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_state.uri:
                                 self.db.table_state.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_master_slave.uri:
                                 self.db.table_master_slave.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_qolsyssettings.uri:
                                 self.db.table_qolsyssettings.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_alarmedsensor.uri:
                                 self.db.table_alarmedsensor.delete(selection, selection_argument)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_history.uri:
                                 self.db.table_history.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_zwave_history.uri:
                                 self.db.table_zwave_history.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_automation.uri:
                                 self.db.table_automation.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_partition.uri:
                                 self.db.table_partition.delete(selection, selection_argument)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_user.uri:
                                 self.db.table_user.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_dashboard_msgs.uri:
                                 self.db.table_dashboard_msgs.delete(selection, selection_argument)
-                                # No action needed
 
                             case self.db.table_eu_event.uri:
-                                self.db.table_eu_event.delete(selection,selection_argument)
+                                self.db.table_eu_event.delete(selection, selection_argument)
 
                             case self.db.table_powerg_device.uri:
-                                self.db.table_powerg_device.delete(selection,selection_argument)
+                                self.db.table_powerg_device.delete(selection, selection_argument)
+
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.delete(selection, selection_argument)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
+
+                            case self.db.table_zwave_association_goup.uri:
+                                self.db.table_zwave_association_goup.delete(selection, selection_argument)
+
+                            case self.db.table_virtual_device.uri:
+                                self.db.table_virtual_device.delete(selection, selection_argument)
+                                self._controller.state.sync_adc_devices_data(self.get_adc_devices_from_db())
+
+                            case self.db.table_zwave_other.uri:
+                                self.db.table_zwave_other.delete(selection, selection_argument)
 
                             case _:
                                 LOGGER.debug("iq2meid deleting unknown uri:%s", uri)
                                 LOGGER.debug(data)
 
                     case "insert":
-                        content_values = data.get("contentValues")
+                        content_values = data.get("contentValues", {})
 
                         match uri:
-
                             # Inser State Content Provider
                             case self.db.table_state.uri:
                                 self.db.table_state.insert(data=content_values)
@@ -629,16 +730,16 @@ class QolsysPanel(QolsysObservable):
                                 new_value = content_values.get("value", "")
                                 if name in self.state_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "ALARM_STATE":
                                                 partition.alarm_state = PartitionAlarmState(new_value)
 
                             # Inser Partition Content Provider
-                            case self.db.table_partition:
+                            case self.db.table_partition.uri:
                                 self.db.table_partition.insert(data=content_values)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             # Insert Settings Content Provider
                             case self.db.table_qolsyssettings.uri:
@@ -649,7 +750,7 @@ class QolsysPanel(QolsysObservable):
                                 new_value = content_values.get("value", "")
                                 if name in self.settings_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "SYSTEM_STATUS":
@@ -679,62 +780,56 @@ class QolsysPanel(QolsysObservable):
                             # Sensor Content Provider
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.insert(data=content_values)
-                                self._state.sync_zones_data(self.get_zones_from_db())
+                                self._controller.state.sync_zones_data(self.get_zones_from_db())
 
                             # Door Lock Content Provider
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # Dimmer Content Provider
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # Thermostat Content Provider
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # ZWave Node Content Provider
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # HistoryContentProvider
                             case self.db.table_history.uri:
                                 self.db.table_history.insert(data=content_values)
-                                # No action needed
 
                             # AlarmedSensorProvider
                             case self.db.table_alarmedsensor.uri:
-
                                 partition_id = content_values.get("partition_id", "")
                                 self.db.table_alarmedsensor.insert(data=content_values)
 
-                                partition = self._state.partition(partition_id)
+                                partition = self._controller.state.partition(partition_id)
                                 if partition is not None:
                                     partition.append_alarm_type([PartitionAlarmType(content_values.get("sgroup", ""))])
 
                             # IQRemoteSettingsProvider
                             case self.db.table_iqremotesettings.uri:
                                 self.db.table_iqremotesettings.insert(data=content_values)
-                                # No action needed
 
                             # HeatMapContentProvider
                             case self.db.table_heat_map.uri:
                                 self.db.table_heat_map.insert(data=content_values)
-                                # No action needed
 
                             # ZDeviceHistoryContentProvider
                             case self.db.table_zwave_history.uri:
                                 self.db.table_zwave_history.insert(data=content_values)
-                                # No action needed
 
                             # Dashboard Message Content Provider
                             case self.db.table_dashboard_msgs.uri:
                                 self.db.table_dashboard_msgs.insert(data=content_values)
-                                # No action needed
 
                             # EU_EVENT
                             case self.db.table_eu_event.uri:
@@ -744,6 +839,26 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_powerg_device.uri:
                                 self.db.table_powerg_device.insert(data=content_values)
 
+                            # Weather
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.insert(data=content_values)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
+
+                            # ZWave Association Group
+                            case self.db.table_zwave_association_goup.uri:
+                                self.db.table_zwave_association_goup.insert(data=content_values)
+
+                            # Zwave Other
+                            case self.db.table_zwave_other.uri:
+                                self.db.table_zwave_other.insert(data=content_values)
+                                LOGGER.debug("New Z-Wave Other information")
+                                LOGGER.debug(content_values)
+
+                            # Virtual Device
+                            case self.db.table_virtual_device.uri:
+                                self.db.table_virtual_device.insert(data=content_values)
+                                self._controller.state.sync_adc_devices_data(self.get_adc_devices_from_db())
+
                             case _:
                                 LOGGER.debug("iq2meid inserting unknow uri:%s", uri)
                                 LOGGER.debug(data)
@@ -757,24 +872,45 @@ class QolsysPanel(QolsysObservable):
 
     def check_user(self, user_code: str) -> int:
         for user in self._users:
-            if user["user_code"] == user_code:
-                return user["id"]
+            if user.user_code == user_code:
+                return user.id
 
         # No valid user code found
         return -1
 
+    def get_adc_devices_from_db(self) -> list[QolsysAdcDevice]:
+        adc_devices: list[QolsysAdcDevice] = []
+        devices_list = self.db.get_adc_devices()
+
+        for device in devices_list:
+            adc_devices.append(QolsysAdcDevice(device))
+
+        return adc_devices
+
     def get_zwave_devices_from_db(self) -> list[QolsysZWaveDevice]:
-        devices = []
+        devices: list[QolsysZWaveDevice] = []
         devices_list = self.db.get_zwave_devices()
         dimmers_list = self.db.get_dimmers()
         thermostats_list = self.db.get_thermostats()
         locks_list = self.db.get_locks()
 
         for device in devices_list:
-
             device_added = False
-
             zwave_node_id = device.get("node_id", "")
+
+            # Check if z-wave device is an Energy Clamp
+            if device.get("node_type", "") == "Energy Clamp":
+                LOGGER.debug(device)
+                qolsys_meter_device = QolsysEnergyClamp(device)
+                devices.append(qolsys_meter_device)
+                device_added = True
+
+            # Check if z-wave device is a thermometer
+            if device.get("node_type", "") == "Thermometer":
+                qolsys_thermometer = QolsysThermometer(device)
+                devices.append(qolsys_thermometer)
+                device_added = True
+
             # Check if z-wave device is a Dimmer
             for d in dimmers_list:
                 dimmer_node_id = d.get("node_id", "")
@@ -821,7 +957,7 @@ class QolsysPanel(QolsysObservable):
 
     def get_scenes_from_db(self) -> list[QolsysScene]:
         scenes = []
-        scenes_list: list[dict] = self.db.get_scenes()
+        scenes_list: list[dict[str, str]] = self.db.get_scenes()
 
         # Create scenes array
         for scene_info in scenes_list:
@@ -829,17 +965,30 @@ class QolsysPanel(QolsysObservable):
 
         return scenes
 
+    def get_weather_from_db(self) -> QolsysWeather:
+        weather = QolsysWeather()
+        forecast_dic_list: list[dict[str, str]] = self.db.get_weather()
+
+        forecast_obj_list = []
+        for forecast in forecast_dic_list:
+            forecast_obj_list.append(QolsysForecast(forecast))
+
+        # Create weather array
+        weather.update(forecast_obj_list)
+
+        return weather
+
     def get_zones_from_db(self) -> list[QolsysZone]:
         zones = []
-        zones_list: list[dict] = self.db.get_zones()
+        zones_list: list[dict[str, str]] = self.db.get_zones()
 
         # Create sensors array
         for zone_info in zones_list:
-            new_zone = QolsysZone(zone_info,self._settings)
+            new_zone = QolsysZone(zone_info, self._controller.settings)
 
             if new_zone.current_capability == "POWERG":
                 LOGGER.debug("Loading PowerG device info for zone %s", new_zone.zone_id)
-                powerg_dict = self.db.get_powerg(short_id= new_zone.shortID)
+                powerg_dict = self.db.get_powerg(short_id=new_zone.shortID)
                 LOGGER.debug("PowerG device info: %s", powerg_dict)
                 if powerg_dict is not None:
                     new_zone.update_powerg(powerg_dict)
@@ -849,13 +998,11 @@ class QolsysPanel(QolsysObservable):
         return zones
 
     def get_partitions_from_db(self) -> list[QolsysPartition]:
-
         partitions = []
-        partition_list: list[dict] = self.db.get_partitions()
+        partition_list: list[dict[str, str]] = self.db.get_partitions()
 
         # Create partitions array
         for partition_dict in partition_list:
-
             partition_id = partition_dict["partition_id"]
 
             settings_dict = {
@@ -867,10 +1014,7 @@ class QolsysPanel(QolsysObservable):
 
             alarm_type = []
             for alarm in self.db.get_alarm_type(partition_id):
-                if alarm == "":
-                    alarm_type.append(PartitionAlarmType("Police Emergency"))
-                else:
-                    alarm_type.append(PartitionAlarmType(alarm))
+                alarm_type.append(PartitionAlarmType(alarm))
 
             alarm_state = PartitionAlarmState(self.db.get_state_partition("ALARM_STATE", partition_id) or "UNKNOWN")
 
@@ -921,4 +1065,8 @@ class QolsysPanel(QolsysObservable):
 
         LOGGER.debug("Users list:")
         for user in self._users:
-            LOGGER.debug("User: %s", user["id"])
+            LOGGER.debug("User: %s", user.id)
+
+        LOGGER.debug("*** Plugin Information ***")
+        LOGGER.debug("Motion Delay Enabled: %s", self._controller.settings.motion_sensor_delay)
+        LOGGER.debug("Motion Delay Value: %s", self._controller.settings.motion_sensor_delay_sec)