qolsys-controller 0.0.28__py3-none-any.whl → 0.0.51__py3-none-any.whl

qolsys_controller/plugin_remote.py

@@ -1,37 +1,42 @@
+from __future__ import annotations
+
 import asyncio
 import base64
+import contextlib
 import datetime
 import json
 import logging
 import random
 import ssl
 import uuid
+from typing import TYPE_CHECKING
 
+import aiofiles
 import aiomqtt
 
 from .enum import PartitionAlarmState, PartitionSystemStatus
-from .enum_zwave import ThermostatFanMode, ThermostatMode
 from .errors import QolsysMqttError, QolsysSslError
 from .mdns import QolsysMDNS
 from .mqtt_command_queue import QolsysMqttCommandQueue
-from .panel import QolsysPanel
 from .pki import QolsysPKI
 from .plugin import QolsysPlugin
-from .settings import QolsysSettings
-from .state import QolsysState
 from .task_manager import QolsysTaskManager
 from .utils_mqtt import generate_random_mac
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+    from .enum_zwave import ThermostatFanMode, ThermostatMode
+
 
 class QolsysPluginRemote(QolsysPlugin):
 
-    def __init__(self, state: QolsysState, panel: QolsysPanel, settings: QolsysSettings) -> None:
-        super().__init__(state, panel, settings)
+    def __init__(self, controller: QolsysController) -> None:
+        super().__init__(controller=controller)
 
         # PKI
-        self._pki = QolsysPKI(settings=settings)
+        self._pki = QolsysPKI(settings=controller.settings)
         self._auto_discover_pki = True
 
         # Plugin
@@ -82,20 +87,14 @@ class QolsysPluginRemote(QolsysPlugin):
         self._auto_discover_pki = value
 
     def is_paired(self) -> bool:
-        # Check if plugin is paired:
-        # 1- random_mac set
-        # 2- KEY file present
-        # 3- Signed certificate file present
-        # 4- Qolsys certificate present
-        # 5- Qolsys Panel IP present
         return (
             self._pki.id != "" and
             self._pki.check_key_file() and
             self._pki.check_cer_file() and
             self._pki.check_qolsys_cer_file() and
             self._pki.check_secure_file() and
-            self.settings.check_panel_ip() and
-            self.settings.check_plugin_ip()
+            self._controller.settings.check_panel_ip() and
+            self._controller.settings.check_plugin_ip()
         )
 
     async def config(self, start_pairing: bool) -> bool:
@@ -106,24 +105,24 @@ class QolsysPluginRemote(QolsysPlugin):
         super().config()
 
         # Check and created config_directory
-        if not self.settings.check_config_directory(create=start_pairing):
+        if not self._controller.settings.check_config_directory(create=start_pairing):
             return False
 
         # Read user file for access code
         loop = asyncio.get_running_loop()
-        if not loop.run_in_executor(None, self.panel.read_users_file):
+        if not loop.run_in_executor(None, self._controller.panel.read_users_file):
             return False
 
         # Config PKI
         if self._auto_discover_pki:
             if self._pki.auto_discover_pki():
-                self.settings.random_mac = self._pki.formatted_id()
+                self._controller.settings.random_mac = self._pki.formatted_id()
         else:
-            self._pki.set_id(self.settings.random_mac)
+            self._pki.set_id(self._controller.settings.random_mac)
 
         # Set mqtt_remote_client_id
-        self.settings.mqtt_remote_client_id = "qolsys-controller-" + self._pki.formatted_id()
-        LOGGER.debug("Using MQTT remoteClientID: %s", self.settings.mqtt_remote_client_id)
+        self._controller.settings.mqtt_remote_client_id = "qolsys-controller-" + self._pki.formatted_id()
+        LOGGER.debug("Using MQTT remoteClientID: %s", self._controller.settings.mqtt_remote_client_id)
 
         # Check if plugin is paired
         if self.is_paired():
@@ -146,7 +145,7 @@ class QolsysPluginRemote(QolsysPlugin):
         return True
 
     async def start_operation(self) -> None:
-        await self._task_manager.run(self.mqtt_connect_task(reconnect=True), self._mqtt_task_connect_label)
+        await self._task_manager.run(self.mqtt_connect_task(reconnect=True, run_forever=True), self._mqtt_task_connect_label)
 
     async def stop_operation(self) -> None:
         LOGGER.debug("Stopping Plugin Operation")
