qolsys-controller 0.0.38__py3-none-any.whl → 0.0.62__py3-none-any.whl

qolsys_controller/panel.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import json
 import logging
+from typing import TYPE_CHECKING, Any
 
 from .database.db import QolsysDB
 from .enum import (
@@ -10,10 +13,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
@@ -21,12 +23,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
@@ -36,73 +40,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")
@@ -342,22 +381,21 @@ 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_scenes_data(self.get_scenes_from_db())
+        self._controller.state.sync_weather_data(self.get_weather_from_db())
 
     # 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
 
@@ -365,16 +403,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", "")
@@ -390,7 +425,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":
@@ -406,7 +441,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(zoneid)
+                                zone = self._controller.state.zone(zone_id=zoneid)
                                 if zone is not None:
                                     zone.update(content_values)
 
@@ -418,7 +453,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":
@@ -427,36 +462,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)
 
@@ -464,7 +495,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)
 
@@ -472,7 +503,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)
 
@@ -480,19 +511,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:
@@ -501,21 +530,39 @@ 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:
-                                self.db.table_trouble_conditions.update(selection,selection_argument,content_values)
-                                # No action needed
+                            case self.db.table_trouble_conditions.uri:
+                                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)
+
+                            # Update PowerG Device
+                            case self.db.table_powerg_device.uri:
+                                self.db.table_powerg_device.update(selection, selection_argument, content_values)
+                                short_id = content_values.get("shortID", "")
+                                zone = self._controller.state.zone_from_short_id(short_id)
+                                if zone is not None:
+                                    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)
 
                             case _:
                                 LOGGER.debug("iq2meid updating unknow uri:%s", uri)
@@ -526,81 +573,82 @@ 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)
+
+                            case self.db.table_powerg_device.uri:
+                                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 _:
                                 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)
@@ -609,16 +657,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:
@@ -629,7 +677,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":
@@ -659,62 +707,72 @@ 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:
+                                self.db.table_eu_event.insert(data=content_values)
+
+                            # PowerG Device
+                            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())
+
+                            case self.db.table_zwave_association_goup.uri:
+                                self.db.table_zwave_association_goup.insert(data=content_values)
 
                             case _:
                                 LOGGER.debug("iq2meid inserting unknow uri:%s", uri)
@@ -729,21 +787,20 @@ 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_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", "")
@@ -793,7 +850,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:
@@ -801,24 +858,44 @@ 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:
-            zones.append(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)
+                LOGGER.debug("PowerG device info: %s", powerg_dict)
+                if powerg_dict is not None:
+                    new_zone.update_powerg(powerg_dict)
+
+            zones.append(new_zone)
 
         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 = {
@@ -884,4 +961,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)