@switchbot/homebridge-switchbot 3.7.1-beta.1 → 3.7.1-beta.11

package/dist/platform.js

@@ -40,6 +40,10 @@ import { readFileSync, writeFileSync } from 'fs';
 import { EveHomeKitTypes } from 'homebridge-lib/EveHomeKitTypes';
 import { PLATFORM_NAME, PLUGIN_NAME, Devices, deleteWebhook, queryWebhook, setupWebhook, updateWebhook } from './settings.js';
 import { isBlindTiltDevice, isCurtainDevice, sleep } from './utils.js';
+/*
+* For Testing Locally:
+* import { SwitchBotModel } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
+*/
 import { SwitchBotModel } from 'node-switchbot';
 /**
  * HomebridgePlatform
@@ -47,9 +51,11 @@ import { SwitchBotModel } from 'node-switchbot';
  * parse the user config and discover/register accessories with Homebridge.
  */
 export class SwitchBotPlatform {
-    accessories;
+    // Platform properties
+    accessories = [];
     api;
     log;
+    // Configuration properties
     version;
     Logging;
     debugMode;
@@ -58,15 +64,16 @@ export class SwitchBotPlatform {
     platformConfig;
     platformLogging;
     config;
+    // MQTT and Webhook properties
     mqttClient = null;
     webhookEventListener = null;
+    // External APIs
     eve;
     fakegatoAPI;
+    // Event Handlers
     webhookEventHandler = {};
     bleEventHandler = {};
     constructor(log, config, api) {
-        // initialize
-        this.accessories = [];
         this.api = api;
         this.log = log;
         // only load if configured
@@ -104,27 +111,42 @@ export class SwitchBotPlatform {
         // in order to ensure they weren't added to homebridge already. This event can also be used
         // to start discovery of new accessories.
         this.api.on('didFinishLaunching', async () => {
-            this.debugLog('Executed didFinishLaunching callback');
+            await this.debugLog('Executed didFinishLaunching callback');
             // run the method to discover / register your devices as accessories
             try {
                 if (this.config.credentials?.openToken && !this.config.credentials.token) {
                     await this.updateToken();
                 }
                 else if (this.config.credentials?.token && !this.config.credentials?.secret) {
-                    this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
+                    await this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
                 }
                 else {
-                    this.discoverDevices();
+                    await this.discoverDevices();
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+                await this.errorLog(`Failed to Discover, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
                 await this.debugErrorLog(`Failed to Discover, Error: ${e}`);
             }
         });
-        this.setupMqtt();
-        this.setupwebhook();
-        this.setupBlE();
+        try {
+            this.setupMqtt();
+        }
+        catch (e) {
+            this.errorLog(`Setup MQTT, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+        }
+        try {
+            this.setupwebhook();
+        }
+        catch (e) {
+            this.errorLog(`Setup Webhook, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+        }
+        try {
+            this.setupBlE();
+        }
+        catch (e) {
+            this.errorLog(`Setup Platform BLE, Error Message: ${e.message}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+        }
     }
     async setupMqtt() {
         if (this.config.options?.mqttURL) {
@@ -141,7 +163,7 @@ export class SwitchBotPlatform {
                     this.mqttClient.subscribe('homebridge-switchbot/webhook/+');
                     this.mqttClient.on('message', async (topic, message) => {
                         try {
-                            await await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
+                            await this.debugLog(`Received Webhook via MQTT: ${topic}=${message}`);
                             const context = JSON.parse(message.toString());
                             this.webhookEventHandler[context.deviceMac]?.(context);
                         }
@@ -173,17 +195,14 @@ export class SwitchBotPlatform {
                                     const body = JSON.parse(data);
                                     await this.debugLog(`Received Webhook: ${JSON.stringify(body)}`);
                                     if (this.config.options?.mqttURL) {
-                                        const mac = body.context.deviceMac
-                                            ?.toLowerCase()
-                                            .match(/[\s\S]{1,2}/g)
-                                            ?.join(':');
+                                        const mac = body.context.deviceMac?.toLowerCase().match(/[\s\S]{1,2}/g)?.join(':');
                                         const options = this.config.options?.mqttPubOptions || {};
                                         this.mqttClient?.publish(`homebridge-switchbot/webhook/${mac}`, `${JSON.stringify(body.context)}`, options);
                                     }
                                     this.webhookEventHandler[body.context.deviceMac]?.(body.context);
                                 }
                                 catch (e) {
-                                    this.errorLog(`Failed to handle webhook event. Error:${e}`);
+                                    await this.errorLog(`Failed to handle webhook event. Error:${e}`);
                                 }
                             });
                             response.writeHead(200, { 'Content-Type': 'text/plain' });
@@ -200,7 +219,7 @@ export class SwitchBotPlatform {
                 }).listen(port ? port : 80);
             }
             catch (e) {
-                this.errorLog(`Failed to create webhook listener. Error:${e.message}`);
+                await this.errorLog(`Failed to create webhook listener. Error:${e.message}`);
                 return;
             }
             try {
@@ -214,16 +233,14 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                await this.debugLog(`setupWebhook: url:${url}`);
-                await this.debugLog(`setupWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`setupWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`setupWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
-                    this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} `
+                    await this.errorLog(`Failed to configure webhook. Existing webhook well be overridden. HTTP:${statusCode} API:${response?.statusCode} `
                         + `message:${response?.message}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to configure webhook. Error: ${e.message}`);
+                await this.errorLog(`Failed to configure webhook. Error: ${e.message}`);
             }
             try {
                 const { body, statusCode } = await request(updateWebhook, {
@@ -236,15 +253,13 @@ export class SwitchBotPlatform {
                     }),
                 });
                 const response = await body.json();
-                await this.debugLog(`updateWebhook: url:${url}`);
-                await this.debugLog(`updateWebhook: body:${JSON.stringify(response)}`);
-                await this.debugLog(`updateWebhook: statusCode:${statusCode}`);
+                await this.debugLog(`updateWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
-                    this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
+                    await this.errorLog(`Failed to update webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to update webhook. Error:${e.message}`);
+                await this.errorLog(`Failed to update webhook. Error:${e.message}`);
             }
             try {
                 const { body, statusCode } = await request(queryWebhook, {
@@ -258,14 +273,14 @@ export class SwitchBotPlatform {
                 await this.debugLog(`queryWebhook: body:${JSON.stringify(response)}`);
                 await this.debugLog(`queryWebhook: statusCode:${statusCode}`);
                 if (statusCode !== 200 || response?.statusCode !== 100) {
-                    this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
+                    await this.errorLog(`Failed to query webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                 }
                 else {
-                    this.infoLog(`Listening webhook on ${response?.body?.urls[0]}`);
+                    await this.infoLog(`Listening webhook on ${response?.body?.urls[0]}`);
                 }
             }
             catch (e) {
-                this.errorLog(`Failed to query webhook. Error:${e}`);
+                await this.errorLog(`Failed to query webhook. Error:${e}`);
             }
             this.api.on('shutdown', async () => {
                 try {
@@ -280,14 +295,14 @@ export class SwitchBotPlatform {
                     const response = await body.json();
                     await this.debugLog(`deleteWebhook: url:${url}, body:${JSON.stringify(response)}, statusCode:${statusCode}`);
                     if (statusCode !== 200 || response?.statusCode !== 100) {
-                        this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
+                        await this.errorLog(`Failed to delete webhook. HTTP:${statusCode} API:${response?.statusCode} message:${response?.message}`);
                     }
                     else {
-                        this.infoLog('Unregistered webhook to close listening.');
+                        await this.infoLog('Unregistered webhook to close listening.');
                     }
                 }
                 catch (e) {
-                    this.errorLog(`Failed to delete webhook. Error:${e.message}`);
+                    await this.errorLog(`Failed to delete webhook. Error:${e.message}`);
                 }
             });
         }
@@ -319,10 +334,10 @@ export class SwitchBotPlatform {
                 this.api.on('shutdown', async () => {
                     try {
                         switchbot.stopScan();
-                        this.infoLog('Stopped BLE scanning to close listening.');
+                        await this.infoLog('Stopped BLE scanning to close listening.');
                     }
                     catch (e) {
-                        this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message}`);
+                        await this.errorLog(`Failed to stop Platform BLE scanning. Error:${e.message}`);
                     }
                 });
             }
@@ -336,7 +351,8 @@ export class SwitchBotPlatform {
      * It should be used to setup event handlers for characteristics and update respective values.
      */
     async configureAccessory(accessory) {
-        await this.debugLog(`Loading accessory from cache: ${accessory.displayName}`);
+        const { displayName } = accessory;
+        await this.debugLog(`Loading accessory from cache: ${displayName}`);
         // add the restored accessory to the accessories cache so we can track if it has already been registered
         this.accessories.push(accessory);
     }
@@ -344,7 +360,7 @@ export class SwitchBotPlatform {
      * Verify the config passed to the plugin is valid
      */
     async verifyConfig() {
-        this.debugLog('Verifying Config');
+        await this.debugLog('Verifying Config');
         this.config = this.config || {};
         this.config.options = this.config.options || {};
         const platformConfig = {};
@@ -379,10 +395,10 @@ export class SwitchBotPlatform {
                 for (const irDeviceConfig of this.config.options.irdevices) {
                     if (!irDeviceConfig.hide_device) {
                         if (!irDeviceConfig.deviceId) {
-                            this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
+                            await this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.');
                         }
                         if (!irDeviceConfig.deviceId && !irDeviceConfig.configRemoteType) {
-                            this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
+                            await this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.');
                         }
                     }
                 }
@@ -394,16 +410,16 @@ export class SwitchBotPlatform {
         if (!this.config.options.refreshRate) {
             // default 120 seconds (2 minutes)
             this.config.options.refreshRate = 120;
-            this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
+            await this.debugWarnLog('Using Default Refresh Rate (2 minutes).');
         }
         if (!this.config.options.pushRate) {
             // default 100 milliseconds
             this.config.options.pushRate = 0.1;
-            this.debugWarnLog('Using Default Push Rate.');
+            await this.debugWarnLog('Using Default Push Rate.');
         }
         if (!this.config.options.maxRetries) {
             this.config.options.maxRetries = 5;
-            this.debugWarnLog('Using Default Max Retries.');
+            await this.debugWarnLog('Using Default Max Retries.');
         }
         else {
             this.maxRetries = this.config.options.maxRetries;
@@ -411,23 +427,23 @@ export class SwitchBotPlatform {
         if (!this.config.options.delayBetweenRetries) {
             // default 3 seconds
             this.config.options.delayBetweenRetries = 3000;
-            this.debugWarnLog('Using Default Delay Between Retries.');
+            await this.debugWarnLog('Using Default Delay Between Retries.');
         }
         else {
             this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
         }
         if (!this.config.credentials && !this.config.options) {
-            this.debugWarnLog('Missing Credentials');
+            await this.debugWarnLog('Missing Credentials');
         }
         else if (this.config.credentials && !this.config.credentials.notice) {
             if (!this.config.credentials?.token) {
-                this.debugErrorLog('Missing token');
-                this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                await this.debugErrorLog('Missing token');
+                await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
             }
             if (this.config.credentials?.token) {
                 if (!this.config.credentials?.secret) {
-                    this.debugErrorLog('Missing secret');
-                    this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+                    await this.debugErrorLog('Missing secret');
+                    await this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
                 }
             }
         }
@@ -460,12 +476,12 @@ export class SwitchBotPlatform {
             }
             // Move openToken to token
             if (!this.config.credentials.secret) {
-                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken,'
+                await this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken,'
                     + ' "openToken" cconfig has been moved to the "token" config');
                 this.errorLog('"secret" config is not populated, you must populate then please restart Homebridge.');
             }
             else {
-                this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, '
+                await this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken, '
                     + '"openToken" config has been moved to the "token" config, please restart Homebridge.');
             }
             // set the refresh token
@@ -476,10 +492,10 @@ export class SwitchBotPlatform {
             await this.debugWarnLog(`token: ${pluginConfig.credentials.token}`);
             // save the config, ensuring we maintain pretty json
             writeFileSync(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4));
-            this.verifyConfig();
+            await this.verifyConfig();
         }
         catch (e) {
-            this.errorLog(`Update Token: ${e}`);
+            await this.errorLog(`Update Token: ${e}`);
         }
     }
     generateHeaders = () => {
@@ -499,326 +515,215 @@ export class SwitchBotPlatform {
             'Content-Type': 'application/json',
         };
     };
-    /**
-     * this method discovers devices
-     *
-        const t = `${Date.now()}`;
-        const nonce = 'requestID';
-        const data = this.config.credentials?.token + t + nonce;
-        const signTerm = crypto.createHmac('sha256', this.config.credentials?.secret).update(Buffer.from(data, 'utf-8')).digest();
-        const sign = signTerm.toString('base64');
-     */
     async discoverDevices() {
-        if (this.config.credentials?.token) {
-            let retryCount = 0;
-            const maxRetries = this.maxRetries; // Maximum number of retries
-            const delayBetweenRetries = this.delayBetweenRetries; // Delay between retries in milliseconds
-            await this.debugWarnLog(`Retry Count: ${retryCount}`);
-            await this.debugWarnLog(`Max Retries: ${maxRetries}`);
-            await this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
-            while (retryCount < maxRetries) {
-                try {
-                    const { body, statusCode } = await request(Devices, {
-                        headers: this.generateHeaders(),
-                    });
-                    await this.debugWarnLog(`statusCode: ${statusCode}`);
-                    const devicesAPI = await body.json();
-                    await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
-                    await this.debugWarnLog(`devicesAPI Body: ${JSON.stringify(devicesAPI.body)}`);
-                    await this.debugWarnLog(`devicesAPI StatusCode: ${devicesAPI.statusCode}`);
-                    if ((statusCode === 200 || statusCode === 100) && (devicesAPI.statusCode === 200 || devicesAPI.statusCode === 100)) {
-                        await this.debugErrorLog(`statusCode: ${statusCode} & devicesAPI StatusCode: ${devicesAPI.statusCode}`);
-                        // SwitchBot Devices
-                        const deviceLists = devicesAPI.body.deviceList;
-                        await this.debugWarnLog(`DeviceLists: ${JSON.stringify(deviceLists)}`);
-                        await this.debugWarnLog(`DeviceLists Length: ${deviceLists.length}`);
-                        if (!this.config.options?.devices) {
-                            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-                            if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
-                            }
-                            else {
-                                const devices = deviceLists.map((v) => v);
-                                for (const device of devices) {
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
-                                        }
-                                        this.createDevice(device);
-                                    }
-                                }
-                            }
-                        }
-                        else if (this.config.credentials?.token && this.config.options.devices) {
-                            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-                            if (deviceLists.length === 0) {
-                                await this.debugLog(`SwitchBot API Has No Devices With Cloud Services Enabled: ${JSON.stringify(devicesAPI.body)}`);
-                            }
-                            else {
-                                const deviceConfigs = this.config.options?.devices;
-                                const mergeBydeviceId = (a1, a2) => a1.map((itm) => ({
-                                    ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
-                                    ...itm,
-                                }));
-                                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                                await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
-                                for (const device of devices) {
-                                    if (!device.deviceType) {
-                                        device.deviceType = device.configDeviceType;
-                                        this.errorLog(`API has displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
-                                    }
-                                    if (device.deviceType) {
-                                        if (device.configDeviceName) {
-                                            device.deviceName = device.configDeviceName;
-                                        }
-                                        this.createDevice(device);
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
-                        }
-                        if (devicesAPI.body.deviceList.length !== 0) {
-                            this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                        }
-                        else {
-                            await this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-                        }
-                        // IR Devices
-                        const irDeviceLists = devicesAPI.body.infraredRemoteList;
-                        if (!this.config.options?.irdevices) {
-                            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-                            const devices = irDeviceLists.map((v) => v);
-                            for (const device of devices) {
-                                if (device.remoteType) {
-                                    this.createIRDevice(device);
-                                }
-                            }
-                        }
-                        else {
-                            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-                            const irDeviceConfig = this.config.options?.irdevices;
-                            const mergeIRBydeviceId = (a1, a2) => a1.map((itm) => ({
-                                ...a2.find((item) => item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item),
-                                ...itm,
-                            }));
-                            const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
-                            for (const device of devices) {
-                                this.createIRDevice(device);
-                            }
-                        }
-                        if (devicesAPI.body.infraredRemoteList.length !== 0) {
-                            this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                        }
-                        else {
-                            await this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-                        }
-                        break;
-                    }
-                    else {
-                        this.statusCode(statusCode);
-                        this.statusCode(devicesAPI.statusCode);
-                        if (statusCode === 500) {
-                            retryCount++;
-                            this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount} of ${maxRetries}`);
-                            await sleep(delayBetweenRetries);
-                        }
-                    }
+        if (!this.config.credentials?.token) {
+            return this.handleManualConfig();
+        }
+        let retryCount = 0;
+        const maxRetries = this.maxRetries;
+        const delayBetweenRetries = this.delayBetweenRetries;
+        await this.debugWarnLog(`Retry Count: ${retryCount}`);
+        await this.debugWarnLog(`Max Retries: ${maxRetries}`);
+        await this.debugWarnLog(`Delay Between Retries: ${delayBetweenRetries}`);
+        while (retryCount < maxRetries) {
+            try {
+                const { body, statusCode } = await request(Devices, { headers: this.generateHeaders() });
+                await this.debugWarnLog(`statusCode: ${statusCode}`);
+                const devicesAPI = await body.json();
+                await this.debugWarnLog(`devicesAPI: ${JSON.stringify(devicesAPI)}`);
+                if (this.isSuccessfulResponse(statusCode, devicesAPI.statusCode)) {
+                    await this.handleDevices(devicesAPI.body.deviceList);
+                    await this.handleIRDevices(devicesAPI.body.infraredRemoteList);
+                    break;
                 }
-                catch (e) {
+                else {
+                    await this.handleErrorResponse(statusCode, devicesAPI.statusCode, retryCount, maxRetries, delayBetweenRetries);
                     retryCount++;
-                    this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-                    await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
                 }
             }
+            catch (e) {
+                retryCount++;
+                await this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)},`
+                    + ' Submit Bugs Here: https://tinyurl.com/SwitchBotBug');
+                await this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+            }
         }
-        else if (!this.config.credentials?.token && this.config.options?.devices) {
+    }
+    async handleManualConfig() {
+        if (this.config.options?.devices) {
             await this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
-            const deviceConfigs = this.config.options?.devices;
-            const devices = deviceConfigs.map((v) => v);
+            const devices = this.config.options.devices.map((v) => v);
             for (const device of devices) {
                 device.deviceType = device.configDeviceType;
                 device.deviceName = device.configDeviceName;
                 if (device.deviceType) {
-                    this.createDevice(device);
+                    await this.createDevice(device);
+                }
+            }
+        }
+        else {
+            await this.errorLog('Neither SwitchBot Token or Device Config are set.');
+        }
+    }
+    isSuccessfulResponse(statusCode, apiStatusCode) {
+        return (statusCode === 200 || statusCode === 100) && (apiStatusCode === 200 || apiStatusCode === 100);
+    }
+    async handleDevices(deviceLists) {
+        if (!this.config.options?.devices) {
+            await this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+            if (deviceLists.length === 0) {
+                await this.debugLog('SwitchBot API Has No Devices With Cloud Services Enabled');
+            }
+            else {
+                for (const device of deviceLists) {
+                    if (device.deviceType) {
+                        if (device.configDeviceName) {
+                            device.deviceName = device.configDeviceName;
+                        }
+                        await this.createDevice(device);
+                    }
+                }
+            }
+        }
+        else {
+            await this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+            const devices = this.mergeByDeviceId(deviceLists, this.config.options.devices);
+            await this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+            for (const device of devices) {
+                if (!device.deviceType && device.configDeviceType) {
+                    device.deviceType = device.configDeviceType;
+                    await this.warnLog(`API is displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`);
+                }
+                else if (!device.deviceType && !device.configDeviceName) {
+                    await this.errorLog('No deviceType or configDeviceType for device. No device will be created.');
+                }
+                if (device.deviceType) {
+                    if (device.configDeviceName) {
+                        device.deviceName = device.configDeviceName;
+                    }
+                    await this.createDevice(device);
+                }
+            }
+        }
+    }
+    async handleIRDevices(irDeviceLists) {
+        if (!this.config.options?.irdevices) {
+            await this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            for (const device of irDeviceLists) {
+                if (device.remoteType) {
+                    await this.createIRDevice(device);
                 }
             }
         }
         else {
-            this.errorLog('Neither SwitchBot Token or Device Config are not set.');
+            await this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+            const devices = this.mergeByDeviceId(irDeviceLists, this.config.options.irdevices);
+            await this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+            for (const device of devices) {
+                await this.createIRDevice(device);
+            }
+        }
+    }
+    mergeByDeviceId(a1, a2) {
+        const normalizeDeviceId = (deviceId) => deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '');
+        return a1.map(itm => {
+            const matchingItem = a2.find(item => normalizeDeviceId(item.deviceId) === normalizeDeviceId(itm.deviceId));
+            return { ...matchingItem, ...itm };
+        });
+    }
+    async handleErrorResponse(statusCode, apiStatusCode, retryCount, maxRetries, delayBetweenRetries) {
+        await this.statusCode(statusCode);
+        await this.statusCode(apiStatusCode);
+        if (statusCode === 500) {
+            this.infoLog(`statusCode: ${statusCode} Attempt ${retryCount + 1} of ${maxRetries}`);
+            await sleep(delayBetweenRetries);
         }
     }
     async createDevice(device) {
-        switch (device.deviceType) {
-            case 'Humidifier':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createHumidifier(device);
-                break;
-            case 'Hub Mini':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                break;
-            case 'Hub Plus':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                break;
-            case 'Hub 2':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createHub2(device);
-                break;
-            case 'Bot':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createBot(device);
-                break;
-            case 'Meter':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMeter(device);
-                break;
-            case 'MeterPlus':
-            case 'Meter Plus (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMeterPlus(device);
-                break;
-            case 'WoIOSensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createIOSensor(device);
-                break;
-            case 'Water Detector':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createWaterDetector(device);
-                break;
-            case 'Motion Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createMotion(device);
-                break;
-            case 'Contact Sensor':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createContact(device);
-                break;
-            case 'Curtain':
-            case 'Curtain3':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
-                this.createCurtain(device);
-                break;
-            case 'Blind Tilt':
-                await this.debugLog(`Discovered ${device.deviceType} ${device.deviceName}: ${device.deviceId}`);
-                this.createBlindTilt(device);
-                break;
-            case 'Plug':
-            case 'Plug Mini (US)':
-            case 'Plug Mini (JP)':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createPlug(device);
-                break;
-            case 'Smart Lock':
-            case 'Smart Lock Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createLock(device);
-                break;
-            case 'Color Bulb':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createColorBulb(device);
-                break;
-            case 'K10+':
-            case 'WoSweeper':
-            case 'WoSweeperMini':
-            case 'Robot Vacuum Cleaner S1':
-            case 'Robot Vacuum Cleaner S1 Plus':
-            case 'Robot Vacuum Cleaner S10':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createRobotVacuumCleaner(device);
-                break;
-            case 'Ceiling Light':
-            case 'Ceiling Light Pro':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createCeilingLight(device);
-                break;
-            case 'Strip Light':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createStripLight(device);
-                break;
-            case 'Battery Circulator Fan':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
-                this.createFan(device);
-                break;
-            case 'Remote':
-            case 'Indoor Cam':
-            case 'remote with screen+':
-                await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
-                break;
-            default:
-                this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`, +`Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
+        const deviceTypeHandlers = {
+            'Humidifier': this.createHumidifier.bind(this),
+            'Hub 2': this.createHub2.bind(this),
+            'Bot': this.createBot.bind(this),
+            'Meter': this.createMeter.bind(this),
+            'MeterPlus': this.createMeterPlus.bind(this),
+            'Meter Plus (JP)': this.createMeterPlus.bind(this),
+            'WoIOSensor': this.createIOSensor.bind(this),
+            'Water Detector': this.createWaterDetector.bind(this),
+            'Motion Sensor': this.createMotion.bind(this),
+            'Contact Sensor': this.createContact.bind(this),
+            'Curtain': this.createCurtain.bind(this),
+            'Curtain3': this.createCurtain.bind(this),
+            'Blind Tilt': this.createBlindTilt.bind(this),
+            'Plug': this.createPlug.bind(this),
+            'Plug Mini (US)': this.createPlug.bind(this),
+            'Plug Mini (JP)': this.createPlug.bind(this),
+            'Smart Lock': this.createLock.bind(this),
+            'Smart Lock Pro': this.createLock.bind(this),
+            'Color Bulb': this.createColorBulb.bind(this),
+            'K10+': this.createRobotVacuumCleaner.bind(this),
+            'WoSweeper': this.createRobotVacuumCleaner.bind(this),
+            'WoSweeperMini': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S1': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S1 Plus': this.createRobotVacuumCleaner.bind(this),
+            'Robot Vacuum Cleaner S10': this.createRobotVacuumCleaner.bind(this),
+            'Ceiling Light': this.createCeilingLight.bind(this),
+            'Ceiling Light Pro': this.createCeilingLight.bind(this),
+            'Strip Light': this.createStripLight.bind(this),
+            'Battery Circulator Fan': this.createFan.bind(this),
+        };
+        if (deviceTypeHandlers[device.deviceType]) {
+            await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}`);
+            await deviceTypeHandlers[device.deviceType](device);
+        }
+        else if (['Hub Mini', 'Hub Plus', 'Remote', 'Indoor Cam', 'remote with screen'].includes(device.deviceType)) {
+            await this.debugLog(`Discovered ${device.deviceType}: ${device.deviceId}, is currently not supported, device: ${JSON.stringify(device)}`);
+        }
+        else {
+            await this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.deviceType}, is currently not supported.`
+                + ` Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
         }
     }
     async createIRDevice(device) {
-        if (device.connectionType === undefined) {
-            device.connectionType = 'OpenAPI';
-        }
-        switch (device.remoteType) {
-            case 'TV':
-            case 'DIY TV':
-            case 'Projector':
-            case 'DIY Projector':
-            case 'Set Top Box':
-            case 'DIY Set Top Box':
-            case 'IPTV':
-            case 'DIY IPTV':
-            case 'DVD':
-            case 'DIY DVD':
-            case 'Speaker':
-            case 'DIY Speaker':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                if (device.external === undefined) {
-                    device.external = true;
-                    this.createTV(device);
-                }
-                else {
-                    this.createTV(device);
-                }
-                break;
-            case 'Fan':
-            case 'DIY Fan':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createIRFan(device);
-                break;
-            case 'Air Conditioner':
-            case 'DIY Air Conditioner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createAirConditioner(device);
-                break;
-            case 'Light':
-            case 'DIY Light':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createLight(device);
-                break;
-            case 'Air Purifier':
-            case 'DIY Air Purifier':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createAirPurifier(device);
-                break;
-            case 'Water Heater':
-            case 'DIY Water Heater':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createWaterHeater(device);
-                break;
-            case 'Vacuum Cleaner':
-            case 'DIY Vacuum Cleaner':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createVacuumCleaner(device);
-                break;
-            case 'Camera':
-            case 'DIY Camera':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createCamera(device);
-                break;
-            case 'Others':
-                await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
-                this.createOthers(device);
-                break;
-            default:
-                await this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
-                this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
-                this.warnLog('Submit Feature Requests Here: ' + 'https://tinyurl.com/SwitchBotFeatureRequest');
+        device.connectionType = device.connectionType ?? 'OpenAPI';
+        const deviceTypeHandlers = {
+            'TV': this.createTV.bind(this),
+            'DIY TV': this.createTV.bind(this),
+            'Projector': this.createTV.bind(this),
+            'DIY Projector': this.createTV.bind(this),
+            'Set Top Box': this.createTV.bind(this),
+            'DIY Set Top Box': this.createTV.bind(this),
+            'IPTV': this.createTV.bind(this),
+            'DIY IPTV': this.createTV.bind(this),
+            'DVD': this.createTV.bind(this),
+            'DIY DVD': this.createTV.bind(this),
+            'Speaker': this.createTV.bind(this),
+            'DIY Speaker': this.createTV.bind(this),
+            'Fan': this.createIRFan.bind(this),
+            'DIY Fan': this.createIRFan.bind(this),
+            'Air Conditioner': this.createAirConditioner.bind(this),
+            'DIY Air Conditioner': this.createAirConditioner.bind(this),
+            'Light': this.createLight.bind(this),
+            'DIY Light': this.createLight.bind(this),
+            'Air Purifier': this.createAirPurifier.bind(this),
+            'DIY Air Purifier': this.createAirPurifier.bind(this),
+            'Water Heater': this.createWaterHeater.bind(this),
+            'DIY Water Heater': this.createWaterHeater.bind(this),
+            'Vacuum Cleaner': this.createVacuumCleaner.bind(this),
+            'DIY Vacuum Cleaner': this.createVacuumCleaner.bind(this),
+            'Camera': this.createCamera.bind(this),
+            'DIY Camera': this.createCamera.bind(this),
+            'Others': this.createOthers.bind(this),
+        };
+        if (deviceTypeHandlers[device.remoteType]) {
+            await this.debugLog(`Discovered ${device.remoteType}: ${device.deviceId}`);
+            if (device.remoteType.startsWith('DIY') && device.external === undefined) {
+                device.external = true;
+            }
+            await deviceTypeHandlers[device.remoteType](device);
+        }
+        else {
+            await this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`
+                + ` Submit Feature Requests Here: https://tinyurl.com/SwitchBotFeatureRequest, device: ${JSON.stringify(device)}`);
         }
     }
     async createHumidifier(device) {
@@ -1979,7 +1884,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -1987,7 +1891,7 @@ export class SwitchBotPlatform {
             // this is imported from `platformAccessory.ts`
             new TV(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2037,7 +1941,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2046,7 +1949,7 @@ export class SwitchBotPlatform {
             new IRFan(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2096,7 +1999,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2105,7 +2007,7 @@ export class SwitchBotPlatform {
             new Light(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2155,7 +2057,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2164,7 +2065,7 @@ export class SwitchBotPlatform {
             new AirConditioner(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2214,7 +2115,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2223,7 +2123,7 @@ export class SwitchBotPlatform {
             new AirPurifier(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2273,7 +2173,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2282,7 +2181,7 @@ export class SwitchBotPlatform {
             new WaterHeater(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2332,7 +2231,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2341,7 +2239,7 @@ export class SwitchBotPlatform {
             new VacuumCleaner(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2391,7 +2289,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2400,7 +2297,7 @@ export class SwitchBotPlatform {
             new Camera(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2450,7 +2347,6 @@ export class SwitchBotPlatform {
                 ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
                 : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName);
             accessory.context.connectionType = await this.connectionType(device);
-            accessory.context.connectionType = device.connectionType;
             accessory.context.version = device.firmware ?? device.version ?? this.version ?? '0.0.0';
             const newOrExternal = !device.external ? 'Adding new' : 'Loading external';
             await this.infoLog(`${newOrExternal} accessory: ${accessory.displayName} deviceId: ${device.deviceId}`);
@@ -2459,7 +2355,7 @@ export class SwitchBotPlatform {
             new Others(this, accessory, device);
             await this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
             // publish device externally or link the accessory to your platform
-            this.externalOrPlatformIR(device, accessory);
+            this.externalOrPlatform(device, accessory);
             this.accessories.push(accessory);
         }
         else {
@@ -2467,13 +2363,6 @@ export class SwitchBotPlatform {
         }
     }
     async registerCurtains(device) {
-        /*function isCurtainDevice(device: device & devicesConfig): device is (curtain | curtain3) & devicesConfig {
-          return device.deviceType === 'Curtain' || device.deviceType === 'Curtain3';
-        }
-    
-        function isBlindTiltDevice(device: device & devicesConfig): device is blindTilt & devicesConfig {
-          return device.deviceType === 'Blind Tilt';
-        }*/
         let registerWindowCovering;
         if (isCurtainDevice(device)) {
             await this.debugWarnLog(`deviceName: ${device.deviceName} deviceId: ${device.deviceId}, curtainDevicesIds: ${device.curtainDevicesIds},`
@@ -2631,103 +2520,62 @@ export class SwitchBotPlatform {
         }
         return registerDevice;
     }
-    async externalOrPlatformIR(device, accessory) {
-        /**
-         * Publish as external accessory
-         * Only one TV can exist per bridge, to bypass this limitation, you should
-         * publish your TV as an external accessory.
-         */
-        if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            this.externalAccessory(accessory);
-        }
-        else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
-            this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
-        }
-    }
     async externalOrPlatform(device, accessory) {
-        if (device.external) {
-            await this.debugWarnLog(`${accessory.displayName} External Accessory Mode`);
-            await this.externalAccessory(accessory);
+        const { displayName } = accessory;
+        const isExternal = device.external ?? false;
+        if (isExternal) {
+            await this.debugWarnLog(`${displayName} External Accessory Mode`);
+            this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
         }
         else {
-            await this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+            await this.debugLog(`${displayName} External Accessory Mode: ${isExternal}`);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
     }
-    async externalAccessory(accessory) {
-        this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
-    }
     unregisterPlatformAccessories(existingAccessory) {
+        const { displayName } = existingAccessory;
         // remove platform accessories when no longer present
         this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
-        this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
+        this.warnLog(`Removing existing accessory from cache: ${displayName}`);
     }
+    /**
+     * Handles the status codes returned by the device and logs appropriate messages.
+     *
+     * @param statusCode - The status code returned by the device.
+     * @returns A promise that resolves when the logging is complete.
+     */
     async statusCode(statusCode) {
-        switch (statusCode) {
-            case 151:
-                await this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: ` +
-                    'https://tinyurl.com/SwitchBotFeatureRequest');
-                break;
-            case 152:
-                await this.errorLog(`Device not found, statusCode: ${statusCode}`);
-                break;
-            case 160:
-                await this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`);
-                break;
-            case 161:
-                await this.errorLog(`Device is offline, statusCode: ${statusCode}`);
-                break;
-            case 171:
-                await this.errorLog(`is offline, statusCode: ${statusCode}`);
-                break;
-            case 190:
-                await this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
-                break;
-            case 100:
-                await this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
-                break;
-            case 200:
-                await this.debugLog(`Request successful, statusCode: ${statusCode}`);
-                break;
-            case 400:
-                await this.errorLog('Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request '
-                    + `payload, statusCode: ${statusCode}`);
-                break;
-            case 401:
-                await this.errorLog('Unauthorized,	Authorization for the API is required, but the request has not been authenticated, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 403:
-                await this.errorLog('Forbidden,	The request has been authenticated but does not have appropriate permissions, or a requested resource is not '
-                    + `found, statusCode: ${statusCode}`);
-                break;
-            case 404:
-                await this.errorLog(`Not Found,	Specifies the requested path does not exist, statusCode: ${statusCode}`);
-                break;
-            case 406:
-                await this.errorLog('Not Acceptable,	The client has requested a MIME type via the Accept header for a value not supported by the server, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 415:
-                await this.errorLog('Unsupported Media Type,	The client has defined a contentType header that is not supported by the server, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 422:
-                await this.errorLog('Unprocessable Entity,	The client has made a valid request, but the server cannot process it. This is often used for '
-                    + `APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
-                break;
-            case 429:
-                await this.errorLog('Too Many Requests,	The client has exceeded the number of requests allowed for a given time window, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 500:
-                await this.errorLog('Internal Server Error,	An unexpected error on the SmartThings servers has occurred. These errors should be rare, '
-                    + `statusCode: ${statusCode}`);
-                break;
-            default:
-                await this.errorLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
+        const messages = {
+            151: `Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: 
+            https://tinyurl.com/SwitchBotFeatureRequest`,
+            152: `Device not found, statusCode: ${statusCode}`,
+            160: `Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`,
+            161: `Device is offline, statusCode: ${statusCode}`,
+            171: `is offline, statusCode: ${statusCode}`,
+            190: `Requests reached the daily limit, statusCode: ${statusCode}`,
+            100: `Command successfully sent, statusCode: ${statusCode}`,
+            200: `Request successful, statusCode: ${statusCode}`,
+            400: `Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request payload, 
+            statusCode: ${statusCode}`,
+            401: `Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`,
+            403: `Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found, 
+            statusCode: ${statusCode}`,
+            404: `Not Found, Specifies the requested path does not exist, statusCode: ${statusCode}`,
+            406: `Not Acceptable, The client has requested a MIME type via the Accept header for a value not supported by the server, 
+            statusCode: ${statusCode}`,
+            415: `Unsupported Media Type, The client has defined a contentType header that is not supported by the server, statusCode: ${statusCode}`,
+            422: `Unprocessable Entity, The client has made a valid request, but the server cannot process it. This is often used for APIs for which 
+            certain limits have been exceeded, statusCode: ${statusCode}`,
+            429: `Too Many Requests, The client has exceeded the number of requests allowed for a given time window, statusCode: ${statusCode}`,
+            500: `Internal Server Error, An unexpected error on the SmartThings servers has occurred. These errors should be rare, 
+            statusCode: ${statusCode}`,
+        };
+        const message = messages[statusCode] ?? `Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`;
+        if ([100, 200].includes(statusCode)) {
+            await this.debugLog(message);
+        }
+        else {
+            await this.errorLog(message);
         }
     }
     async retryRequest(deviceMaxRetries, deviceDelayBetweenRetries, url, options) {
@@ -2755,57 +2603,43 @@ export class SwitchBotPlatform {
     }
     // BLE Connection
     async connectBLE(accessory, device) {
-        let switchbot;
         try {
-            const SwitchBot = (await import('node-switchbot')).SwitchBot;
-            queueScheduler.schedule(() => (switchbot = new SwitchBot()));
+            const { SwitchBot } = await import('node-switchbot');
+            const switchbot = new SwitchBot();
+            queueScheduler.schedule(async () => switchbot);
             await this.debugLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}`);
+            return switchbot;
         }
         catch (e) {
-            switchbot = false;
-            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' found: ${switchbot}, Error: ${e}`);
+            await this.errorLog(`${device.deviceType}: ${accessory.displayName} 'node-switchbot' not found, Error: ${e}`);
+            return false;
         }
-        return switchbot;
     }
     async getVersion() {
         const json = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
         await this.debugLog(`Plugin Version: ${json.version}`);
         this.version = json.version;
+        return json.version;
     }
     async getPlatformConfigSettings() {
+        const { options } = this.config;
         const platformConfig = {};
-        if (this.config.options) {
-            if (this.config.options.logging) {
-                platformConfig.logging = this.config.options.logging;
-            }
-            if (this.config.options.refreshRate) {
-                platformConfig.refreshRate = this.config.options.refreshRate;
-            }
-            if (this.config.options.updateRate) {
-                platformConfig.updateRate = this.config.options.updateRate;
-            }
-            if (this.config.options.pushRate) {
-                platformConfig.pushRate = this.config.options.pushRate;
-            }
-            if (this.config.options.maxRetries) {
-                this.maxRetries = this.config.options.maxRetries;
-                platformConfig.maxRetries = this.config.options.maxRetries;
-            }
-            else {
-                this.maxRetries = 3;
-                this.debugWarnLog('Using Default Max Retries');
-                platformConfig.maxRetries = this.maxRetries;
-            }
-            if (this.config.options.delayBetweenRetries) {
-                this.delayBetweenRetries = this.config.options.delayBetweenRetries * 1000;
-                platformConfig.delayBetweenRetries = this.config.options.delayBetweenRetries;
-            }
-            else {
-                this.delayBetweenRetries = 3000;
-                this.debugWarnLog('Using Default Delay Between Retries');
-                platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
-            }
-            if (Object.entries(platformConfig).length !== 0) {
+        if (options) {
+            platformConfig.logging = options.logging;
+            platformConfig.refreshRate = options.refreshRate;
+            platformConfig.updateRate = options.updateRate;
+            platformConfig.pushRate = options.pushRate;
+            this.maxRetries = options.maxRetries || 3;
+            platformConfig.maxRetries = this.maxRetries;
+            if (!options.maxRetries) {
+                await this.debugWarnLog('Using Default Max Retries');
+            }
+            this.delayBetweenRetries = (options.delayBetweenRetries || 3) * 1000;
+            platformConfig.delayBetweenRetries = this.delayBetweenRetries / 1000;
+            if (!options.delayBetweenRetries) {
+                await this.debugWarnLog('Using Default Delay Between Retries');
+            }
+            if (Object.keys(platformConfig).length) {
                 await this.debugLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
             }
             this.platformConfig = platformConfig;
@@ -2828,31 +2662,42 @@ export class SwitchBotPlatform {
     }
     /**
      * Validate and clean a string value for a Name Characteristic.
-   * @param displayName
-   * @param name
-   * @param value
-   * @returns string value
-   */
+     * @param displayName - The display name of the accessory.
+     * @param name - The name of the characteristic.
+     * @param value - The value to be validated and cleaned.
+     * @returns The cleaned string value.
+    */
     async validateAndCleanDisplayName(displayName, name, value) {
-        const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9 ']*[a-zA-Z0-9]$/;
-        const invalidCharsPattern = /[^a-zA-Z0-9 ']/g;
-        const invalidStartEndPattern = /^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g;
-        if (!validPattern.test(value)) {
-            this.warnLog(`WARNING: The accessory '${displayName}' has an invalid '${name}' characteristic ('${value}'). Please use only alphanumeric,`
-                + ' space, and apostrophe characters. Ensure it starts and ends with an alphabetic or numeric character, and avoid emojis. This may'
-                + ' prevent the accessory from being added in the Home App or cause unresponsiveness.');
-            // Remove invalid characters
-            if (invalidCharsPattern.test(value)) {
-                this.warnLog(`Removing invalid characters from '${name}' characteristic`);
-                value = value.replace(invalidCharsPattern, '');
-            }
-            // Ensure it starts and ends with an alphanumeric character
-            if (invalidStartEndPattern.test(value)) {
-                this.warnLog(`Removing invalid starting or ending characters from '${name}' characteristic`);
-                value = value.replace(invalidStartEndPattern, '');
-            }
-        }
-        return value;
+        if (this.config.options?.allowInvalidCharacters) {
+            return value;
+        }
+        else {
+            const validPattern = new RegExp(/^[\p{L}\p{N}][\p{L}\p{N} ']*[\p{L}\p{N}]$/u);
+            const invalidCharsPattern = /[^\p{L}\p{N} ']/gu;
+            const invalidStartEndPattern = /^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu;
+            if (typeof value === 'string' && !validPattern.test(value)) {
+                await this.warnLog(`WARNING: The accessory '${displayName}' has an invalid '${name}' characteristic ('${value}').`
+                    + ' Please use only alphanumeric, space, and apostrophe characters. Ensure it starts and ends with an alphabetic or numeric character,'
+                    + ' and avoid emojis. This may prevent the accessory from being added in the Home App or cause unresponsiveness.');
+                // Remove invalid characters
+                if (invalidCharsPattern.test(value)) {
+                    const before = value;
+                    await this.warnLog(`Removing invalid characters from '${name}' characteristic, if you feel this is incorrect,`
+                        + ' please enable \'allowInvalidCharacter\' in the config to allow all characters');
+                    value = value.replace(invalidCharsPattern, '');
+                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                }
+                // Ensure it starts and ends with an alphanumeric character
+                if (invalidStartEndPattern.test(value)) {
+                    const before = value;
+                    await this.warnLog(`Removing invalid starting or ending characters from '${name}' characteristic, if you feel this is incorrect,`
+                        + ' please enable \'allowInvalidCharacter\' in the config to allow all characters');
+                    value = value.replace(invalidStartEndPattern, '');
+                    await this.warnLog(`${name} Before: '${before}' After: '${value}'`);
+                }
+            }
+            return value;
+        }
     }
     /**
      * If device level logging is turned on, log to log.warn