@@ -166,7 +165,7 @@ class QolsysPluginRemote(QolsysPlugin):
         self.connected = False
         self.connected_observer.notify()
 
-    async def mqtt_connect_task(self, reconnect: bool) -> None:
+    async def mqtt_connect_task(self, reconnect: bool, run_forever: bool) -> None:
         # Configure TLS parameters for MQTT connection
         tls_params = aiomqtt.TLSParameters(
             ca_certs=self._pki.qolsys_cer_file_path,
@@ -179,73 +178,79 @@ class QolsysPluginRemote(QolsysPlugin):
 
         LOGGER.debug("MQTT: Connecting ...")
 
+        self._task_manager.cancel(self._mqtt_task_listen_label)
+        self._task_manager.cancel(self._mqtt_task_ping_label)
+
         while True:
             try:
                 self.aiomqtt = aiomqtt.Client(
-                    hostname=self.settings.panel_ip,
+                    hostname=self._controller.settings.panel_ip,
                     port=8883,
                     tls_params=tls_params,
                     tls_insecure=True,
                     clean_session=True,
-                    timeout=self.settings.mqtt_timeout,
-                    identifier="QolsysController",
+                    timeout=self._controller.settings.mqtt_timeout,
+                    identifier= self._controller.settings.mqtt_remote_client_id,
                 )
 
                 await self.aiomqtt.__aenter__()
 
                 LOGGER.info("MQTT: Client Connected")
 
-                # Subscribe to panel internal databse updates
+                # Subscribe to panel internal database updates
                 await self.aiomqtt.subscribe("iq2meid")
 
-                # Subscribte to MQTT commands response
-                await self.aiomqtt.subscribe("response_" + self.settings.random_mac, qos=self.settings.mqtt_qos)
+                # Subscribte to MQTT private response
+                await self.aiomqtt.subscribe("response_" + self._controller.settings.random_mac, qos=self._controller.settings.mqtt_qos)
 
                 # Subscribe to Z-Wave response
-                await self.aiomqtt.subscribe("ZWAVE_RESPONSE", qos=self.settings.mqtt_qos)
+                await self.aiomqtt.subscribe("ZWAVE_RESPONSE", qos=self._controller.settings.mqtt_qos)
 
                 # Only log all traffic for debug purposes
                 if self.log_mqtt_mesages:
                     # Subscribe to MQTT commands send to panel by other devices
-                    #await self.aiomqtt.subscribe("mastermeid", qos=self.settings.mqtt_qos)
+                    await self.aiomqtt.subscribe("mastermeid", qos=self._controller.settings.mqtt_qos)
 
                     # Subscribe to all topics
-                    await self.aiomqtt.subscribe("#", qos=self.settings.mqtt_qos)
+                    # await self.aiomqtt.subscribe("#", qos=self._controller.settings.mqtt_qos)
 
-                # Start mqtt_listent_task and mqtt_ping_task
-                self._task_manager.cancel(self._mqtt_task_listen_label)
-                self._task_manager.cancel(self._mqtt_task_ping_label)
                 self._task_manager.run(self.mqtt_listen_task(), self._mqtt_task_listen_label)
                 self._task_manager.run(self.mqtt_ping_task(), self._mqtt_task_ping_label)
 
                 response_connect = await self.command_connect()
-                self.panel.imei = response_connect.get("master_imei", "")
-                self.panel.product_type = response_connect.get("primary_product_type", "")
+                self._controller.panel.imei = response_connect.get("master_imei", "")
+                self._controller.panel.product_type = response_connect.get("primary_product_type", "")
 
                 await self.command_pingevent()
-                await self.command_timesync()
                 await self.command_pair_status_request()
 
                 response_database = await self.command_sync_database()
                 LOGGER.debug("MQTT: Updating State from syncdatabase")
-                self.panel.load_database(response_database.get("fulldbdata"))
-                self.panel.dump()
-                self.state.dump()
+                self._controller.panel.load_database(response_database.get("fulldbdata"))
+                self._controller.panel.dump()
+                self._controller.state.dump()
 
                 self.connected = True
                 self.connected_observer.notify()
+
+                if not run_forever:
+                    self.connected = False
+                    self.connected_observer.notify()
+                    self._task_manager.cancel(self._mqtt_task_listen_label)
+                    self._task_manager.cancel(self._mqtt_task_ping_label)
+                    await self.aiomqtt.__aexit__(None,None,None)
+
                 break
 
             except aiomqtt.MqttError as err:
                 # Receive pannel network error
                 self.connected = False
                 self.connected_observer.notify()
-                await self.aiomqtt.__aexit__(None, None, None)
                 self.aiomqtt = None
 
                 if reconnect:
-                    LOGGER.debug("MQTT Error - %s: Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
-                    await asyncio.sleep(self.settings.mqtt_timeout)
+                    LOGGER.debug("MQTT Error - %s: Connect - Reconnecting in %s seconds ...", err, self._controller.settings.mqtt_timeout)
+                    await asyncio.sleep(self._controller.settings.mqtt_timeout)
                 else:
                     raise QolsysMqttError from err
 
@@ -255,16 +260,16 @@ class QolsysPluginRemote(QolsysPlugin):
                 # Pannels need to be re-paired
                 self.connected = False
                 self.connected_observer.notify()
-                await self.aiomqtt.__aexit__(None, None, None)
                 self.aiomqtt = None
                 raise QolsysSslError from err
 
     async def mqtt_ping_task(self) -> None:
         while True:
             if self.aiomqtt is not None and self.connected:
-                await self.command_pingevent()
+                with contextlib.suppress(aiomqtt.MqttError):
+                    await self.command_pingevent()
 
-            await asyncio.sleep(self.settings.mqtt_ping)
+            await asyncio.sleep(self._controller.settings.mqtt_ping)
 
     async def mqtt_listen_task(self) -> None:
         try:
@@ -274,17 +279,15 @@ class QolsysPluginRemote(QolsysPlugin):
                     LOGGER.debug("MQTT TOPIC: %s\n%s", message.topic, message.payload.decode())
 
                 # Panel response to MQTT Commands
-                if message.topic.matches("response_" + self.settings.random_mac):
+                if message.topic.matches("response_" + self._controller.settings.random_mac):
                     data = message.payload.decode()
-                    # data = message.payload.decode().replace("\\\\", "\\")
-                    # data = fix_json_string(data)
                     data = json.loads(data)
                     await self._mqtt_command_queue.handle_response(data)
 
                 # Panel updates to IQ2MEID database
                 if message.topic.matches("iq2meid"):
                     data = json.loads(message.payload.decode())
-                    self.panel.parse_iq2meid_message(data)
+                    self._controller.panel.parse_iq2meid_message(data)
 
                 # Panel Z-Wave response
                 if message.topic.matches("ZWAVE_RESPONSE"):
@@ -293,34 +296,23 @@ class QolsysPluginRemote(QolsysPlugin):
                     decoded_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",""),decoded_payload)
 
-
         except aiomqtt.MqttError as err:
             self.connected = False
             self.connected_observer.notify()
 
-            LOGGER.debug("%s: Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
-            await asyncio.sleep(self.settings.mqtt_timeout)
-            self._task_manager.run(self.mqtt_connect_task(reconnect=True), self._mqtt_task_connect_label)
-
-        except ssl.SSLError as err:
-            # SSL error is and authentication error with invalid certificates en pki
-            # We cannot recover from this error automaticly
-            # Pannels need to be re-paired
-            self.connected = False
-            self.connected_observer.notify()
-            await self.aiomqtt.__aexit__(None, None, None)
-            self.aiomqtt = None
-            raise QolsysSslError from err
+            LOGGER.debug("%s: Listen - Reconnecting in %s seconds ...", err, self._controller.settings.mqtt_timeout)
+            await asyncio.sleep(self._controller.settings.mqtt_timeout)
+            self._task_manager.run(self.mqtt_connect_task(reconnect=True, run_forever=True), self._mqtt_task_connect_label)
 
     async def start_initial_pairing(self) -> bool:
         # check if random_mac exist
-        if self.settings.random_mac == "":
+        if self._controller.settings.random_mac == "":
             LOGGER.debug("Creating random_mac")
-            self.settings.random_mac = generate_random_mac()
-            self._pki.create(self.settings.random_mac, key_size=self.settings.key_size)
+            self._controller.settings.random_mac = generate_random_mac()
+            self._pki.create(self._controller.settings.random_mac, key_size=self._controller.settings.key_size)
 
         # Check if PKI is valid
-        self._pki.set_id(self.settings.random_mac)
+        self._pki.set_id(self._controller.settings.random_mac)
         LOGGER.debug("Checking PKI")
         if not (
             self._pki.check_key_file() and
@@ -332,19 +324,19 @@ class QolsysPluginRemote(QolsysPlugin):
 
         LOGGER.debug("Starting Pairing Process")
 
-        if not self.settings.check_plugin_ip():
+        if not self._controller.settings.check_plugin_ip():
             LOGGER.error("Plugin IP Address not configured")
             return False
 
         # If we dont allready have client signed certificate, start the pairing server
-        if not self._pki.check_secure_file() or not self._pki.check_qolsys_cer_file() or not self.settings.check_panel_ip():
+        if not self._pki.check_secure_file() or not self._pki.check_qolsys_cer_file() or not self._controller.settings.check_panel_ip():
 
             # High Level Random Pairing Port
             pairing_port = random.randint(50000, 55000)
 
             # Start Pairing mDNS Brodcast
-            LOGGER.debug("Starting mDNS Service Discovery: %s:%s", self.settings.plugin_ip, str(pairing_port))
-            mdns_server = QolsysMDNS(self.settings.plugin_ip, pairing_port)
+            LOGGER.debug("Starting mDNS Service Discovery: %s:%s", self._controller.settings.plugin_ip, str(pairing_port))
+            mdns_server = QolsysMDNS(self._controller.settings.plugin_ip, pairing_port)
             await mdns_server.start_mdns()
 
             # Start Key Exchange Server
@@ -352,8 +344,7 @@ class QolsysPluginRemote(QolsysPlugin):
             context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
             context.load_cert_chain(certfile=self._pki.cer_file_path, keyfile=self._pki.key_file_path)
             self.certificate_exchange_server = await asyncio.start_server(self.handle_key_exchange_client,
-                                                                          self.settings.plugin_ip, pairing_port, ssl=context)
-
+                                                                          self._controller.settings.plugin_ip, pairing_port, ssl=context)
             LOGGER.debug("Certificate Exchange Server Waiting for Panel")
             LOGGER.debug("Press Pair Button in IQ Remote Config Page ...")
 
@@ -363,6 +354,7 @@ class QolsysPluginRemote(QolsysPlugin):
 
                 except asyncio.CancelledError:
                     LOGGER.debug("Stoping Certificate Exchange Server")
+                    await self.certificate_exchange_server.wait_closed()
                     LOGGER.debug("Stoping mDNS Service Discovery")
                     await mdns_server.stop_mdns()
 
@@ -370,19 +362,16 @@ class QolsysPluginRemote(QolsysPlugin):
 
         # We have client sgined certificate at this point
         # Connect to Panel MQTT to send pairing command
-        await self._task_manager.run(self.mqtt_connect_task(reconnect=False), self._mqtt_task_connect_label)
+        await self._task_manager.run(self.mqtt_connect_task(reconnect=False, run_forever=False), self._mqtt_task_connect_label)
         LOGGER.debug("Plugin Pairing Completed ")
         return True
 
-    async def handle_key_exchange_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+    async def handle_key_exchange_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:  # noqa: PLR0915
 
         received_panel_mac = False
         received_signed_client_certificate = False
         received_qolsys_cer = False
 
-        signed_certificate_data = ""
-        qolsys_certificate_data = ""
-
         try:
             continue_pairing = True
             while continue_pairing:
@@ -398,19 +387,19 @@ class QolsysPluginRemote(QolsysPlugin):
                     LOGGER.debug("Receiving from Panel: %s", mac)
 
                     # Remove \x00 and \x01 from received string
-                    self.settings.panel_mac = "".join(char for char in mac if char.isprintable())
-                    self.settings.panel_ip = address
+                    self._controller.settings.panel_mac = "".join(char for char in mac if char.isprintable())
+                    self._controller.settings.panel_ip = address
                     received_panel_mac = True
 
                     # Sending random_mac to panel
-                    message = b"\x00\x11" + self.settings.random_mac.encode()
+                    message = b"\x00\x11" + self._controller.settings.random_mac.encode()
                     LOGGER.debug("Sending to Panel: %s", message.decode())
                     writer.write(message)
                     await writer.drain()
 
                     # Sending CSR File to panel
-                    with open(self._pki.csr_file_path, "rb") as file:
-                        content = file.read()
+                    async with aiofiles.open(self._pki.csr_file_path, mode="rb") as f:
+                        content = await f.read()
                         LOGGER.debug("Sending to Panel: [CSR File Content]")
                         writer.write(content)
                         writer.write(b"sent")
@@ -420,36 +409,26 @@ class QolsysPluginRemote(QolsysPlugin):
 
                 # Read signed certificate data
                 if (received_panel_mac and not received_signed_client_certificate and not received_qolsys_cer):
+                    request = await reader.readuntil(b"sent")
+                    if request.endswith(b"sent"):
+                        request = request[:-4]
 
-                    request = (await reader.readline())
-                    signed_certificate_data += request.decode()
-
-                    if "sent" in request.decode():
-                        certificates = [item for item in signed_certificate_data.split("sent") if item]
-                        LOGGER.debug("Saving [Signed Client Certificate]")
-                        with open(self._pki.secure_file_path, "wb") as f:
-                            f.write(certificates[0].encode())
-                            received_signed_client_certificate = True
-
-                        if len(certificates) > 1:
-                            qolsys_certificate_data += certificates[1]
+                    LOGGER.debug("Saving [Signed Client Certificate]")
+                    async with aiofiles.open(self._pki.secure_file_path, mode="wb") as f:
+                        await f.write(request)
+                        received_signed_client_certificate = True
 
                 # Read qolsys certificate data
                 if (received_panel_mac and received_signed_client_certificate and not received_qolsys_cer):
-
-                    request = (await reader.readline())
-                    qolsys_certificate_data += request.decode()
-
-                    if "sent" in request.decode():
+                    request = await reader.readuntil(b"sent")
+                    if request.endswith(b"sent"):
+                        request = request[:-4]
+
+                    LOGGER.debug("Saving [Qolsys Certificate]")
+                    async with aiofiles.open(self._pki.qolsys_cer_file_path, mode="wb") as f:
+                        await f.write(request)
+                        received_qolsys_cer = True
                         continue_pairing = False
-                        certificates = [item for item in qolsys_certificate_data.split("sent") if item]
-
-                        LOGGER.debug("Saving [Qolsys Certificate]")
-                        with open(self._pki.qolsys_cer_file_path, "w") as f:
-                            f.write(certificates[0])
-                            received_qolsys_cer = True
-                            continue_pairing = False
-                            writer.close()
 
                     continue
 
@@ -461,6 +440,7 @@ class QolsysPluginRemote(QolsysPlugin):
 
         finally:
             writer.close()
+            await writer.wait_closed()
             self.certificate_exchange_server.close()
 
     async def send_command(self, topic: str, json_payload: str, request_id: str) -> dict:
@@ -468,17 +448,17 @@ class QolsysPluginRemote(QolsysPlugin):
             LOGGER.error("MQTT Client not configured")
             raise QolsysMqttError
 
-        await self.aiomqtt.publish(topic=topic, payload=json.dumps(json_payload), qos=self.settings.mqtt_qos)
+        await self.aiomqtt.publish(topic=topic, payload=json.dumps(json_payload), qos=self._controller.settings.mqtt_qos)
         return await self._mqtt_command_queue.wait_for_response(request_id)
 
     async def command_connect(self) -> dict:
         LOGGER.debug("MQTT: Sending connect command")
 
         topic = "mastermeid"
-        ipAddress = self.settings.plugin_ip
+        ipAddress = self._controller.settings.plugin_ip
         eventName = "connect_v204"
-        macAddress = self.settings.random_mac
-        remoteClientID = self.settings.mqtt_remote_client_id
+        macAddress = self._controller.settings.random_mac
+        remoteClientID = self._controller.settings.mqtt_remote_client_id
         softwareVersion = "4.4.1"
         producType = "tab07_rk68"
         bssid = ""
@@ -497,8 +477,8 @@ class QolsysPluginRemote(QolsysPlugin):
         remote_panel_plugged = 1
         remote_panel_battery_temperature = 430
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         dhcpInfo = {
             "ipaddress": "",
@@ -548,9 +528,9 @@ class QolsysPluginRemote(QolsysPlugin):
 
         topic = "mastermeid"
         eventName = "pingevent"
-        macAddress = self.settings.random_mac
+        macAddress = self._controller.settings.random_mac
         remote_panel_status = "Active"
-        ipAddress = self.settings.plugin_ip
+        ipAddress = self._controller.settings.plugin_ip
         current_battery_status = "Normal"
         remote_panel_battery_percentage = 100
         remote_panel_battery_temperature = 430
@@ -563,8 +543,8 @@ class QolsysPluginRemote(QolsysPlugin):
         remote_panel_battery_health = 2
         remote_panel_plugged = 1
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -597,8 +577,8 @@ class QolsysPluginRemote(QolsysPlugin):
         eventName = "timeSync"
         startTimestamp = datetime.datetime.now().timestamp()
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -617,8 +597,8 @@ class QolsysPluginRemote(QolsysPlugin):
         topic = "mastermeid"
         eventName = "syncdatabase"
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -637,8 +617,8 @@ class QolsysPluginRemote(QolsysPlugin):
         topic = "mastermeid"
         eventName = "acStatus"
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
         acStatus = "Connected"
 
         payload = {"eventName": eventName,
@@ -655,8 +635,8 @@ class QolsysPluginRemote(QolsysPlugin):
         topic = "mastermeid"
         eventName = "dealerLogo"
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -672,9 +652,9 @@ class QolsysPluginRemote(QolsysPlugin):
 
         topic = "mastermeid"
         eventName = "pair_status_request"
-        remoteMacAddress = self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -691,9 +671,9 @@ class QolsysPluginRemote(QolsysPlugin):
 
         topic = "mastermeid"
         eventName = "disconnect"
-        remoteClientID = self.settings.mqtt_remote_client_id
+        remoteClientID = self._controller.settings.mqtt_remote_client_id
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -710,9 +690,9 @@ class QolsysPluginRemote(QolsysPlugin):
         topic = "mastermeid"
         eventName = "connect_v204"
         pairing_request = True
-        ipAddress = self.settings.plugin_ip
-        macAddress = self.settings.random_mac
-        remoteClientID = self.settings.mqtt_remote_client_id
+        ipAddress = self._controller.settings.plugin_ip
+        macAddress = self._controller.settings.random_mac
+        remoteClientID = self._controller.settings.mqtt_remote_client_id
         softwareVersion = "4.4.1"
         productType = "tab07_rk68"
         bssid = ""
@@ -720,8 +700,8 @@ class QolsysPluginRemote(QolsysPlugin):
         dealerIconsCheckSum = ""
         remote_feature_support_version = "1"
         requestID = str(uuid.uuid4())
-        responseTopic = "response_" + self.settings.random_mac
-        remoteMacAddress = self.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
 
         dhcpInfo = {
             "ipaddress": "",
@@ -759,7 +739,7 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT: Sending ui_delay command")
 
         # partition state needs to be sent for ui_delay to work
-        partition = self.state.partition(partition_id)
+        partition = self._controller.state.partition(partition_id)
 
         arming_command = {
             "operation_name": "ui_delay",
@@ -768,7 +748,7 @@ class QolsysPluginRemote(QolsysPlugin):
             "partitionID": partition_id,  # STR EXPECTED
             "silentDisarming":silent_disarming,
             "operation_source": 1,
-            "macAddress": self.settings.random_mac,
+            "macAddress": self._controller.settings.random_mac,
         }
 
         topic = "mastermeid"
@@ -777,8 +757,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQInternalService"
         ipcTransactionID = 7
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -798,7 +778,7 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT: Receiving ui_delay command")
 
     async def command_disarm(self, partition_id: str, user_code: str = "", silent_disarming: bool = False) -> bool:
-        partition = self.state.partition(partition_id)
+        partition = self._controller.state.partition(partition_id)
         if not partition:
             LOGGER.debug("MQTT: disarm command error - Unknow Partition")
             return False
@@ -806,7 +786,7 @@ class QolsysPluginRemote(QolsysPlugin):
         # Do local user code verification
         user_id = 1
         if self.check_user_code_on_disarm:
-            user_id = self.panel.check_user(user_code)
+            user_id = self._controller.panel.check_user(user_code)
             if user_id == -1:
                 LOGGER.debug("MQTT: disarm command error - user_code error")
                 return False
@@ -834,7 +814,7 @@ class QolsysPluginRemote(QolsysPlugin):
             "userID": user_id,
             "partitionID": int(partition_id),  # INT EXPECTED
             "operation_source": 1,
-            "macAddress": self.settings.random_mac,
+            "macAddress": self._controller.settings.random_mac,
         }
 
         topic = "mastermeid"
@@ -843,8 +823,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQInternalService"
         ipcTransactionID = 7
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {"eventName": eventName,
                    "ipcServiceName": ipcServiceName,
@@ -867,10 +847,10 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT: Sending zwave_doorlock_set command: EXPERIMENTAL")
         LOGGER.debug("MQTT: Sending zwave_doorlock_set command - Node(%s) - Locked(%s)",node_id,locked)
 
-        command = 68
+        command = 98
 
         # 0 unlocked
-        # 255 lockeck
+        # 255 locked
         lock_mode = 0
         if locked:
             lock_mode = 255
@@ -885,7 +865,7 @@ class QolsysPluginRemote(QolsysPlugin):
             },
             {
                 "dataType": "byteArray",
-                "dataValue": [command,lock_mode],
+                "dataValue": [command,1,lock_mode],
             },
             {
                 "dataType": "int",
@@ -907,8 +887,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -927,7 +907,7 @@ class QolsysPluginRemote(QolsysPlugin):
     async def command_zwave_thermostat_setpoint_set(self, node_id: int, mode:ThermostatMode, setpoint:float) -> None:
         # Command 67
         LOGGER.debug("MQTT: Sending zwave_thermostat_setpoint_set command: EXPERIMENTAL")
-        LOGGER.debug("MQTT: Sending zwave_thermostat_setpoint_set command")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_setpoint_set - Node(%s) - Mode(%s) - Setpoint(%s)",node_id,mode,setpoint)
         ipcRequest = [{
                 "dataType": "int",
                 "dataValue": node_id,
@@ -960,8 +940,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {"eventName": eventName,
                    "ipcServiceName": ipcServiceName,
@@ -978,7 +958,7 @@ class QolsysPluginRemote(QolsysPlugin):
     async def command_zwave_thermostat_mode_set(self, node_id: int, mode:ThermostatMode) -> None:
         # Command 64
         LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command: EXPERIMENTAL")
-        LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command - Node(%s) - Mode(%s)",node_id,mode)
         ipcRequest = [{
                 "dataType": "int",
                 "dataValue": node_id,
@@ -1011,8 +991,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -1022,7 +1002,7 @@ class QolsysPluginRemote(QolsysPlugin):
             "ipcRequest": ipcRequest,
             "requestID": requestID,
             "responseTopic": responseTopic,
-            "remoteMacAddress": remoteMacAddress
+            "remoteMacAddress": remoteMacAddress,
         }
 
         await self.send_command(topic, payload, requestID)
@@ -1031,7 +1011,7 @@ class QolsysPluginRemote(QolsysPlugin):
     async def command_zwave_thermostat_fan_mode_set(self, node_id: int, fan_mode:ThermostatFanMode) -> None:
         # Command 68
         LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command: EXPERIMENTAL")
-        LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command")
+        LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command - Node(%s) - FanMode(%s)",node_id,fan_mode)
         ipcRequest = [{
                 "dataType": "int",
                 "dataValue": node_id,
@@ -1064,8 +1044,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {"eventName": eventName,
                    "ipcServiceName": ipcServiceName,
@@ -1080,7 +1060,7 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT: Receiving zwave_thermostat_fan_mode_set command")
 
     async def command_zwave_switch_multi_level(self, node_id: int, level: int) -> None:
-        LOGGER.debug("MQTT: Sending zwave_switch_multi_level command")
+        LOGGER.debug("MQTT: Sending zwave_switch_multi_level command  - Node(%s) - Level(%s)",node_id,level)
         ipcRequest = [{
                 "dataType": "int",  # Node ID
                 "dataValue": node_id,
@@ -1114,8 +1094,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {"eventName": eventName,
                    "ipcServiceName": ipcServiceName,
@@ -1168,8 +1148,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQZwaveService"
         ipcTransactionID = 47
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {"eventName": eventName,
                    "ipcServiceName": ipcServiceName,
@@ -1184,22 +1164,22 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT:Receiving zwave_switch_binary command")
 
 
-    async def command_arm(self, partition_id: str, arming_type: str, user_code: str = "", exit_sounds: bool = False,
-                          instant_arm: bool = False) -> bool:
+    async def command_arm(self, partition_id: str, arming_type: str, user_code: str = "", exit_sounds: bool = False,  # noqa: PLR0913
+                          instant_arm: bool = False, entry_delay: bool = True) -> bool:
 
-        LOGGER.debug("MQTT: Sending arm command: partition%s, arming_type:%s, secure_arm:%s",
-                     partition_id, arming_type, self.panel.SECURE_ARMING)
+        LOGGER.debug("MQTT: Sending arm command: partition%s, arming_type:%s, exit_sounds:%s, instant_arm: %s, entry_delay:%s",
+                     partition_id, arming_type,exit_sounds,instant_arm,entry_delay)
 
         user_id = 0
 
-        partition = self.state.partition(partition_id)
+        partition = self._controller.state.partition(partition_id)
         if not partition:
             LOGGER.debug("MQTT: arm command error - Unknow Partition")
             return False
 
-        if self.panel.SECURE_ARMING == "true" and self.check_user_code_on_arm:
+        if self._controller.panel.SECURE_ARMING == "true" and self.check_user_code_on_arm:
             # Do local user code verification to arm if secure arming is enabled
-            user_id = self.panel.check_user(user_code)
+            user_id = self._controller.panel.check_user(user_code)
             if user_id == -1:
                 LOGGER.debug("MQTT: arm command error - user_code error")
                 return False
@@ -1223,19 +1203,23 @@ class QolsysPluginRemote(QolsysPlugin):
         if not exit_sounds:
             exitSoundValue = "OFF"
 
+        entryDelay = "ON"
+        if not entry_delay:
+            entryDelay = "OFF"
+
         arming_command = {
             "operation_name": mqtt_arming_type,
             "bypass_zoneid_set": "[]",
             "userID": user_id,
             "partitionID": int(partition_id),
             "exitSoundValue":  exitSoundValue,
-            "entryDelayValue": "OFF",
+            "entryDelayValue": entryDelay,
             "multiplePartitionsSelected": False,
             "instant_arming": instant_arm,
             "final_exit_arming_selected": False,
             "manually_selected_zones": "[]",
             "operation_source": 1,
-            "macAddress": self.settings.random_mac,
+            "macAddress": self._controller.settings.random_mac,
         }
 
         topic = "mastermeid"
@@ -1244,8 +1228,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQInternalService"
         ipcTransactionID = 7
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,
@@ -1268,7 +1252,7 @@ class QolsysPluginRemote(QolsysPlugin):
     async def command_execute_scene(self,scene_id:str) -> bool:
         LOGGER.debug("MQTT: Sending execute_scene command")
 
-        scene = self.state.scene(scene_id)
+        scene = self._controller.state.scene(scene_id)
         if not scene:
             LOGGER.debug("MQTT: command_execute_scene Erro - Unknow Scene: %s", scene_id)
             return False
@@ -1277,7 +1261,7 @@ class QolsysPluginRemote(QolsysPlugin):
             "operation_name": "execute_scene",
             "scene_id": scene.scene_id,
             "operation_source": 1,
-            "macAddress": self.settings.random_mac,
+            "macAddress": self._controller.settings.random_mac,
         }
 
         topic = "mastermeid"
@@ -1286,8 +1270,8 @@ class QolsysPluginRemote(QolsysPlugin):
         ipcInterfaceName = "android.os.IQInternalService"
         ipcTransactionID = 7
         requestID = str(uuid.uuid4())
-        remoteMacAddress = self.settings.random_mac
-        responseTopic = "response_" + self.settings.random_mac
+        remoteMacAddress = self._controller.settings.random_mac
+        responseTopic = "response_" + self._controller.settings.random_mac
 
         payload = {
             "eventName": eventName,